Hoje iniciaremos uma série de artigos que abordam a criação de uma classe php totalmente orientada a objeto para geração de formulários. Porém, antes vamos observar brevemente as características do form, seus atributos e elementos adicionais.

Os formulários HTML são estruturas que permitem a usuários submeterem dados a uma página. Esses dados podem ser tratados e/ou armazenados dependendo da aplicação. Possuem uma tag de abertura e outra de fechamento, inserindo os elementos adicionais entre essas duas.

Estrutura:
<form (atributos/valores)> (elementos) </form>

Atributos:

• accept
• accept_charset
• action
• method
• enctype

Elementos Adicionais:
- input - <input (atributos/valores) />
- option - <option (atributos/valores)> (nome) </option>
- select - <select (atributos/valores)> (elemento option) ou (elemento optgroup) </select>
- textarea - <textarea (atributos/valores)> (texto) </textarea>
- button - <button (atributos/valores)> (nome) </button>
- label - <label (atributos/valores)> (rótulo) </label>
- fieldset - <fieldset (atributos/valores)> (elemento legend [opcional] ) (elementos) </fieldset>
- optgroup - <optgroup (atributos/valores)> (elemento option) </optgroup>

Com base nessas informações, iniciaremos a construção de nossa classe genérica.

Criação da classe commons (comum), attribute (atributo) e element (elemento)

O primeiro passo será a criação das classes genéricas, ou seja, as classes que serão utilizadas como extensões para as demais classes. A classe commons será responsável pelos métodos __set() e __get(). A classe attribute será a instância de nossos atributos e, por fim, a classe element manipulará essas instâncias de attribute.

Class commons

Definiremos a classe commons como abstrata (abstract), pois ela não deve ser instanciada, servirá apenas de apoio para as demais. Adicionamos então dois métodos de interceptação (intercepções – conceito introduzido no PHP5), o método __set() e __get().

O método __set() interceptará a atribuição de valores a propriedades do objeto. Assim, sempre que for atribuído um valor a uma propriedade do objeto, automaticamente essa atribuição passará pelo método __set().

O método __get() interceptará requisições de propriedades do objeto. Assim, sempre que for requisitada uma propriedade, automaticamente essa requisição passará pelo método __get().

abstract class commons {
 function __set( $property,$val ) {
  $this->$property = $val;
 }
 
 function __get( $property ) {
  return $this->$property;
 }
}

Class attribute

A classe attribute será uma extensão da classe commons, herdando os métodos __set() e __get(). Definimos também a mesma como final. Adicionamos duas variáveis, attribute e value, responsáveis por guardar o nome do atributo e seu valor. Então incluímos o método construtor __construct() que atribuirá o valor de attribute e value na criação do objeto, caso seja passado algum valor.

final class attribute extends commons {
 protected $attribute;
 protected $value;
 
 function __construct( $attribute,$value ) {
  $this->attribute = $attribute;
  $this->value = $value;
 }
}

Class element

A classe element será uma extensão da classe commons e abstrata (abstract). A função desta classe será manipular os objetos attribute, para isso adicionaremos três métodos: addAttribute, hasAttributes e getAttributes.

Como o próprio nome já descreve, o método addAttribute adicionará na array attributes uma instância do objeto attribute. A palavra attribute antes de $attribute descreve que a variável recebida deverá ser um objeto attribute. hasAttributes tem a finalidade de verificar se a array attributes possui filhos, retornando um booleano.

Por fim, o método getAttributes percorre os atributos contidos na array attribute e os transformam em uma string plana para serem adicionados mais tarde aos elementos. Definimos também o método draw como abstrato (abstract), obrigando as subclasses que herdarem element a implementar draw().

abstract class element extends commons {
 protected $attributes;
 
 final public function addAttribute( attribute $attribute ) {
  $this->attributes[] = $attribute;
 }
 
 final public function hasAttributes() {
  return count( $this->attributes ) > 0;
 }
 
 final public function getAttributes() {  
  $elementAttributes = '';   
  foreach( $this->attributes as $attribute ) {
   $elementAttributes .= "{$attribute->attribute}=\"{$attribute->value}\" ";
  }
  return $elementAttributes;  
 }
 
 abstract function draw();  
}

Na segunda parte da série de artigos, vamos iniciar a construção dos elementos. Espero vocês. Até a próxima!