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/IT.php

Documentation is available at IT.php

  1. <?PHP
  2. /**
  3.  * patTemplate reader that reads HTML_Template_IT files
  4.  *
  5.  * $Id: IT.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 HTML_Template_IT files
  17.  *
  18.  * @package        patTemplate
  19.  * @subpackage    Readers
  20.  * @author        Stephan Schmidt <[email protected]>
  21.  */
  22. class patTemplate_Reader_IT extends patTemplate_Reader
  23. {
  24.    /**
  25.     * reader name
  26.     * @access    private
  27.     * @var        string 
  28.     */
  29.     var    $_name    =    'IT';
  30.  
  31.    /**
  32.     * files that have been used
  33.     * @access    private
  34.     * @var        array 
  35.     */
  36.     var    $_files    =    array();
  37.  
  38.    /**
  39.     * parse templates from string
  40.     *
  41.     * @access    private
  42.     * @param    string        string to parse
  43.     * @return    array        templates
  44.     */
  45.     function parseString( $string )
  46.     {
  47.         /**
  48.          * apply input filter before parsing
  49.          */
  50.         $string = $this->_tmpl->applyInputFilters( $string );
  51.  
  52.         $this->_inheritAtts    =    array();
  53.         $this->_elStack        =    array();
  54.         $this->_data        =    array( '' );
  55.         $this->_tmplStack    =    array();
  56.         $this->_depth        =    0;
  57.         $this->_templates    =    array();
  58.         $this->_path        =    array();
  59.         $this->_processedData    =    '';
  60.  
  61.         $this->_defaultAtts    =    $this->_tmpl->getDefaultAttributes();
  62.  
  63.         if( !isset( $this->_defaultAtts['autoload'] ) )
  64.             $this->_defaultAtts['autoload']    =    'on';
  65.  
  66.         /**
  67.          * create a special root template
  68.          */
  69.         $attributes        = $this->_rootAtts;
  70.         $attributes['name']    = '__global';
  71.  
  72.         $rootTemplate    = $this->_initTemplate( $attributes );
  73.  
  74.         array_push( $this->_tmplStack, $rootTemplate );
  75.  
  76.         /**
  77.          *start parsing
  78.          */
  79.         $patNamespace    =    strtolower( $this->_tmpl->getNamespace() );
  80.  
  81.         $regexp    =    '/(<!-- (BEGIN|END) ([a-zA-Z]+) -->)/m';
  82.  
  83.         $tokens    =    preg_split( $regexp, $string, -1, PREG_SPLIT_DELIM_CAPTURE );
  84.  
  85.         /**
  86.          * the first token is always character data
  87.          * Though it could just be empty
  88.          */
  89.         if( $tokens[0] != '' )
  90.             $this->_characterData( $tokens[0] );
  91.  
  92.         $cnt    =    count( $tokens );
  93.         $i        =    1;
  94.         // process all tokens
  95.         while( $i < $cnt )
  96.         {
  97.             $fullTag    =    $tokens[$i++];
  98.             $closing    =    strtoupper( $tokens[$i++] ) == 'END' ? true : false;
  99.             $tmplName    =    $tokens[$i++];
  100.             $namespace  =   $patNamespace;
  101.             $tagname    =    'tmpl';
  102.             $data        =    $tokens[$i++];
  103.  
  104.             /**
  105.              * is it a closing tag?
  106.              */
  107.             if( $closing === true )
  108.             {
  109.                 $result    =    $this->_endElement( $namespace, $tagname );
  110.                 if( patErrorManager::isError( $result ) )
  111.                 {
  112.                     return    $result;
  113.                 }
  114.                 $this->_characterData( $data );
  115.                 continue;
  116.             }
  117.  
  118.             $attributes    =    array( 'name' => $tmplName );
  119.             $result     =    $this->_startElement( $namespace, $tagname, $attributes );
  120.             if( patErrorManager::isError( $result ) )
  121.             {
  122.                 return    $result;
  123.             }
  124.  
  125.             $this->_characterData( $data );
  126.         }
  127.  
  128.         $rootTemplate = array_pop( $this->_tmplStack );
  129.  
  130.         $this->_closeTemplate( $rootTemplate, $this->_data[0] );
  131.  
  132.         /**
  133.          * check for tags that are still open
  134.          */
  135.         if( $this->_depth > 0 )
  136.         {
  137.             $el    =    array_pop( $this->_elStack );
  138.             return patErrorManager::raiseError(
  139.                 PATTEMPLATE_READER_ERROR_NO_CLOSING_TAG,
  140.                 $this->_createErrorMessage( "No closing tag for {$el['ns']}:{$el['name']} found" )
  141.             );
  142.         }
  143.  
  144.         return    $this->_templates;
  145.     }
  146.  
  147.    /**
  148.     * read templates from any input
  149.     *
  150.     * @final
  151.     * @access    public
  152.     * @param    string    file to parse
  153.     * @return    array    templates
  154.     */
  155.     function readTemplates( $input )
  156.     {
  157.         $this->_currentInput = $input;
  158.         $fullPath    =    $this->_resolveFullPath( $input );
  159.         if( patErrorManager::isError( $fullPath ) )
  160.             return $fullPath;
  161.         $content    =    $this->_getFileContents( $fullPath );
  162.         if( patErrorManager::isError( $content ) )
  163.             return $content;
  164.  
  165.         $templates    =    $this->parseString( $content );
  166.  
  167.         return    $templates;
  168.     }
  169.  
  170.    /**
  171.     * load template from any input
  172.     *
  173.     * If the a template is loaded, the content will not get
  174.     * analyzed but the whole content is returned as a string.
  175.     *
  176.     * @abstract    must be implemented in the template readers
  177.     * @param    mixed    input to load from.
  178.     *                     This can be a string, a filename, a resource or whatever the derived class needs to read from
  179.     * @return    string  template content
  180.     */
  181.     function loadTemplate( $input )
  182.     {
  183.         $fullPath    =    $this->_resolveFullPath( $input );
  184.         if( patErrorManager::isError( $fullPath ) )
  185.             return $fullPath;
  186.         return $this->_getFileContents( $fullPath );
  187.     }
  188.  
  189.    /**
  190.     * resolve path for a template
  191.     *
  192.     * @access    private
  193.     * @param    string        filename
  194.     * @return    string        full path
  195.     */
  196.     function _resolveFullPath( $filename )
  197.     {
  198.         $baseDir  = $this->getTemplateRoot();
  199.         $fullPath = $baseDir . '/' . $filename;
  200.         return    $fullPath;
  201.     }
  202.  
  203.    /**
  204.     * get the contents of a file
  205.     *
  206.     * @access    private
  207.     * @param    string        filename
  208.     * @return    string        file contents
  209.     */
  210.     function _getFileContents( $file )
  211.     {
  212.         if( !file_exists( $file ) || !is_readable( $file ) )
  213.         {
  214.             return patErrorManager::raiseError(
  215.                                         PATTEMPLATE_READER_ERROR_NO_INPUT,
  216.                                         "Could not load templates from $file."
  217.                                         );
  218.         }
  219.  
  220.         if( function_exists( 'file_get_contents' ) )
  221.             $content    =    @file_get_contents( $file );
  222.         else
  223.             $content    =    implode( '', file( $file ) );
  224.  
  225.         /**
  226.          * store the file name
  227.          */
  228.         array_push( $this->_files, $file );
  229.  
  230.         return    $content;
  231.     }
  232. }
  233. ?>
Documentation generated on Mon, 05 Mar 2007 21:08:53 +0000 by phpDocumentor 1.3.1