Witam wszystki,

zacząłem pisać klasę do generowania tagów/kodu HTML.
Nakreślę najpierw jak działa, a potem napiszę w czym problem.

Jednym z ważniejszych klasy jest właściwość "neighborTags", jest to tablica zawierająca z kolei 4 inne tablice: before, after, outer, inner.
Tak to działa:

[PHP] pobierz, plaintext 
//Tworzony jest pierwszy tag
$img = new Tag('img', array('class'=>'logi','style'=>'border:0'));
 
//Tworzymy link to zdjecia, tag 'a' opakowujący tag 'img'
//w obiekcie $img zostanie utworzony nowy obiekt klas Tag a następnie zapisany we właściwości $neighborTags: array_unshift($this->neberTags['inner'], $tag);
$a = $img->outer('a',array('href'=>'http://php.pl'));
 
//za tagiem 'a' wstawiamy 'span'
//w obiekcie $a zostanie utworzony nowy obiekt klasy Tag a następnie zapisany we właściwości $neighborTags: $neighborTags: array_unshift($this->neberTags['inner'], $tag);
$a->after('span',array('class'=>'span1'));
[PHP] pobierz, plaintext 

Teraz mój problem.
Napisałem metodę, która generuje kod html na zasadzie łączenia stringów.
Generowałem pierwszy tag i sprawdzałem co ma w 'before' i w 'after' doklejałem co trzeba i dalej...
Niestety bardziej skomplikowany kod jest źle generowany...

Nie mam innego pomysłu jak to rozwiązać...
Nie jestem nawet pewien czy jest to możliwe w przypadku takiej struktury danych.

Ktoś ma jakiś pomysł?

Ok zacznijmy od tego Po co ci coś takiego robić. Takie rozwiązanie o którym mówisz jest najgorszym z możliwych rozwiązań w Zend_Form_Decorators. Już niedługo dojdzie do tego, że każda literka będzie obiektem.

czy to ma znaczenie po co?
chodzi o rozwiązanie tego problemu...

Generalnie klasa będzie miała 'cikawsze' zadania niż tylko generowanie htmla ale najpierw muszę rozwiązać ten problem.

No to przy generowaniu jednego taga sprawdza, jakie tagi ma w before. Generujesz je i wstawiasz przed tag. Podobine z after. Ale skoro mówisz, że źle ci działa to może byś sypnął kodem?

Problem tkwi w metodzie renderAll()

[PHP] pobierz, plaintext 
class Tag
{    
    public $tagType;
    public $tagAttributes;
    public $neberTags = array('before'=>array(), 'after'=>array(), 'inner'=>array(), 'outer'=>array());    
    public $options = false; 
    private $optionsDefault = array('quotation'=>'"'); 
    private $closedTags = array('img'=>1,'input'=>1);
 
 
    public function __construct($tagType, $tagAttributes = array(), $options = array())
    {        
        $this->tagType = $tagType;
        $this->tagAttributes = $tagAttributes;        
        $this->options = array_merge($this->optionsDefault, $options);        
    }    
 
    public function after($tagType, $tagAttributes = array(), $options = array())    
    {        
        $options = array_merge($this->options, $options);
 
        $tag = new Tag($tagType, $tagAttributes, $options);
        array_unshift($this->neberTags['after'], $tag);
        //$tag = $this->neberTags['after'][] = new Tag($tagType, $tagAttributes, $options);
        return $tag;
    }    
 
    public function before($tagType, $tagAttributes = array(), $options = array())    
    {
        $options = array_merge($this->options, $options);
 
        $tag = new Tag($tagType, $tagAttributes, $options);
        array_unshift($this->neberTags['before'], $tag);
        return $tag;
    }    
 
    public function outer($tagType, $tagAttributes = array(), $options = array())
    {
        $options = array_merge($this->options, $options);
 
        $tag = new Tag($tagType, $tagAttributes, $options);
        array_unshift($this->neberTags['outer'], $tag);
        return $tag;    
    }    
 
    public function inner($tagType, $tagAttributes = array(), $options = array())
    {
        $options = array_merge($this->options, $options);
 
        $tag = new Tag($tagType, $tagAttributes, $options);
        array_unshift($this->neberTags['inner'], $tag);
        return $tag;    
    }    
 
    public function link($url, $tagAttributes = array(), $options = array())
    {           
        $options = array_merge($this->options, $options);
 
        $defaultAttributes = array('href'=>$url, 'title'=>''); 
        $tagAttributes = array_merge($defaultAttributes, $tagAttributes);
 
        if(!$tagAttributes['href'] || !file_exists($tagAttributes['href'])) return false;
 
        $tag = new Tag('a', $tagAttributes, $options);
        array_unshift($this->neberTags['outer'], $tag);
        return $tag;    
    } 
 
    public function render($echo = true)
    {
        $attributes = $this->attributes($this->tagAttributes);
 
        if(!empty($this->closedTags[$this->tagType])){
            if($echo === true){
                echo  "<{$this->tagType}{$attributes} />";
            }else{
                return  "<{$this->tagType}{$attributes} />";
            }
        }else{
            if($echo === true){
                echo "<{$this->tagType}{$attributes}></{$this->tagType}>";
            }else{
                return "<{$this->tagType}{$attributes}></{$this->tagType}>";
            }
 
        }    
    }
 
    public function renderAll($html = false, $type = false)
    {     
        if($type == false) $html = $this->render(false);
 
        if($type == 'after') $html = $html.$this->render(false);
        if($type == 'before') $html = $this->render(false).$html;       
 
        if($type == 'outer'){
            $out = explode('><',$this->render(false));           
            $html = $out[0].'>'.$html.'<'.$out[1];
        }        
 
        if($type == 'inner'){       
            $out = explode('><',$html);           
            $html = $out[0].'>'.$this->render(false).'<'.$out[1];
        }
 
        foreach($this->neberTags as $k=>$types){            
            foreach($types as $k2=>$v2){                
                $html = $v2->renderAll($html, $k);
            }
        }
        return $html;
    }     
 
    private function attributes($tagAttributes)
    {
        if(!is_array($tagAttributes)) return;        
        foreach($tagAttributes as $attribute=>$value){
            $attributes .= ' '.$attribute.'='.$this->options['quotation'].$value.$this->options['quotation'];
        }        
        return $attributes;    
    }
 
}
[PHP] pobierz, plaintext 

linia 108:

[PHP] pobierz, plaintext 
 $html = $v2->renderAll($html, $k);
[PHP] pobierz, plaintext 

co to jest $v2 - obiekt ? , do $this też jakoś niepodobne

zgadza się obiekt, mało trafna nazwa co?
v od value (element tablicy), 2 to zagnieżdżenie pętli foreach.
generalnie cała ta metoda jest skopana, przepisywałem ją po kilka razy i dlatego takie nazewnictwo...

czyli neberTags to jest tablica obiektów ?
jesteś pewien, że odczytujesz je w tej samej kolejności co je zapisałeś ?
zawsze wpisujesz coś do wszystkich 4 metod - 'before' 'after' 'inner' 'outer'
nie sypie się wszystko gdy masz puste np. inner
czyli np.
1. zapisujesz do wszystkich czterech
2. zapisujesz do trzech (bez inner ? outer ?)
3. znowu do czterech

nie bardzo wiem o co pytasz więc wytłumaczę jak to leci:

[PHP] pobierz, plaintext 
//Tworzę pierwszy tag IMG
$img = new Tag('img');
//za IMG wstawiam SPAN. Do tablicy neberTags['after'] obiektu $img dodaje pierwszą pozycją, jest nią obiekt $span
$span = $img->after('span');
//znowu za IMG wstawiam P. Do tablicyneberTags['after'] obiektu $img dodaję drugą pozycję, jest nią obiekt $p
$p = $img->after('p');
/*
W tej chwili mój kod htm powinien wyglądać tak:
<img/><p></p><span></span>
 
zwróć uwagę, że P jest przed SPAN, chociaż dodane zostało po tym jak dodałem SPAN. 
Powinno tak być gdyż metodę 'after' wykonałem na obiekcie $img.
Gdybym chciał aby P było po SPAN kod musiał by wyglądać tak:
*/
$img = new Tag('img');
$span = $img->after('span');
$p = $span->after('p');
[PHP] pobierz, plaintext 

Wydaje mi się, że tablica $neberTags jest prawidłowo uzupełniana.
Problemem jest metoda renderAll(). Nie jestem pewien, czy rekurencja jest poprawna i czy zwracane są odpowiednie wartości.

[PHP] pobierz, plaintext 
        foreach($this->neberTags as $k=>$types){            
 echo "<pre>";
 echo "k : <br />";
 var_dump($k);
 echo "<pre>";
            foreach($types as $k2=>$v2){                
                $html = $v2->renderAll($html, $k);
            }
        }
        return $html;
    }     
[PHP] pobierz, plaintext 

uruchomienie:

[PHP] pobierz, plaintext 
$img = new Tag('img');
$p = $img->after('p');
$span = $img->after('span');
 
$img->renderAll();
[PHP] pobierz, plaintext 

efekt:

[HTML] pobierz, plaintext 
k : 
string(6) "before"
k : 
string(5) "after"
k : 
string(6) "before"
k : 
string(5) "after"
k : 
string(5) "inner"
k : 
string(5) "outer"
k : 
string(6) "before"
k : 
string(5) "after"
k : 
string(5) "inner"
k : 
string(5) "outer"
k : 
string(5) "inner"
k : 
string(5) "outer"
[HTML] pobierz, plaintext 

musisz dojść do tego skąd tyle tego się nabrało, jak będzie wyglądało tak jak poniżej wtedy powinno działać

[HTML] pobierz, plaintext 
k : 
string(6) "before"
k : 
string(5) "after"
k : 
string(5) "inner"
k : 
string(5) "outer"
[HTML] pobierz, plaintext 

mi to wygląda (przyznaję się, że szczegółowo nie analizowałem skryptu) jak jednopoziomowa tablica asocjacyjna dla tagów (niższe poziomy są tylko dla atrybutów) gdzie jeszcze są zapisane niby zależności - ale zależności zagnieżdżeń tagów powinno też się realizować odpowiednio przez zagnieżdżenie tablicy kolejnej asocjacyjnej...

poza tym nie bardzo wiem do czego ten skrypt ma być tym bardziej, że w samym PHP jest też mechanizm DOM - skoro nie znam końcowego przeznaczenia więc nie mogę też krytykować - ale może jednak dało by się jakoś wykorzystać tutaj logikę DOM'u?? - spróbuj to zaimplementować:
Document Object Model

No ale dokładnie tak jest...
atrybuty nie mają z tym nic wspólnego. Każdy obiekt posiada oddzielną tablicę to przechowywania atrybutów ($tagAttributes).

Zagnieżdżone tagi to tablica $neberTags - tak naprawdę jest to tablica zawierająca kolejne Obiekty tagów - odpowiednio zagnieżdżone właśnie.

tak w największym skrócie wyobrażam sobie prowadzenie wykopalisk :

[PHP] pobierz, plaintext 
<?php
 
class Tag
{   
//	private $tags = array('br' => '<br />', 'p' => '<p>', 'pc' => '</p>');
	private $tags = array('br' => ' br ', 'p' => ' p ', 'pc' => ' pc ', 'img' => ' img '); // to po to aby można w echo coś zobaczyć
	private $before = array();
	private $inner  = array();
	private $after  = array();
 
 
        public function __construct($inner)
	{
		$this->inner = $inner;
	}
 
	public function before($before)    
	{
		$this->before[] = $before;
	}
 
	public function after($after)    
	{
        $this->after[] = $after;
	}
 
 
	public function renderAll()
	{
		$html = '';
		foreach($this->before as $key => $value)
		{
			foreach($this->tags as $key1 => $value1)
			{
				if($value == $key1) $html .= $value1;
			}
		}
 
		$html = $html . $this->inner;
 
 
		foreach($this->after as $key => $value)
		{
			foreach($this->tags as $key2 => $value2)
			{
				if($value == $key2) $html .= $value2;
			}
		}
		return $html;
	}
 
}
 
$img = new Tag('img');
$img->before('br');
$img->before('p');
$img->after('pc');
$img->after('br');
echo $img->renderAll();
[PHP] pobierz, plaintext 

IMO jeżeli musisz to robić od podstaw samemu to jednak radziłbym wzorować się na DOMie.

[PHP] pobierz, plaintext 
$img = new ImgElement('/my/image', 'alt text');
 
$a = new AElement('http://...');
$a->appendChild($img);
$a->appendChild('Click me!');
 
echo $a;
[PHP] pobierz, plaintext 

A struktura klas mniej-więcej:

[PHP] pobierz, plaintext 
<?php
 
abstract class Element{
	protected $tagName;
	protected $hasEndTag = true;
	protected $availableAttributes = array();
 
	protected $childNodes = array();
	protected $parent;
 
	public function setAttribute($name, $value){
		$name = strtolower($name);
 
		if(!in_array($name, $this->availableAttributes)){
			throw new Exception('...');
		}
 
		$this->availableAttributes[$name] = $value;
	}
 
	public function appendChild($node){
		if($this->hasEndTag === false){
			throw new Exception('....');
		}
 
		if(is_string($node){
			//...
		}elseif($node instanceof Element){
			$node->setParent($this);
		}else{
			throw new Exception('blah blah blah');
		}
 
		$this->childNodes[] = $node;
	}
 
	public function render(){
		if($this->hasEndTag === true){
			$tagFormat = '<%s%s>%s</%s>';
			return sprintf($tagFormat, $this->tagName, $this->renderAttributes(), $this->renderChildNodes(), $this->tagName);
		}else{
			$tagFormat = '<%s %s />';
			return sprintf($tagFormat, $this->tagName, $this->renderAttributes());
		}
	}
 
	public function __toString(){
		return $this->render();
	}
 
	protected function renderAttributes(){
		//..
		return ' title="to_tylko_przyklad"';
	}
 
	protected function renderChildNodes(){
		$html = '';
		foreach($this->childNodes as $node){
			if(is_string($node)){
				$html .= $node;
			}else{
				$html .= $node->render();
			}
		}
 
		return $html;
	}
}
 
class AElement extends Element{
	protected $availableAttributes = array('href', 'title');
 
	public function __construct($hrefAttr = null){
		if(!is_null($hrefAttr)){
			$this->setAttribute('href', $hrefAttr);
		}
	}
}
 
class ImgElement extends Element{
	protected $hasEndTag = false;
	protected $availableAttributes = array('src', 'alt');
 
	public function __construct($srcAttr = null, $altAttr = null){
		if(!is_null($srcAttr)){
			$this->setAttribute('src', $srcAttr);
		}
 
		if(!is_null($altAttr)){
			$this->setAttribute('alt', $altAttr);
		}
	}
}
 
?>
[PHP] pobierz, plaintext 

Dzięki wszystkim za pomoc, znalazłem rozwiazanie:

[PHP] pobierz, plaintext 
 public function before($tagName, $attributes = array(), $options = array())
    {
        $options = array_merge($this->options, $options);
        $tag = new Tag($tagName, $attributes, $options);
        if(count($this->before) >= 1){
            array_push($this->before[0]->after, $tag);
        }else{
            array_push($this->before, $tag);
        }
        return $tag;
    }
    public function after($tagName, $attributes = array(), $options = array())
    {
        $options = array_merge($this->options, $options);
        $tag = new Tag($tagName, $attributes, $options);
        if(count($this->after) >= 1){
            array_push($this->after[0]->before, $tag);
        }else{
            array_push($this->after, $tag);
        }
        return $tag;
    }
[PHP] pobierz, plaintext 

Jezeli mam tag SPAN i przed niego chce wstawic tag IMG to:
zanim do tablicy before tagu SPAN dodam nowy obiekt tagu IMG sprawdzam czy w tej tablicy juz sa jakies obiekty, jezeli tak to do odnalezionego obiektu dodaje ten nowy IMG lecz nie do tablicy before tylko after.
Troche to zagmatwane, ale logiczne i tagi generowane sa w odpowiedniej kolejnosci.

Pozdrawiam