Patron decorador

[Italico76]

Me pregunto si el patron decorator esta o no bien aplicado......

Código PHP:

  <?php 
class html { 
  protected $html;   
    
  function __construct($html){ 
    $this->setHtml($html); 
  }   
    
  function __tostring(){ 
    return $this->html; 
  } 
   
  function setHtml($html){ 
    $this->html =$html; 
  } 
} # 
 
/* decorator */ 
abstract class tag extends html {  
  protected $obj; 
   
  function __construct ($obj=null){ 
    $this->obj = $obj; 
  }    
 
} #   
   
class link extends tag { 
  private $uri; 
 
  function __construct ($x=null){ 
    if ($x instanceof tag){ 
      parent::__construct($x); 
    }else{ 
      $y = new html($x); 
      parent::__construct($x); 
      return $y; 
    } 
  } 
   
  function setUri($uri){ 
    $this->uri = $uri; 
  } 
 
  function linkear (){ 
    $this->setHtml ("<a href='{$this->uri}'>{$this->obj}</a>"); 
  } 
   
} #  
   
  
class strong extends tag { 
 
  function render(){ 
    $this->setHtml ('<strong>'.$this->obj.'</strong>'); 
  }   
   
} # 
 
class italic extends tag { 
 
  function render(){ 
    $this->setHtml ('<i>'.$this->obj.'</i>'); 
  }   
   
} # 
 
class img extends html { 
  private $img; 
   
  function __construct($img){ 
    $this->img = $img; 
    $this->render(); 
  }   
   
  private function render(){ 
    $this->setHtml ("<img src='{$this->img}' />"); 
  } 
} # 
 
/* Creo HTML */ 
//$x = new html('Google'); 
 
/* Creo link sobre el HTML on_the_fly */ 
$h = new link('Google'); 
$h->setUri('http://google.es'); 
$h->linkear(); 
 
/* Le hago un strong */ 
$h = new strong ($h); 
$h->render(); 
 
/* Le hago italica   */ 
$h = new italic ($h); 
$h->render(); 
 
echo $h; 
 
/* Creo imagen y le aplico enlace */ 
$i = new img ('http://2.bp.blogspot.com/-nURw-T8ErDM/ThYBg4eyhGI/AAAAAAAAB8I/Tapme43aapE/s72-c/google-picasa-blogger.jpg'); 
$i = new link($i); 
$i->setUri('http://google.es'); 
$i->linkear(); 
 
echo $i;   

Salida de la primera parte:

<i><strong><a href='http://www.google.com'>Google</a></strong></i>

GRACIAS

[Dany_s]

no tenés bien definida una interfaz
tus decoradores están aceptando objetos de cualquier tipo

Debe ser algo como:
tu clase Html va a definir la interfaz de los componentes a los que se pueden añadir funcionalidades

tu clase Tag (interfaz para los decoradores concretos) extiende a Html (Componentes) y tus decoradores concretos (Strong, Italic, etc) extienden a Tag por lo que son también componentes

Si te fijás en el diagrama uml del patrón (o sea la base), hay una realación de agregación, un decorador agrega componentes
en el constructor de tu clase Link no debes preguntar por el tipo de datos, ya que podés especificar qué tipo de datos debe aceptar el que es pasado por parámetro

Código PHP:

public function  __construct(Html $decorador) {
        $this->_html = "<a href=''>". $decorador ."</a>";
    }
 

en vez de

Código PHP:

if ($x instanceof tag){
 

fijate el diagrama uml http://es.wikipedia.org/wiki/Decorat...dise%C3%B1o%29
acá explica los participantes http://dmi.uib.es/people/yuhua/TAP04-05/3.6.pdf

¿otra es que Tu clase Img que funcionalidad daría? creo que ese objeto debe recibir funcionalidad, como ser la de un enlace.

Aclaro que recién estoy tratando de comprender los patrones, hay cosas que por ahi no tengo en cuenta pero a partir de esto muchos pueden dar aportes/correcciones que nos ayuden a aprender jeje

Asi que aprovecho para tirar mi ejemplo y que salgan correcciones

Código PHP:

<?php
abstract class Html
{
    protected $_html;
    
    public function render(){
        return $this->_html;
    }
    
}
 
class Texto extends Html
{
    public function  __construct($texto)
    {
        $this->_html = $texto;
    }
}
 
abstract class Decoradores extends Html
{
    public function  __construct(Html $decorador)
    {
        $this->_html = $decorador->render();
    }
}
 
class Link extends Decoradores
{
    public function render()
    {
        return $this->_html = "<a href=''>". $this->_html ."</a>";
    }
}
 
Class Italica extends Decoradores
{
    public function  render()
    {
        return $this->_html = "<i>". $this->_html ."</i>";
    }
}
 
$t = new Texto("Mi texto");
echo $t->render() . "<br /><br />";
 
$i = new Italica(new Texto("Texto itálica"));
echo $i->render() . "<br /><br />";
 
$link = new Link(new Italica(new Texto("Un link itálica")));
echo $link->render();
 

La clase texto es un componente al que se pueden dar funcionalidades pero el no puede añadir funcionalidad a otro, no es un decorador.

este es el uml y está la clase Img que lo colocaría como componente

[Italico76]

Si te fijás en el diagrama uml del patrón (o sea la base), hay una realación de agregación, un decorador agrega componentes
en el constructor de tu clase Link no debes preguntar por el tipo de datos, ya que podés especificar qué tipo de datos debe aceptar el que es pasado por parámetro

Mejor asi ? sigo preguntando..pero porque quiero que LINK cree enlaces sobre strings sin necesidad de crear previamente un objeto compatible

Código PHP:

  <?php 
class html { 
  protected $html;   
    
  function __construct($html){ 
    $this->setHtml($html); 
  }   
    
  function __tostring(){ 
    return $this->html; 
  } 
   
  function setHtml($html){ 
    $this->html =$html; 
  } 
} # 
 
/* decorator */ 
abstract class tag extends html {  
  protected $obj; 
   
  function __construct (tag $obj=null){ 
    $this->obj = $obj; 
  }    
 
} #   
   
class link extends tag { 
  private $uri; 
 
  function __construct ($obj=null){ 
    if (!($obj instanceof tag)){ 
      if (!is_object($obj)){ 
        $obj = (string) $obj; 
      } 
    }   
    $this->obj = $obj; 
       
  }   
   
  function setUri($uri){ 
    $this->uri = $uri; 
  } 
 
  function linkear (){ 
    $this->setHtml ("<a href='{$this->uri}'>{$this->obj}</a>"); 
  } 
   
} #  
   
  
class strong extends tag { 
 
  function render(){ 
    $this->setHtml ('<strong>'.$this->obj.'</strong>'); 
  }   
   
} # 
 
class italic extends tag { 
 
  function render(){ 
    $this->setHtml ('<i>'.$this->obj.'</i>'); 
  }   
   
} # 
 
class img extends html { 
  private $img; 
   
  function __construct($img){ 
    $this->img = $img; 
    $this->render(); 
  }   
   
  private function render(){ 
    $this->setHtml ("<img src='{$this->img}' />"); 
  } 
} # 
 
 
/* Creo imagen y le aplico enlace */ 
$i = new img ('http://2.bp.blogspot.com/-nURw-T8ErDM/ThYBg4eyhGI/AAAAAAAAB8I/Tapme43aapE/s72-c/google-picasa-blogger.jpg'); 
$i = new link($i); 
$i->setUri('http://google.es'); 
$i->linkear(); 
 
/* Creo link sobre el HTML on_the_fly */ 
$h = new link('Google'); 
$h->setUri('http://google.es'); 
$h->linkear(); 
 
/* Le hago un strong */ 
$h = new strong ($h); 
$h->render(); 
 
/* Le hago italica   */ 
$h = new italic ($h); 
$h->render(); 
 
echo $i; 
echo new html('<p/>'); 
echo $h;   

[Italico76]

Te falto algo...

class Link extends Decoradores
{
* * public function render()
* * {
* * * * return $this->_html = "<a href=''>". $this->_html ."</a>";
* * }
}

Fijate que haces: <a href='ACA NADA'>". $this->_html ."</a>

[GatorV]

Recuerda el punto clave, los Decoradores son para agregar/decorar un objeto base y/o modificar su resultado de la clase base. Esto es que los decoradores no deben de funcionar por si solos, y solo es un agregado a la clase, revisa este ejemplo que diseñe:

Código PHP:

$html = new Html();
$html->addTag(new Link(new Img('foto.jpg'), 'http://www.php.net/'));
$html->addTag(new Bold(new Node('Test')));
echo htmlentities($html);
 

En este caso hay dos nodos base, Img, y Node, que son nodos base que no pueden decorar a otro nodo (no puedes hacer <img><algo></img>).

Las clases que use son las siguientes:

Código PHP:

// Base Tag Class
abstract class Tag
{
    abstract public function render();
    
    public function __toString()
    {
        return $this->render();
    }
}
 
// Base Decorator Class
abstract class TagDecorator extends Tag
{
    protected $_tag;
    
    public function __construct(Tag $tag)
    {
        $this->_tag = $tag;
    }
    
    public function getTag()
    {
        return $this->_tag;
    }
}
 
class Html
{
    private $_tags = array();
    public function __construct(){}
    
    public function addTag(Tag $tag)
    {
        $this->_tags[] = $tag;
    }
    
    public function renderHtml()
    {
        $strOutput = '';
        foreach ($this->_tags as $Tag) {
            $strOutput = (string) $Tag;
        }
        
        return $strOutput;
    }
    
    public function __toString()
    {
        return $this->renderHtml();
    }
}
 
/** Base Clases **/
class Node extends Tag
{
    private $_text;
    
    public function __construct($text)
    {
        $this->_text = $text;
    }
    
    public function render()
    {
        return $this->_text;
    }
}
 
class Img extends Tag
{
    private $_path;
    private $_border;
    
    public function __construct($path, $border = 0)
    {
        $this->_path = $path;
        $this->_border = $border;
    }
    
    public function render()
    {
        return '<img src="' . $this->_path . '" border="'.$this->_border.'" />');
    }
}
 
/** Decorators **/
 
class Link extends TagDecorator
{   
    private $_url;
    
    public function __construct(Tag $text, $url)
    {
        parent::__construct($text);
        $this->setUrl($url);
    }
    
    public function setUrl($url)
    {
        $this->_url = $url;
    }
    
    public function render()
    {
        return '<a href="' . $this->_url . '">' . $this->getTag() . '</a>';
    }
}
 
class Bold extends TagDecorator
{   
    public function render()
    {
        return '<b>' . $this->getTag() . '</b>';
    }
}
 
class Italic extends TagDecorator
{
    public function render()
    {
        return '<i>' . $this->getTag() . '</i>';
    }
}
 

Saludos.

[Italico76]

GatorV: mil gracias por tomarte el trabajo de hacer el ejemplo explicativo

Lo bueno de como aplicas el patron es que todas las clases son tipo 'Tag' o compatibles pero no entiendo esta aclaracion tuya en el contexto de mi codigo:

Recuerda el punto clave, los Decoradores son para agregar/decorar un objeto base y/o modificar su resultado de la clase base. Esto es que los decoradores no deben de funcionar por si solos,

No lo comprendo a pesar de que me doy cuenta intuitivamente de que estas en lo cierto

Gracias de nuevo GatorV!

[GatorV]

Eso mismo, que un decorador por sí solo no funciona, necesita la clase a decorar, de nada serviría que agregaras un tag Bold si no tienes ningún texto.

La idea es modificar la funcionalidad/agregar funcionalidad a la clase base sin tener que modificar directamente la clase base, y que esta funcionalidad se pueda extender a otras clases bases.

Saludos.

[Dany_s]

Tenes que solucionar lo de preguntar el tipo.

Código PHP:

function __construct ($obj=null){
    if (!($obj instanceof tag)){
      if (!is_object($obj)){
        $obj = (string) $obj;
      }
    }  
    $this->obj = $obj;
  }
 

con eso estás desaprovechando el polimorfismo y la herencia (o interfaces si era el caso), todos tus ojetos que pueden ser decorados y los que decoran son del mismo tipo, por lo tanto van a responder a las mismas operaciones

y el constructor está aceptando objetos de cualquier tipo

Fijate en la Clase Html del ejemplo de gator_v, el método addTag(Tag $tag) acepta objetos de tipo Tag, depende de Tag y no importa si le pasas un Link, Bold, o Img porque ellos son de tipo Tag