HTML_TEMPLATE BETA

Nie wiem, czy pasuje ale co mi tam:P

Napisałem sobie taką klasę, która ma za zadanie wypełniać szablony HTML(bądź inne) danymi.

Z grubsza szablon wygląda tak:

Kod:

{ZMIENNA_W_BLOKU_2}

{ZMIENNA_W_BLOKU_1}

A oto sama klasa:

Kod:

<?php

class HTML_TEMPLATE
{
var $co = array();
var $czym = array();
var $Block = array();
var $Errors = array();

var $Blocks;
var $template;
var $TempName;
var $CurrentBlock;
var $PreviousBlock;

var $cache = 'cache/';

function HTML_TEMPLATE()
{
 if(!@opendir($this->cache))
 {
 if(!mkdir($this->cache))
 {
 $this->Errors[] = 'Nie można utworzyć katalogu o nazwie '.$this->cache.'';
 }
 }
}
function LoadTemplate($var)
{
 if(empty($var))
 {
 return false;
 $this->Errors[] = 'Brak argumentu dla LoadTemplate';
 }
 else
 {
 if(!file_exists($var))
 {
 $this->Errors[] = 'Nie moge załadować szablonu!';
 return false;
 }
 else
 {
 if(!$this->template = file_get_contents($var))
 {
 return false;
 }
 else
 {
 $this->TempName = $var;
 return($this->template);
 }
 }
 }
}
function SetBlock($var)
{
 $this->Errors[] = empty($var) ? 'Brak argumentu dla SetBlock()' : '';
 $this->Blocks[] = $var;
 $Block = explode("", $this->template);
 if(count($Block) == 3)
 {
 $this->template = $Block[0].'{'.md5($var).'}'.$Block[2];
 if($this->CacheWrite($Block[1], '', $var, true))
 {
 if($this->CacheWrite($this->template, 'TPL-', $this->TempName, false))
 {
 return true;
 }
 else
 {
 $this->Errors[] = 'Błąd, nie mogę dodać wpisu w cache, linia: '.__LINE__;
 }
 return true;
 }
 else
 {
 $this->Errors[] = 'Błąd, nie mogę dodać wpisu w cache, linia: '.__LINE__;
 }
 }
 else
 {
 return false;
 }
}

function SetCurrentBlock($name)
{
 if(empty($name))
 {
 $this->Errors[] = 'Braj argumentu dla SetCurrentBlock';
 }
 else
 {
 if($this->CacheExists(md5($name)))
 {
 if($this->CurrentBlock = $this->ReadCache('',$name))
 {
 return true;
 }
 }
 }
}

function SetVariable($co, $czym)
{
 if(empty($co))
 {
 $this->Errors[] = 'Brak argumentu dla SetVariable';
 }
 else
 {
 $this->co[] = '{'.$co.'}';
 $this->czym[] = $czym;
 }
}

function ParseBlock($name)
{
 if(empty($name))
 {
 $this->Errors[] = 'Braj argumentu dla ParseCurrentBlock';
 }
 else
 {
 if($this->CacheExists(md5($name)))
 {
 if(isset($this->PreviousBlock) AND $this->PreviousBlock !== $name)
 {
 $this->co[] = '{'.md5($this->PreviousBlock).'}';
 $this->czym[] = $this->Block[$this->PreviousBlock];
 }


 if($name == $this->PreviousBlock OR $this->Blocks[count($this->Blocks)-1] == $name)
 {
 $this->Block[$name] .= str_replace($this->co, $this->czym, $this->CurrentBlock);
 }
 else
 {
 $this->Block[$name] = str_replace($this->co, $this->czym, $this->CurrentBlock);
 }
 }
 }
 $this->co = array();
 $this->czym = array();
 $this->PreviousBlock = $name;
}

function ParseAll()
{
 $this->Block = str_replace('{'.md5($this->PreviousBlock).'}', $this->Block[$this->PreviousBlock], $this->ReadCache('TPL-', $this->TempName));
}
function Show()
{
 print $this->Block;
}

function ReadCache($prefix, $name)
{
 if(empty($name))
 {
 $this->Errors[] = 'Brak argumentu dla ReadCache';
 }
 else
 {
 return file_get_contents($this->cache.$prefix.md5($name));
 }
}
function CacheWrite($var, $prefix, $name, $check)
{
 if(empty($name))
 {
 $this->Errors[] = 'Brak argumentu dla CacheWrite';
 }
 else
 {
 $name = md5($name);

 $CacheExists = $check == 1 ? $this->CacheExists($prefix.$name) : false;

 if( !$CacheExists )
 {

 if(file_put_contents($this->cache.$prefix.$name, $var))
 {
 return true;
 }
 else
 {
 $this->Errors[] = 'Nie mogę zapisać do cache, linia:'.__LINE__;
 return false;
 }
 }
 else
 {
 return true;
 }
 }
}
function CacheExists($var)
{
 if(empty($var))
 {
 $this->Errors[] = 'Brak argumentu dla CacheExists';
 }
 else
 {
 if(file_exists($this->cache.$var))
 {
 return true;
 }
 else
 {
 return false;
 }
 }
}
function DeleteCache()
{
 $Dir = opendir($this->cache);
 while($File = @ReadDir($Dir))
 {
 if($File == '.' OR $File == '..')
 {
 //
 }
 else
 {
 $result = unlink($this->cache.$File);
 if( $result )
 {
 $result = true;
 }
 else
 {
 $this->Errors[] = 'Nie mogę usunąć pliku '.$File.'';
 $result = false;
 }
 }
 }
 return $result;
}
function PrintErrors()
{
 for($i=0; $i<count($this->Errors);++$i)
 {
 print $this->Errors[$i];
 }
}
}
?>

Jeszcze nie zdążyłem dopracować.
Ide dobrym tropem? A może wywalić to w kosmos i pisać od początku?
PS:Z grubsza klasa działa tak:
1.Dzieli szablon na bloki
2.Wypełnia bloki danymi
3.Łączy w całość

PS2: 500 powtórzeń przy 20zmiennych zajęło jej 0.1s[przy jednym bloku]

Lol prawie nic z tego nie rozumiem Laughing

lepiej wrócę na imprezę XD

Dzięki za konkretną opinie ;]
Jak coś jest niejasne to wytłumaczę, wystarczy pytać ;]

baran napisał:

Dzięki za konkretną opinie ;]
Jak coś jest niejasne to wytłumaczę, wystarczy pytać ;]

eee....Co toto jest ?^^

Update ;]

Kod:

<?php

class HTML_TEMPLATE
{
var $co = array(); #Co będzie zastępowane
var $czym = array(); #Czym będzie zastępowane
var $Block = array(); #Tablica przechowująca zawartość bloków
var $Blocks = array(); #Tablica z nazwami bloków
var $Errors = array(); #Tablica z błędami

var $template; #Zmienna zawierająca szablon
var $TempName; #Nazwa szablonu
var $CurrentBlock; #Bierzący blok
var $PreviousBlock; #Poprzedni blok[definiowana na końcu metody ParseBlock()]
var $CurrentBlockName; #Nazwa bierzącego bloku[definiowana w SetCurrentBlock()]

var $cache = 'cache/'; #Nazwa folderu z plikami które tworzy klasa

function HTML_TEMPLATE()
{
if(!@opendir($this->cache))
{
if(!mkdir($this->cache))
{
$this->Errors[] = 'Nie można utworzyć katalogu o nazwie '.$this->cache.'';
}
}
}
function LoadTemplate($var)
{
if(empty($var))
{
return false;
$this->Errors[] = 'Brak argumentu dla LoadTemplate';
}
else
{
if(!file_exists($var))
{
$this->Errors[] = 'Nie moge załadować szablonu!';
return false;
}
else
{
if(!$this->template = file_get_contents($var))
{
return false;
}
else
{
$this->TempName = $var;
return($this->template);
}
}
}
}
#Definicja bloków, które znajdują się w szablonie
function SetBlock($var)
{
$this->Errors[] = empty($var) ? 'Brak argumentu dla SetBlock()' : '';

 #Do spisu bloków dodajemy nowy
$this->Blocks[] = $var;

 #Dzielenie szablonu na tabline, $Block[1] to blok, który nas interesuje,
 #reszta szablonu jest w $Block[0] i $Block[2].
$Block = explode("", $this->template);
if(count($Block) == 3)
{
 $this->template = $Block[0].'{'.md5($var).'}'.$Block[2];

 #Zapisywanie bloku do pliku
 if($this->CacheWrite($Block[1], '', $var, true))
{
 #Zapisywanie reszty szablonu do pliku
if($this->CacheWrite($this->template, 'TPL-', $this->TempName, false))
{
return true;
}
else
{
$this->Errors[] = 'Błąd, nie mogę dodać wpisu w cache, linia: '.__LINE__;
}
return true;
}
else
{
$this->Errors[] = 'Błąd, nie mogę dodać wpisu w cache, linia: '.__LINE__;
}
}
else
{
return false;
}
}
#Wybieranie bierzącego bloku
function SetCurrentBlock($name)
{
if(empty($name))
{
$this->Errors[] = 'Braj argumentu dla SetCurrentBlock';
}
else
{
if($this->CacheExists(md5($name)))
{
 #Ładowanie bloku do zmiennej
if($this->CurrentBlock = $this->ReadCache('',$name))
{
 #Nazwa bierzącego bloku
 $this->CurrentBlockName = $name;
return true;
}
}
}
}

function SetVariable($co, $czym)
{
if(empty($co))
{
$this->Errors[] = 'Brak argumentu dla SetVariable';
}
else
{
$this->co[] = '{'.$this->CurrentBlockName.'.'.$co.'}';
$this->czym[] = $czym;
}
}
#Parsowanie bloku
function ParseBlock($name, $mode = '0')
{
if(empty($name))
{
$this->Errors[] = 'Braj argumentu dla ParseCurrentBlock';
}
else
{
if($this->CacheExists(md5($name)))
{
 switch($mode)
 {

 #w przypadku zwyczajnie zagnierzdżonych bloków
 case '0':
 if(isset($this->PreviousBlock) AND $this->PreviousBlock !== $name)
 {
 $this->co[] = '{'.md5($this->PreviousBlock).'}'; #Nazwa poprzedniego bloku
 $this->czym[] = $this->Block[$this->PreviousBlock]; #Zawartość poprzedniego bloku
 }
 if($name == $this->PreviousBlock OR $this->Blocks[count($this->Blocks)-1] == $name)
 {
 #Rozpatrywane jeżeli bieżący blok jest ostatnim
 $BlockName = array_keys($this->Block);

 $this->co[] = '{'.md5($BlockName[0]).'}';
 $this->czym[] = $this->Block[$array[0]];

 $this->Block = array($name => $this->Block[$name].str_replace($this->co, $this->czym, $this->CurrentBlock));
 }
 else
 {
 $this->Block = array($name => str_replace($this->co, $this->czym, $this->CurrentBlock));

 unset($this->Block[$this->PreviousBlock]);
 }

 $this->PreviousBlock = $name;

 $this->co = array();
 $this->czym = array();

 break;

 #Jeżeli istnieją dwa bloki obok siebie
 case '1':
 $this->Block[$name] .= str_replace($this->co, $this->czym, $this->CurrentBlock);

 #Czyszczenie zmiennych
 $this->co = array();
 $this->czym = array();

 case '2':
 $this->PreviousBlock = $name;

 $this->co[] = '{'.md5($name).'}'; #Nazwa bieżącego bloku
 $this->czym[] = $this->Block[$name]; #Zawartość bieżącego bloku

 break;
 }
}
}
}
function ParseAll()
{
$this->Block = str_replace('{'.md5($this->PreviousBlock).'}', $this->Block[$this->PreviousBlock], $this->ReadCache('TPL-', $this->TempName));
}
function Show()
{
print $this->Block;
}

function ReadCache($prefix, $name)
{
if(empty($name))
{
$this->Errors[] = 'Brak argumentu dla ReadCache';
}
else
{
return file_get_contents($this->cache.$prefix.md5($name));
}
}
function CacheWrite($var, $prefix, $name, $check)
{
if(empty($name))
{
$this->Errors[] = 'Brak argumentu dla CacheWrite';
}
else
{
$name = md5($name);

$CacheExists = $check == 1 ? $this->CacheExists($prefix.$name) : false;

if( !$CacheExists )
{

if(file_put_contents($this->cache.$prefix.$name, $var))
{
return true;
}
else
{
$this->Errors[] = 'Nie mogę zapisać do cache, linia:'.__LINE__;
return false;
}
}
else
{
return true;
}
}
}
function CacheExists($var)
{
if(empty($var))
{
$this->Errors[] = 'Brak argumentu dla CacheExists';
}
else
{
if(file_exists($this->cache.$var))
{
return true;
}
else
{
return false;
}
}
}
function DeleteCache()
{
$Dir = opendir($this->cache);
while($File = @ReadDir($Dir))
{
if($File == '.' OR $File == '..')
{
//
}
else
{
$result = unlink($this->cache.$File);
if( $result )
{
$result = true;
}
else
{
$this->Errors[] = 'Nie mogę usunąć pliku '.$File.'';
$result = false;
}
}
}
return $result;
}
function PrintErrors()
{
for($i=0; $i<count($this->Errors);++$i)
{
print $this->Errors[$i];
}
}
}
?>

szablon:

Kod:

{blok1.zmienna}

{blok2.zmienna}

{blok3.zmienna}

Jak sama nazwa wskazuje jest to klasa, która coś robi z szablonami html ;]
Coś jak to z PEAR, ale troche gorsze Razz

Celowo jest to dzielone na bloki, aby nie trzeba było dzielić szablonu tylko powstawiać coś takiego jak pokazałem.
przykładowe wykozystanie:

Kod:

$tpl -> LoadTemplate('test');
$tpl -> SetBlock('blok3');
$tpl -> SetBlock('blok2');
$tpl -> SetBlock('blok1');

$tpl -> SetCurrentBlock('blok3');
$tpl -> SetVariable('zmienna', 'Zmienna w bloku 3');
$tpl -> ParseBlock('blok3');

$tpl -> SetCurrentBlock('blok2');
$tpl -> SetVariable('zmienna', 'Zmienna w bloku 2');
$tpl -> ParseBlock('blok2');

$tpl -> SetCurrentBlock('blok1');
$tpl -> SetVariable('zmienna', 'Zmienna w bloku 1');
$tpl -> ParseBlock('blok1');

$tpl -> ParseAll()
$tpl -> Show();
$tpl -> PrintErrors();

Pisałem na gorąco to nie wiem czy dobrze napisałem ;]

Lol. ja tam nie wiem waitnij na sky'a Razz

on powie raczej czy dobrze czy źle czy do pupy xP

Dobra... po dłuższym testowaniu wiem, że spupiłem ;]
Klasa łamie się przy wielu sąsiadujących ze sobą blokach.
Nie chce mi się poprawiać więc temat uważam za nieaktualny ;]

Tak masz rację zgadzam się z Tobą w 100% x]