Como faço isso?

[Godoi 0]

Bom dia meu povo...

 

Seguinte, to pegando POO com PHP agora, e comecei minhas classes e tudo mais.

 

To fazendo uma classe para criar arquivos de configuração em XML pra mim. então segue o código (ps: esse é somente uma parte dela..)

 

<?php
class Config_Files{

protected $_xmlw;
protected $_child;

public function __construct($version = '1.0', $charset = 'utf-8'){
	$this->_xmlw = new DOMDocument($version, $charset);
	$this->_xmlw->formatOutput = true;
	$this->_child = $this->_xmlw->createElement('Config');
	$this->_xmlw->appendChild($this->_child);
}

public function addNode($name){
	$this->_child = $this->_xmlw->createElement($name);
	$this->_xmlw->appendChild($this->_child);
}

public function addText($text){
	$text = $this->_xmlw->createTextNode($text);
	$this->_child->appendChild($text);
}

public function endFile(){
    echo $this->_xmlw->saveXML();
}
}
?>

 

Se eu usar da seguinte forma funciona e meu xml sai direitinho;

 

<?php
$novoconfig = new Config_Files;
$novoconfig->addNode('nofilho');
$novoconfig->addText('Texto no filho');
$novoconfig->endFile;
?>

 

mas eu quero usar as funcoes assim:

 

<?php
$novoconfig = new Config_File;
$novoconfig->addNode('nofilho')->addText('Texto no filho');
$novoconfig->endFile;
?>

 

Com qual principio eu posso fazer isso? Me passem como fazer.. não como implementar isso nesse código.. hehe quero aprender.. links com conteúdo também são extremamente bem vindos..

 

Vlw pessoal..

[William Bruno 1501]

Com qual principio eu posso fazer isso? Me passem como fazer..

Fluent Interface

 

retorne o objeto atual no fim de cada método.

 

não pense 'quero fazer assim', pense: 'se faz sentido fazer assim'.

[Bruno Augusto 417]

retorne o objeto atual no fim de cada método.

Não necessariamente o objeto atual, William. Desde que método anteriormente invocado retorne um objeto válido, a cadeia pode continuar.

[William Bruno 1501]

Não necessariamente o objeto atual, William.

sim exato, mas no contexto dele, como pretende trabalhar apenas com os métodos do objeto gerado apartir da class Config_Files, fez mais sentido eu falar do objeto atual, até para não confundir o colega.

[Godoi 0]

Entendi, e vou pesquisar a respeito..

 

mas no meu contexto, ao meu ponto de vista, torna meu código mais fácil.

 

estou certo?

 

So pra avisar,

 

Consegui implementar o código, na realidade nem é tão difícil assim.

 

A meu ver ficou muito mais fácil. Alem de economizar meus dedos quando for usar a classe.. hehe.

 

Assim que terminar essa classe, vou posta-la aqui a quem interessar..

 

Vlw pessoal

[Andrey Knupp Vital 136]

Olá, Vejo que Sua Classe é pra Lidar

Com XML ? Se sim

Tem Algo Aqui que pode lhe ser util :lol:

 

:seta: http://forum.imasters.com.br/topic/431301-classe-para-xml-html/page__pid__1702482#entry1702482

[Godoi 0]

Andrey,

 

Muito obrigado,

 

mas o motivo principal de eu estar criando isso.. e quero aprender.. OOP, MVC, e saber implementa-los de forma mais correta possivel...

 

depois que eu souber, ai sim, com certeza vou procurar as bibliotecas e codicos prontos para poder me auxiliar a resolver meus problemas de forma mais fácil e rápida..

 

mas vlw mesmo assim..

 

Abraço.

[Andrey Knupp Vital 136]

Nen sempre a Criação das Classes

São a Solução mais Rapida Para Certo Tipo de Problema

MVC Tem um Proposito, OOP Tambem

Não 'Procurar os Codigos, Ou Solução Mais Rapida' é sim Saber Quando é onde Utilizar dos Recursos

Que o PHP nos oferece ;)

 

 

Em Questão da Sua Duvida, Basta Retornar $this

Isso Siginifica Que Você Está Retornando 'isto, este, ou esta'

 

Então

<?php
     class Fabrica{
          public $Boneco, $Vende, $Troca;

                public function Monta(){
                       $this->Boneco = 'Montamos um Boneco !!!';
                       return $this;
                }
                public function Vende(){
                       $this->Vende = 'Vendemos um Boneco !!!';
                       return $this;
                }
                final public function Troca(){
                       $this->Troca = 'Trocamos um Boneco !!!';
                       return $this->Boneco . PHP_EOL . $this->Vende . PHP_EOL . $this->Troca;
                }

    }
    $Fabrica = new Fabrica();
    echo $Fabrica->Monta()->Vende()->Troca();

 

Saida:

Montamos um Boneco !!! Vendemos um Boneco !!! Trocamos um Boneco !!!

 

^_^

[André Severino 3]

Assim como você tenho a mesma dúvida então digo o seguinte, porque não fazer o node e o texto juntos. no mesmo método?

Por exemplo, voce apenas declara o node(obrigatório) e o texto você deixa como opcional, assim em um próprio metodo você insere 2 valores, isso está certo ou errado ?!?!

 

<?php
class Config_Files{

       protected $_xmlw;
       protected $_child;

       public function __construct($version = '1.0', $charset = 'utf-8'){
               $this->_xmlw = new DOMDocument($version, $charset);
               $this->_xmlw->formatOutput = true;
               $this->_child = $this->_xmlw->createElement('Config');
               $this->_xmlw->appendChild($this->_child);
       }

       public function addNode($name, $text = NULL){
               $this->_child = $this->_xmlw->createElement($name);
               $this->_xmlw->appendChild($this->_child);

               $text = $this->_xmlw->createTextNode($text);
               $this->_child->appendChild($text);
       }

       public function endFile(){
           echo $this->_xmlw->saveXML();
       }
}
?>

 

Na implementação seria apenas

<?php
$novoconfig = new Config_File;
$novoconfig->addNode('nofilho', 'Texto no filho'); // Com texto
$novoconfig->addNode('nofilho2'); // Sem texto
$novoconfig->endFile;
?>

 

Isto estaria certo?

[Andrey Knupp Vital 136]

Não Prescisa de Invocar Mais um Metodo

Para Criar o Texto ao Elemento

 

<?php
  $DOMDocument = new DOMDocument( '1.0', 'iso-8859-1' );
  $Element = $DOMDocument->createElement( 'node', 'texto ...' );
  $DOMDocument->appendChild( $Element );

[Godoi 0]

Bem, realmente,

 

mas e se for pra eu criar um nó, que recebera outros.. ele não tem a necessidade de ter um texto dentro.. e outra.. e se eu for criar um nó... com um conteudo que tenha CDATA... acho melhor criar metodos independentes para trabalhar com isso.. da mesma forma que um metodo para criar atributos ao nó..

 

  $novono->addChild('config')->setAttribute('database' ,'mysql')->addText('qualquertexto');

 

acho que fica mais legivel assim.

[Andrey Knupp Vital 136]

Bem ai e Contigo, a Reescrita dos Metodos Nen Sempre Pode ser a Melhor Solução ^_^

Se Prescisar Criar um Nó Dentro de Outro

 

<?php
	$DOM = new DOMDocument();
$Node = $DOM->createElement( 'pai' );
$Element = $DOM->appendChild( $Node );
$Append = $Element->createElement( 'filho', 'oi' );
$DOM->appendChild( $Append );
...

Isso Faz uma Hierarquia .. Mais Fique atento a Semântica

:)

[Godoi 0]

é realmente,

 

ainda estou limpando o código... mas esta ficando legal.. fazendo testes e aprendendo.. hehe

 

<?php

$teste = new Tools_Files_Dom();

$teste->startFile("teste.xml", ".");
$teste->addRoot("config");
$teste->addChild('filho');

for($i = 0; $i<10; $i++){
	$teste->addChild('neto', true);
if($i == 3){
	$teste->setAttribute('type' ,'database')->addText('Neto com attributo');
} else {
	$teste->addText('nome '.$i);
}
$teste->getNode('filho',true);
}

$teste->addChild('esposa', false)->addText('MinhaEsposa');
$teste->endFile();

class Tools_Files_Dom {

	// @ Domdocument for read
	protected $_xml = null; 

	// @ Domdocument for write
	protected $_xmlw = null;

	// @ Path for write
	protected $_path = null;

	// @ Filename for write
	protected $_file = null;

	// @ Dom Element
	protected $_child = null;

	// @ Dom root Element
	protected $_root = null;

	// @ Dom frament Element
	protected $_fragment = null;


/**
* @ Carregar arquivo via string
*
* @ Param string $file
* @ Retorna DOMDocument
*/
public function loadFile($file)
{
	if(is_readable($file)){
		$this->_xml = new DOMDocument();
		$this->_xml->load($file);
	} else {
		// Adicionar Exceptiond
		echo 'não leu';
	}
}

/**
* @ Retorna um nó do elemento
*
* @ Param string $node
* @ Param int $level
* @ Retorna DOMNode
*/
public function getNode($node, $insert = false, $level = 0)
{
	if(!$insert){
		return $this->_xml->getElementsByTagName($node)->item($level);
	} else {
		$this->_child = $this->_xmlw->getElementsByTagName($node)->item($level);
	}
}

/**
* @ Retorna o valor de um nó
*
* @ Param string $node
* @ Param int $level = 0
* @ Retorna string
*/
public function getNodeValue($node, $level = 0)
{
	return $this->getNode($node, $level)->nodeValue;
}

/**
* @ Retorna o nome de um nó
*
* @ Param string $node
* @ Param int $level = 0
* @ Retorna string
*/
public function getNodeName($node, $level = 0)
{
	return $this->getNode($node, $level)->nodeName;
}

/**
* @ Retorna os atributos de um nó
*
* @ Param string $node
* @ Param int $level = 0
* @ Retorna array
*/
public function getNodeAtt($node)
{
	$a = array();		
	$node = $this->getNode($node);
	if($node->hasAttributes()){
		$attributes = $node->attributes;	
		if(!is_null($attributes)){
			foreach($attributes as $key => $attr){
				$a[$attr->name] = $attr->value;
			}
		}
	}
	return $a;
}

/**
* @ Inicia a escrita de um arquivo
*
* A fazer, verificar se a pasta de destino é passivel de escrita
*
* @ Param string $filename
* @ Param string $folder
* @ Retorna bool
*/
public function startFile($filename, $path, $version = '1.0', $charset = 'utf-8')
{
	if(is_dir($path)){
		$this->_xmlw = new DOMDocument($version, $charset);
		$this->_xmlw->formatOutput = true;
		$this->_file = $filename;
		$this->_path = $path;
	} else {
		// Exception
		echo 'nao criou';
	}	
}

/**
* @ Adiciona o nó root
*
* @ Param tipo $variavel
* @ Retorna tipo
*/
public function addRoot($name)
{
	$this->_root = $this->_xmlw->createElement($name);
	$this->_xmlw->appendChild($this->_root);
}

/**
* @ Cria um child no documento XML
*
* @ Param string $name
* @ Param bool $child
*/
public function addChild($name, $child = false)
{
	$node = $this->_xmlw->createElement($name);

	if($child){
		$this->_child->appendChild($node);
	} else {
		$this->_root->appendChild($node);
	}

	$this->_child = $node;
	return $this;
}

/**
* @ Cria um texto dentro do nó atual
*
* @ Param string $text
*/
public function addText($text)
{
	$text = $this->_xmlw->createTextNode($text);
	$this->_child->appendChild($text);
	return $this;
}

/**
* @ Cria um attributo no nó atual
*
* @ Param string $key
* @ Param string $value
*/
public function setAttribute($key, $value)
{
	$this->_child->setAttribute($key, $value);
	return $this;
}

/**
* @ Salva o documento XML
*
* @ Param tipo $variavel
* @ Retorna tipo
*/
public function endFile()
{
    echo $this->_xmlw->saveXML();
}



}

?>

 

esse código retorna exatamente isso aqui:

 

<?xml version="1.0" encoding="utf-8"?> 
<config> 
 <filho> 
   <neto>nome 0</neto> 
   <neto>nome 1</neto> 
   <neto>nome 2</neto> 
   <neto type="database">Neto com attributo</neto> 
   <neto>nome 4</neto> 
   <neto>nome 5</neto> 
   <neto>nome 6</neto> 
   <neto>nome 7</neto> 
   <neto>nome 8</neto> 
   <neto>nome 9</neto> 
 </filho> 
 <esposa>MinhaEsposa</esposa> 
</config>