Location: PHPKode > scripts > template_tpl > template_tpl/template.php
<?php

/**
 * Permite leer fichero tpl, permitiendo varias funcionalidades como son 
 * el poder poner variables dentro de dichas plantillas,
 * crear dependencias entre plantillas
 *
 */
class Template 
{
	/**
	 * guarda la direccion donde se encuentran las plantillas
	 *
	 * @var string
	 */
	static public $path = 'tpl';
	/**
	 * especifica el prefijo que se le antepone a la variable que se utilizara para 
	 * llenar los bloques dependientes
	 *
	 * @var string
	 */
	static public $prefix_mul = '';//__block_
	/**
	 * contiene toda la informacion cargada por el objeto
	 *
	 * @var string
	 */
	public $read;
	/**
	 * contiene el ultimo bloque cargado
	 *
	 * @var string
	 */
	public $lastBlock;
	/**
	 * contiene las variables para la plantilla
	 *
	 * @var array
	 */
	public $vars = array();
	/**
	 * contiene inicio del formato para parsear los bloques
	 *
	 * @var string
	 */
	static private $pattern_block_ini = '[';
	/**
	 * contiene fin del formato para parsear los bloques
	 *
	 * @var string
	 */
	static private $pattern_block_end = ']';
	/**
	 * contiene inicio del formato para parsear las variables
	 *
	 * @var string
	 */
	static private $pattern_var_ini = '{';
	/**
	 * contiene fin del formato para parsear las variables
	 *
	 * @var string
	 */
	static private $pattern_var_end = '}';
	/**
	 * contiene inicio del formato para parsear los bloques dependientes
	 *
	 * @var string
	 */
	static private $pattern_depend_ini = '{{';
	/**
	 * contiene fin del formato para parsear los bloques dependientes
	 *
	 * @var string
	 */
	static private $pattern_depend_end = '}}';
	/**
	 * contiene inicio del formato para parsear los bloques dependientes multiples
	 *
	 * @var string
	 */
	static private $pattern_depend_mul_ini = '{<{';
	/**
	 * contiene fin del formato para parsear los bloques dependientes multiples
	 *
	 * @var string
	 */
	static private $pattern_depend_mul_end = '}>}';
	
	
	// '#{([a-z0-9\-_]*?)}#is';
	
	/**
	 * Contruye una instancia de la clase, ya sea con el o los ficheros
	 * a mapear o el contenido
	 *
	 * @param string o array $file
	 * @param string $content
	 * @return Template
	 */
	function Template($file = '',$content = '')
	{
		if($file)
			$this->read_file($file);
		else
		{
			$this->read = $content;
			$this->lastBlock = $content;
		}
	}
	
	/**
	 * Devuelve la dirección correspondiente 
	 * a un fichero tenuiendo en cuenta la variable $path 
	 * que tiene que haber sido inicializada con anterioridad
	 *
	 * @param string $file
	 * @return string
	 */
	function dir_tpl($file)
	{
		$dir = "";
		$dir = (self::$path)?self::$path."/":"";
		return "$dir$file.tpl";
	}
	
	/**
	 * Permite leer uno o mas fichero y lo deja guardado en memoria
	 *
	 * @param string $file
	 */
	function read_file($file)
	{
		$this->read = $this->read($file);
		$this->lastBlock = $this->read;
		$data = "";
		if(is_array($file))
		{
			foreach ($file as $value) {
				$data .= $this->read($value);
			}			
		}else
			$data = $this->read($file);
			
		$this->read = $data;
		$this->lastBlock = $this->read;	
	}
	
	/**
	 * lee un fichero que se le pase por parámetro
	 *
	 * @param string $file
	 * @return string
	 */
	private function read($file){
		$tpl_file = $this->dir_tpl($file);
		$data = '';
		if (($fd = @fopen($tpl_file, 'r')))
		{
			$tam = filesize($tpl_file);
			if($tam)
				$data = fread($fd, $tam);
				
			fclose($fd);
		}
		return $data;
	}
	
	/**
	 * Devuelve solo el bloque deseado dentro del contenido en memoria
	 * en caso de que no exista dicho bloque se devuelve ""
	 *
	 * @param string $block
	 * @param array $dependsIgnore
	 * @return string
	 */
	function get_block ( $block , $dependsIgnore = array())
	{
		if($block)
		{
			$strBegin = self::$pattern_block_ini.$block.self::$pattern_block_end;
			$strEnd = self::$pattern_block_ini."/$block".self::$pattern_block_end;
			$posBegin = strpos($this->read,$strBegin) +  strlen ( $strBegin ) ;
			$posEnd = strpos($this->read,$strEnd);
			$lengt = $posEnd - $posBegin;
			
			if($lengt > 0)	
				$this->lastBlock = substr ( $this->read, $posBegin,$lengt);
			else
				$this->lastBlock = "";
		}
		else 
			$this->lastBlock = $this->read;
			
		$this->lastBlock = $this->findDependes($dependsIgnore);
					
		return $this->lastBlock;
	}
	
	/**
	 * Busca las dependencia dentro del bloque
	 *
	 * @param array $dependsIgnore
	 * @return array
	 */
	function dependences($dependsIgnore = array())
	{
		$result = array();
		if(!is_array($dependsIgnore))$dependsIgnore = array();
		
		$array = split(self::$pattern_depend_ini,$this->lastBlock);
		for ($i = 1;$i<count($array);$i++)
		{
			$array_aux = split(self::$pattern_depend_end,$array[$i]);
			if(!in_array($array_aux[0],$dependsIgnore))
				$result[] = $array_aux[0];
		}
		return $result;
	}
	
	/**
	 * Busca las dependencia dentro del bloque
	 *
	 * @param array $dependsIgnore
	 * @return array
	 */
	function dependences_mul($dependsIgnore = array())
	{
		$result = array();
		if(!is_array($dependsIgnore))$dependsIgnore = array();
		
		$array = split(self::$pattern_depend_mul_ini,$this->lastBlock);
		for ($i = 1;$i<count($array);$i++)
		{
			$array_aux = split(self::$pattern_depend_mul_end,$array[$i]);
			if(!in_array($array_aux[0],$dependsIgnore))
				$result[] = $array_aux[0];
		}
		return $result;
	}
	
	/**
	 * Permite incluir las dependencias
	 *
	 * @param array $dependsIgnore
	 * @return srting
	 */
	function findDependes($dependsIgnore = array())
	{
		$result = $this->dependences($dependsIgnore);
		$result_mul = $this->dependences_mul($dependsIgnore);
		
		if(count($result) > 0 || count($result_mul) > 0)
		{
			$depends = array();
			$lastBlock = $this->lastBlock;
			if(count($result) > 0)
			{
				foreach ($result as $block_name) 
				{
					$name = $block_name."_block";
					$html_block = $this->get_block($block_name);
					$depends[$name] = $html_block;
				}
			}
		
			if(count($result_mul) > 0)
			{
				foreach ($result_mul as $block_name) 
				{
					$block_mul = self::$prefix_mul.$block_name;
					$name = $block_name."_block_mul";
					if(is_array($this->vars[$block_mul]))
					{
						$html = '';
						$tpl_mul = new Template('',$this->read);
						$tpl_mul->get_block($block_name);
						
						foreach ($this->vars[$block_mul] as $key => $value)
						{
							$tpl_mul->vars = $value;
							$tpl_mul->get_block($block_name);
							$html .= $tpl_mul->parser();
						}
						$html_block = $html;
					}
					$depends[$name] = $html_block;
				}
			}
				
			$exp = '#'.self::$pattern_depend_ini.'([a-z0-9\-_]*?)'.self::$pattern_depend_end.'#is';
			$lastBlock = preg_replace($exp, self::$pattern_depend_ini."\\1_block".self::$pattern_depend_end, $lastBlock);
			
			$exp_mul = '#'.self::$pattern_depend_mul_ini.'([a-z0-9\-_]*?)'.self::$pattern_depend_mul_end.'#is';
			$lastBlock = preg_replace($exp_mul, self::$pattern_depend_ini."\\1_block_mul".self::$pattern_depend_end,$lastBlock);
			
			$tpl_dep = new Template('',$lastBlock);
			$tpl_dep->vars = $depends;
			$this->lastBlock = $tpl_dep->parser(self::$pattern_depend_ini,self::$pattern_depend_end);
		}
		
		
		return $this->lastBlock;
	}
	
	/**
	 * Permite completar  las variables en las posiciones correspondientes dentro del contexto
	 *
	 * @param string $exp
	 * @return string
	 */
	function parser($ini = '', $end = '')
	{
		if(!$ini)$ini = self::$pattern_var_ini;
		if(!$end)$end = self::$pattern_var_end;
		
		$exp = "#$ini([a-z0-9\-_]*?)$end#is";	
		
		$this->vars = (is_array($this->vars))?$this->vars:array();

		$mihtml = str_replace ("'", "\'", $this->lastBlock);
		$mihtml = preg_replace($exp, "' . $\\1 . '", $mihtml);
		
		reset ($this->vars);
		while (list($key, $val) = each($this->vars)) 
		{
			$$key = $val;
		}
		
		eval("\$mihtml = '$mihtml';");
		
		reset ($this->vars);		
		while (list($key, $val) = each($this->vars)) 
		{
			unset($$key);
		}
		
		$mihtml=str_replace ("\'", "'", $mihtml);
		$result = str_replace('\n',"",$mihtml);
		
		return $result;
	}
	
//Métodos estáticos
	/**
	 * Devuelve el contenido completo dentro de un fichero tpl,
	 * en caso que se le pase el bloque el resultado sera el contenido del bloque
	 *
	 * @param string $file
	 * @param string $block
	 * @param string $context
	 * @param array $dependsIgnore
	 * @return string
	 */
	static function context($file,$block = "", $context = '', $dependsIgnore = array())
	{
		$template = new Template($file,$context);
		if($block)
			$template->get_block($block,$dependsIgnore);
			
		return $template->lastBlock;
	}	
	
	/**
	 * Devuelve un bloque ya parseado,
	 * en caso de que no se le pase el fichero se le debe pasar el contenido de este
	 *
	 * @param string $block
	 * @param array $vars
	 * @param string $file
	 * @param string $context
	 * @return string
	 */
	static function parser_block_file($file = '',$block='',$vars = array(),$context='', $dependsIgnore = array() ,$ini = '', $end = '')
	{			
//		wl("$file = '',$block=''");
		$template = new Template($file,$context);
		$template->vars = $vars;
//		w($template->read);
		$template->get_block($block,$dependsIgnore);
//		w($template->lastBlock);
		return $template->parser($ini, $end);
	}
	
	/**
	 * Cambia el patron con el que se leen los bloques
	 *
	 * @param string $ini
	 * @param string $end
	 */
	static function change_block_pattern($ini = '', $end = '')
	{
		if($ini)self::$pattern_block_ini = $ini;
		if($end)self::$pattern_block_end = $end;
	}
	
	/**
	 * Cambia el patron con el que se leen los bloques
	 *
	 * @param string $ini
	 * @param string $end
	 */
	static function change_var_pattern($ini = '', $end = '')
	{
		if($ini)self::$pattern_var_ini = $ini;
		if($end)self::$pattern_var_end = $end;
	}
	
	/**
	 * Cambia el patron con el que se leen los bloques
	 *
	 * @param string $ini
	 * @param string $end
	 */
	static function change_depend_pattern($ini = '', $end = '')
	{
		if($ini)self::$pattern_depend_ini = $ini;
		if($end)self::$pattern_depend_end = $end;
	}
	
	/**
	 * Cambia el patron con el que se leen los bloques
	 *
	 * @param string $ini
	 * @param string $end
	 */
	static function change_depend_mul_pattern($ini = '', $end = '')
	{
		if($ini)self::$pattern_depend_mul_ini = $ini;
		if($end)self::$pattern_depend_mul_end = $end;
	}
	
	/**
	 * Cambia los campos de la clase
	 *
	 * @param array $array
	 */
	static function change_fields($array)
	{
		if($array[pattern_block_ini])		self::$pattern_block_ini 		= $array[pattern_block_ini];
		if($array[pattern_block_end]) 		self::$pattern_block_end 		= $array[pattern_block_end];
		if($array[pattern_var_ini]) 		self::$pattern_var_ini 			= $array[pattern_var_ini];
		if($array[pattern_var_end]) 		self::$pattern_var_end 			= $array[pattern_var_end];
		if($array[pattern_depend_ini]) 		self::$pattern_depend_ini 		= $array[pattern_depend_ini];
		if($array[pattern_depend_end]) 		self::$pattern_depend_end 		= $array[pattern_depend_end];
		if($array[pattern_depend_mul_ini]) 	self::$pattern_depend_mul_ini 	= $array[pattern_depend_mul_ini];
		if($array[pattern_depend_mul_end]) 	self::$pattern_depend_mul_end 	= $array[pattern_depend_mul_end];
		if($array[path]) 					self::$path 					= $array[path];
		if($array[prefix_mul]) 				self::$prefix_mul 				= $array[prefix_mul];
	}
//	
//	/**
//	 * Devuelve un bloque ya parseado, correspondiente a la accción activa
//	 *
//	 * @param string $block
//	 * @param array $vars
//	 * @param string $file
//	 * @param string $context
//	 * @return string
//	 */
//	static function parser_block_action($block='',$vars = array(),$files = array(),$dependsIgnore = array())
//	{
//		$files[] = Sys_Direction::inter_directory_to_action();
//		return Template::parser_block_file($files,$block,$vars,'',$dependsIgnore);
//	}
}
?>
Return current item: template_tpl