Support Joomla!

Joomla! 1.5 Documentation

Packages

Package: patTemplate

Developer Network License

The Joomla! Developer Network content is © copyright 2006 by the individual contributors and can be used in accordance with the Creative Commons License, Attribution- NonCommercial- ShareAlike 2.5
Source code for file /pattemplate/patTemplate/Reader/File.php

Documentation is available at File.php

  1. <?PHP
  2. /**
  3.  * patTemplate Reader that reads from a file
  4.  *
  5.  * $Id: File.php 413 2005-08-05 13:51:01Z schst $
  6.  *
  7.  * @package        patTemplate
  8.  * @subpackage    Readers
  9.  * @author        Stephan Schmidt <[email protected]>
  10.  */
  11.  
  12. // Check to ensure this file is within the rest of the framework
  13. defined('JPATH_BASE') or die();
  14.  
  15. /**
  16.  * patTemplate Reader that reads from a file
  17.  *
  18.  * $Id: File.php 413 2005-08-05 13:51:01Z schst $
  19.  *
  20.  * @package        patTemplate
  21.  * @subpackage    Readers
  22.  * @author        Stephan Schmidt <[email protected]>
  23.  */
  24. class patTemplate_Reader_File extends patTemplate_Reader
  25. {
  26.    /**
  27.     * reader name
  28.     * @access    private
  29.     * @var        string 
  30.     */
  31.     var    $_name    =    'File';
  32.  
  33.    /**
  34.     * flag to indicate, that current file is remote
  35.     *
  36.     * @access    private
  37.     * @var        boolean 
  38.     */
  39.     var $_isRemote = false;
  40.  
  41.    /**
  42.     * all files, that have been opened
  43.     *
  44.     * @access    private
  45.     * @var        array 
  46.     */
  47.     var $_files = array();
  48.  
  49.    /**
  50.     * read templates from any input
  51.     *
  52.     * @final
  53.     * @access    public
  54.     * @param    string    file to parse
  55.     * @return    array    templates
  56.     */
  57.     function readTemplates( $input )
  58.     {
  59.         if (isset($this->_rootAtts['relative'])) {
  60.             $relative = $this->_rootAtts['relative'];
  61.         } else {
  62.             $relative = false;
  63.         }
  64.         if ($relative === false) {
  65.                $this->_currentInput = $input;
  66.         } else {
  67.             $this->_currentInput = dirname($relative) . DIRECTORY_SEPARATOR . $input;
  68.         }
  69.  
  70.         $fullPath = $this->_resolveFullPath($input, $relative);
  71.         if (patErrorManager::isError($fullPath)) {
  72.             return $fullPath;
  73.         }
  74.         $content = $this->_getFileContents($fullPath);
  75.         if (patErrorManager::isError($content)) {
  76.             return $content;
  77.         }
  78.  
  79.         $templates = $this->parseString($content);
  80.  
  81.         return    $templates;
  82.     }
  83.  
  84.    /**
  85.     * load template from any input
  86.     *
  87.     * If the a template is loaded, the content will not get
  88.     * analyzed but the whole content is returned as a string.
  89.     *
  90.     * @abstract    must be implemented in the template readers
  91.     * @param    mixed    input to load from.
  92.     *                     This can be a string, a filename, a resource or whatever the derived class needs to read from
  93.     * @return    string  template content
  94.     */
  95.     function loadTemplate( $input )
  96.     {
  97.         if (isset($this->_rootAtts['relative'])) {
  98.             $relative = $this->_rootAtts['relative'];
  99.         } else {
  100.             $relative = false;
  101.         }
  102.         $fullPath    =    $this->_resolveFullPath( $input, $relative );
  103.         if( patErrorManager::isError( $fullPath ) )
  104.             return $fullPath;
  105.         return $this->_getFileContents( $fullPath );
  106.     }
  107.  
  108.    /**
  109.     * resolve path for a template
  110.     *
  111.     * @access    private
  112.     * @param    string            filename
  113.     * @param    boolean|string filename for relative path calculation
  114.     * @return    string            full path
  115.     */
  116.     function _resolveFullPath( $filename, $relativeTo = false )
  117.     {
  118.         if (preg_match( '/^[a-z]+:\/\//', $filename )) {
  119.             $this->_isRemote = true;
  120.             return $filename;
  121.         } else {
  122.             $rootFolders = $this->getTemplateRoot();
  123.             if (!is_array($rootFolders)) {
  124.                 $rootFolders = array($rootFolders);
  125.             }
  126.             foreach ($rootFolders as $root) {
  127.                 if ($relativeTo === false) {
  128.                     $baseDir = $root;
  129.                 } else {
  130.                     $baseDir = $root . DIRECTORY_SEPARATOR . dirname($relativeTo);
  131.                 }
  132.                 $fullPath = $baseDir . DIRECTORY_SEPARATOR . $filename;
  133.                 if (file_exists($fullPath)) {
  134.                     return $fullPath;
  135.                 }
  136.             }
  137.         }
  138.         return patErrorManager::raiseError(
  139.                                     PATTEMPLATE_READER_ERROR_NO_INPUT,
  140.                                     "Could not load templates from $filename."
  141.                                     );
  142.     }
  143.  
  144.    /**
  145.     * get the contents of a file
  146.     *
  147.     * @access    private
  148.     * @param    string        filename
  149.     * @return    string        file contents
  150.     */
  151.     function _getFileContents( $file )
  152.     {
  153.         if (!$this->_isRemote && (!file_exists($file) || !is_readable($file))) {
  154.             return patErrorManager::raiseError(
  155.                                         PATTEMPLATE_READER_ERROR_NO_INPUT,
  156.                                         "Could not load templates from $file."
  157.                                         );
  158.         }
  159.  
  160.         if (function_exists('file_get_contents')) {
  161.             $content = @file_get_contents( $file );
  162.         } else {
  163.             $content = implode('', file($file));
  164.         }
  165.  
  166.         /**
  167.          * store the file name
  168.          */
  169.         array_push($this->_files, $file);
  170.  
  171.         return $content;
  172.     }
  173. }
  174. ?>
Documentation generated on Mon, 05 Mar 2007 20:58:35 +0000 by phpDocumentor 1.3.1