Home arrow PHP arrow Page 3 - Working with Multiple Template Files to Separate Logic from Presentation

Parsing multiple template files: redefining the “TemplateProcessor” class - PHP

Welcome to the last part of the series “Separating logic from presentation.” In three tutorials, this series teaches you how to develop an expandable template processor class using PHP 5, which exposes some useful features, such as recursive placeholder replacement, MySQL result sets processing, and parsing of dynamic PHP files, among others.

TABLE OF CONTENTS:
  1. Working with Multiple Template Files to Separate Logic from Presentation
  2. Setting up the basics of chunked caching: defining multiple template files
  3. Parsing multiple template files: redefining the “TemplateProcessor” class
  4. Putting the “TemplateProcessor” class to work: setting up a concrete example
By: Alejandro Gervasio
Rating: starstarstarstarstar / 9
May 16, 2006

print this article
SEARCH DEV SHED

TOOLS YOU CAN USE

advertisement

Before I list the corresponding source code of the improved “TemplateProcessor” class, let me first explain in a few words how it will work. Since this class must use all the template files previously defined, it will take up an additional array (aside from the array of input tags), which will contain the shortened name of the template file for being parsed, along with its cache expiration time, expressed in seconds.

If this explanation doesn’t ring any bells to you, don’t worry for the moment. When I set up a practical example, you’ll understand how this array will be used by the template processor.

Now, after a short introduction, please take a look at the signature of the modified “TemplateProcessor” class:

class TemplateProcessor{
    // declare data members
    private $output;
    private $rowTag='p';
    private $tags;
    private $templateFile;
    private $cacheFile;
    private $expiry;
    public function __construct($tags=array(),$pageSections=array
()){
        if(count($tags)<1||count($pageSections)<1){
            throw new Exception('Invalid number of parameters for
template processor');
        }
        foreach($pageSections as $key=>$expiry){
            // define template files
            $this->templateFile[$key]=$key.'_template.htm';
            // define cache files
            $this->cacheFile[$key]=md5($key).'.txt';
            // assign cache expiration values
            $this->expiry[$key]=$expiry;
            // assign tags for replacement
            $this->tags[$key]=$tags[$key];
            // initialize page outputs
            $this->output[$key]='';
        }
        foreach($this->cacheFile as $key=>$cacheFile){
            // check if cache files are valid
            if($this->isCacheValid($key)){
                // read data from cache files
                $this->output[$key]=$this->readCache($key);
            }
            else{
                // read template files
                $this->output[$key]=file_get_contents($this-
>templateFile[$key]);
                // process template files
                $this->processTemplate($tags[$key],$key);
                // clean up empty tags
                $this->output[$key]=preg_replace("/{w}
|}/",'',$this->output[$key]);
                // write crunched data to cache files
                $this->writeCache($key);
            }
        }
    }
    // check validity of cache files
    private function isCacheValid($key){
        // determine if cache file is valid or not
        if(file_exists($this->cacheFile[$key])&&filemtime($this-
>cacheFile[$key])>(time()-$this->expiry[$key])){
            return true;
        }
        return false;
    }
    // process template file
    private function processTemplate($tags,$key){
        foreach($tags as $tag=>$data){
            // if data is array, traverse recursive array of tags
            if(is_array($data)){
                $this->output[$key]=preg_replace("/
{$tag/",'',$this->output[$key]);
                $this->processTemplate($data,$key);
            }
            // if data is a file, fetch processed file
            elseif(file_exists($data)){
                $data=$this->processFile($data);
            }
            // if data is a MySQL result set, obtain a formatted
list of database rows
            elseif(@get_resource_type($data)=='mysql result'){
                $rows='';
                while($row=mysql_fetch_row($data)){
                    $cols='';
                    foreach($row as $col){
                        $cols.='&nbsp;'.$col.'&nbsp;';
                    }
                    $rows.='<'.$this-
>rowTag.'>'.$cols.'</'.$this->rowTag.'>';
                }
                $data=$rows;
            }
            // if data contains the '[code]' elimiter, parse data
as PHP code
            elseif(substr($data,0,6)=='[code]'){
                $data=eval(substr($data,6));
            }
            $this->output[$key]=str_replace('{'.$tag.'}',$data,$this->output[$key]);
        }
    }
    // process input file
    private function processFile($file){
          ob_start();
          include($file);
          $contents=ob_get_contents();
          ob_end_clean();
          return $contents;
    }
    // write compressed data to cache file
    private function writeCache($key){
        if(!$fp=fopen($this->cacheFile[$key],'w')){
            throw new Exception('Error writing data to cache
file');
        }
        fwrite($fp,$this->getCrunchedHTML($key));
        fclose($fp);
    }
    // read compressed data from cache file
    private function readCache($key){
        if(!$cacheContents=file_get_contents($this->cacheFile
[$key])){
            throw new Exception('Error reading data from cache
file');
        }
        return $cacheContents;
    }
    // return overall output
    public function getHTML(){
        $html='';
        foreach($this->output as $output){
            $html.=$output;
        }
        return $html;
    }
    // return crunched output
    private function getCrunchedHTML($key){
        // crunch (X)HTML content & compress it with gzip
        $this->output[$key]=preg_replace("/(rn|n)/","",$this-
>output[$key]);
        // return compressed (X)HTML content
        return $this->output[$key];
    }
}

As shown above, now the “TemplateProcessor” class looks a little more complex and intimidating, but essentially it implements the same logic that you learned in the previous articles. Since now the class must deal with multiple template and cache files, most of its properties have been redefined as arrays, a fact that you’ll clearly see if you analyze the signature of the constructor.

Notice how this method uses a “foreach” loop, in order to create the arrays corresponding to the cache and template files, the respective cache expiration times, and the parsed output of each section of the web page. Also, following the same approach, the method checks out, in sequence, the validity of each cache file and determines whether the template file in question should be parsed and saved later on, or the parsed contents should be directly fetched from the cache file.

In general terms, you can see that all the subsequent methods of the class use the same approach in working with different cache and template files, and most of them utilize array keys to handle each element in question. Therefore, if you already read the previous articles of the series, you shouldn’t have any problems understanding how the template processor works.

Well, before I proceed to coding a hands-on example, I’d like to point out one last thing: notice the way I redefined the private “getCrunchedHTML()” method, instead of compressing the parsed template files and saving them to cache. I deliberately defined the method like this, because I wanted to make the class flexible enough to include the data compression method that you most prefer. In this case, I decided only to remove new line characters from the parsed template files, but you can change this and use another technique for compressing data.

At this point, after explaining how the “TemplateProcessor” class implements chunked caching on multiple template files, it’s a good time to demonstrate its useful capabilities. Therefore, go ahead and read the next section, in order to see the template processor in action. It’s really worth it, trust me.



 
 
>>> More PHP Articles          >>> More By Alejandro Gervasio
 

blog comments powered by Disqus
escort Bursa Bursa escort Antalya eskort
   

PHP ARTICLES

- Hackers Compromise PHP Sites to Launch Attac...
- Red Hat, Zend Form OpenShift PaaS Alliance
- PHP IDE News
- BCD, Zend Extend PHP Partnership
- PHP FAQ Highlight
- PHP Creator Didn't Set Out to Create a Langu...
- PHP Trends Revealed in Zend Study
- PHP: Best Methods for Running Scheduled Jobs
- PHP Array Functions: array_change_key_case
- PHP array_combine Function
- PHP array_chunk Function
- PHP Closures as View Helpers: Lazy-Loading F...
- Using PHP Closures as View Helpers
- PHP File and Operating System Program Execut...
- PHP: Effects of Wrapping Code in Class Const...

Developer Shed Affiliates

 


Dev Shed Tutorial Topics: