lib/MLIB/Tpl/HIT.php

   1 <?php /* vim: set binary expandtab tabstop=4 shiftwidth=4 textwidth=80:
   2 -------------------------------------------------------------------------------
   3                                     mlib
   4 -------------------------------------------------------------------------------
   5 This file is part of mlib.
   6
   7 mlib is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU Lesser General Public License as published by the Free
   9 Software Foundation; either version 2 of the License, or (at your option)
  10 any later version.
  11
  12 mlib is distributed in the hope that it will be useful, but WITHOUT
  13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  14 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  15 details.
  16
  17 You should have received a copy of the GNU Lesser General Public License; if
  18 not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  19 Boston, MA  02111-1307  USA
  20 -------------------------------------------------------------------------------
  21 Creado: Wed Jun 17 19:03:14 2003
  22 Autor: Leandro Lucarella <luca@lugmen.org.ar>
  23 -------------------------------------------------------------------------------
  24 $Id$
  25 -----------------------------------------------------------------------------*/
  26
  27 /**
  28  * Hooks vs IT Template Engine.
  29  * Hooks vs IT (HIT) is a simple template implementation, based on hooks and IT
  30  * template systems.
  31  * This class was originally created as a part of BIFE.
  32  * Implements HIT + GHIT + BHIT, which includes groups of templates and buffers.
  33  *
  34  * @access public
  35  */
  36 class MLIB_Tpl_HIT extends MLIB_Tpl
  37 {
  38     /**
  39      * Root directory where template files are.
  40      *
  41      * @var    string $root
  42      * @access public
  43      */
  44     var $root = '.';
  45
  46     /**
  47      * If it's true, it looks for template files in PHP's include_path.
  48      *
  49      * @var    bool $useIncludePath
  50      * @access public
  51      */
  52     var $useIncludePath = false;
  53
  54     /**
  55      * Group of templates to use (a subdirectory in root).
  56      *
  57      * @var    string $group
  58      * @access protected
  59      */
  60     var $group = '';
  61
  62     /**
  63      * Templates cache.
  64      *
  65      * @var    array $cache
  66      * @access protected
  67      */
  68     var $cache = array();
  69
  70     /**
  71      * Parsed templates buffer.
  72      *
  73      * @var    array $buffer
  74      * @access protected
  75      */
  76     var $buffer = array();
  77
  78     /**
  79      * Constructor.
  80      *
  81      * @param  string $root Root directory where template files are.
  82      * @param  bool $useIncludePath If it's true, it looks for template files in PHP's include_path.
  83      * @param  string $group Group of templates to use (a subdirectory in root).
  84      *
  85      * @return void
  86      * @access public
  87      */
  88     function HTML_Template_HIT($root = '.', $useIncludePath = false, $group = '')
  89     {
  90         $this->__construct($root, $useIncludePath, $group);
  91     }
  92
  93     /**
  94      * Constructor.
  95      *
  96      * @param  int $root Root directory where template files are.
  97      * @param  false $useIncludePath If it's true, it looks for template files in PHP's include_path.
  98      * @param  string $group Group of templates to use (a subdirectory in root).
  99      *
 100      * @return void
 101      * @access public
 102      */
 103     function __construct($root = '.', $useIncludePath = false, $group = '')
 104     {
 105         $this->root = $root;
 106         $this->useIncludePath = $useIncludePath;
 107         $this->pushGroup($group);
 108     }
 109
 110     /**
 111      * Parse a template returning the results.
 112      * If $vars is an array, the {[keys]} are replaced with [values] ($val is ignored).
 113      * If is a string, {$vars} is replaced with $val.
 114      *
 115      * @param  string $name Name of template to parse.
 116      * @param  mixed $vars Variables to replace in the template.
 117      * @param  string $val If $vars is a string, the value to replace for $vars.
 118      * @param  mixed $group Group to use to parse this template. Null to use the current group.
 119      *
 120      * @return string
 121      * @access public
 122      */
 123     function parse($name, $vars = '', $val = '', $group = null)
 124     {
 125         $group = is_null($group) ? end($this->group) : $group;
 126         if ($group) {
 127             $file = "{$this->root}/$group/$name.tpl.html";
 128         } else {
 129             $file = "{$this->root}/$name.tpl.html";
 130         }
 131         if (!isset($this->cache[$file])) {
 132             $this->cache[$file] = $this->getFileContent($file);
 133         }
 134         if ($vars) {
 135             if (is_string($vars)) {
 136                 $vars = array($vars => $val);
 137             }
 138             foreach ($vars as $key => $val) {
 139                 $keys[] = '{' . $key . '}';
 140                 $vals[] = $val;
 141             }
 142             return str_replace($keys, $vals, $this->cache[$file]);
 143         } else {
 144             return $this->cache[$file];
 145         }
 146     }
 147
 148     /**
 149      * Parse a template adding the results to the buffer.
 150      * Parse a template appending the results to an internal buffer.
 151      * If $vars is an array, the {[keys]} are replaced with [values] ($val is ignored).
 152      * If is a string, {$vars} is replaced with $val.
 153      *
 154      * @param  string $name Name of template to parse.
 155      * @param  mixed $vars Variables to replace in the template.
 156      * @param  string $val If $vars is a string, the value to replace for $vars.
 157      *
 158      * @return void
 159      * @access public
 160      */
 161     function parseBuffered($name, $vars = '', $val = '')
 162     {
 163         @$this->buffer["{$this->group}/$name"] .= $this->parse($name, $vars, $val);
 164     }
 165
 166     /**
 167      * Gets a parsed buffer.
 168      *
 169      * @param  string $name Name of the parsed template to get.
 170      *
 171      * @return string
 172      * @access public
 173      */
 174     function getBuffer($name)
 175     {
 176         return @$this->buffer["{$this->group}/$name"];
 177     }
 178
 179     /**
 180      * Gets a parsed buffer and removes it.
 181      *
 182      * @param  string $name Name of the buffer to flush.
 183      *
 184      * @return void
 185      * @access public
 186      */
 187     function popBuffer($name)
 188     {
 189         $return = @$this->buffer["{$this->group}/$name"];
 190         unset($this->buffer["{$this->group}/$name"]);
 191         return $return;
 192     }
 193
 194     /**
 195      * Sets the group to use and add it to the groups stack.
 196      *
 197      * @param  string $group Group to use.
 198      *
 199      * @return void
 200      * @access public
 201      */
 202     function pushGroup($group = '')
 203     {
 204         $this->group[] = $group;
 205     }
 206
 207     /**
 208      * Removes the group from the groups stack and returns to the previous used group.
 209      *
 210      * @return string
 211      * @access public
 212      */
 213     function popGroup()
 214     {
 215         return array_pop($this->group);
 216     }
 217
 218     /**
 219      * Tells if a template exists.
 220      * True if the template $name exists in $group (or the current group).
 221      *
 222      * @param  string $name Name of the template.
 223      * @param  mixed $group Template's group. If it's null it uses the current group.
 224      *
 225      * @return bool
 226      * @access public
 227      */
 228     function exists($name, $group = null)
 229     {
 230         $group = is_null($group) ? end($this->group) : $group;
 231         if ($group) {
 232             $file = "{$this->root}/$group/$name.tpl.html";
 233         } else {
 234             $file = "{$this->root}/$name.tpl.html";
 235         }
 236         if (!$this->useIncludePath) {
 237             return is_readable($file);
 238         } else {
 239             $include_path = array_unique(preg_split('/[:;]/', ini_get('include_path')));
 240             foreach ($include_path as $path) {
 241                 if (is_readable("$path/$file")) {
 242                     return true;
 243                 }
 244             }
 245             return false;
 246         }
 247     }
 248
 249
 250     //Agregados debido a la nueva dependencia con MLIB_Tpl'
 251
 252     /**
 253      * Returns the template file name based on the blockname
 254      *
 255      * @param string $group BlockName.
 256      *
 257      * @access public
 258      * @return mixed
 259      */
 260     function getFileName($group)
 261     {
 262         //TODO Revisar esto porque asi solo me devuelve el nombre de los
 263         //templates que esten en la barra.
 264         return "{$this->root}/$group.tpl.html";
 265     }
 266
 267     /**
 268      * Returns the template file content.
 269      *
 270      * @param string $file Filename.
 271      *
 272      * @access public
 273      * @return mixed
 274      */
 275     function getFileContent($filename)
 276     {
 277         return file_get_contents($filename, $this->useIncludePath);
 278     }
 279 }
 280 ?>