Como faço isso?

>
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'.

>
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.

>
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.

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

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

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.

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 !!!

^_^

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?

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 );

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.

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

 :)

é 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>