OOP - Extending DOMElement in PHP with registerNodeClass

Question

registerNodeClass is great for extending the various DOMNode-based DOM classes in PHP, but I need to go one level deeper.

I've created an extDOMElement that extends DOMElement. This works great with registerNodeClass, but I would like to have something that works more like this: registerNodeClass("DOMElement->nodeName='XYZ'", 'extDOMXYZElement')

Consider the following XML document, animals.xml:

<animals>
    <dog name="fido" />
    <dog name="lucky" />
    <cat name="scratchy" />
    <horse name="flicka" />
</animals>

Consider the following code:

extDomDocument extends DOMDocument {
    public function processAnimals() {
        $animals = $this->documentElement->childNodes;
        foreach($animals as $animal) {
            $animal->process();
        }
    }
}


extDOMElement extends DOMElement {
    public function process() {
        if ($this->nodeName=='dog'){
            $this->bark();
        } elseif ($this->nodeName=='cat'){
            $this->meow();
        } elseif  ($this->nodeName=='horse'){
            $this->whinny();
        }
        this->setAttribute('processed','true');
    }
    private function bark () {
        echo "$this->getAttribute('name') the $this->nodeName barks!";
    }
    private function meow() {
        echo "$this->getAttribute('name') the $this->nodeName meows!";
    }
    private function whinny() {
        echo "$this->getAttribute('name') the $this->nodeName whinnies!";
    }
}

$doc = new extDOMDocument();
$doc->registerNodeClass('DOMElement', 'extDOMElement');
$doc->loadXMLFile('animals.xml');
$doc->processAnimals();
$doc->saveXMLFile('animals_processed_' . Now() . '.xml');

Output: fido the dog barks! lucky the dog barks! scratchy the cat meows! flicka the horse whinnies!

I don't want to have to put bark(), meow() and whinny() into extDOMElement - I want to put them into extDOMDogElement, extDOMCatElement and extDOMHorseElement, respectively.

I've looked at the Decorator and Strategy patterns here, but I'm not exactly sure how to proceed. The current setup works OK, but I'd prefer to have shared properties and methods in extDOMElement with separate classes for each ElementName, so that I can separate methods and properties specific to each Element out of the main classes.

Answer 1

EDIT for the code you show, wouldn't it be easier not to extend DOMElement at all? Just pass in the regular DOMElements to your processing Strategies, e.g.

class AnimalProcessor
{
    public function processAnimals(DOMDocument $dom) {
        foreach($dom->documentElement->childNodes as $animal) {
            $strategy = $animal->tagName . 'Strategy';
            $strategy = new $strategy($animal);
            $strategy->process();
        }
    }
}

$dom = new DOMDocument;
$dom->load('animals.xml');
$processor = new AnimalProcessor;
$processor->processAnimals($dom);

---

Original answer before question update

Not sure if this is what you are looking for, but if you want specialized DOMElements, you can simply create them and use them directly, e.g. bypassing createElement, so you dont have to registerNodeClass at all.

class DogElement extends DOMElement
{
    public function __construct($value) 
    {
        parent::__construct('dog', $value);
    }
}
class CatElement extends DOMElement
{
    public function __construct($value) 
    {
        parent::__construct('cat', $value);
    }
}
$dom = new DOMDocument;
$dom->loadXML('<animals/>');
$dom->documentElement->appendChild(new DogElement('Sparky'));
$dom->documentElement->appendChild(new CatElement('Tinky'));
echo $dom->saveXml();

---

I don't think you can easily use registerNodeClass to instantiate elements based on the tagname or influence parsing that much. But you can override DOMDocument's createElement class, e.g.

class MyDOMDocument extends DOMDocument
{
    public function createElement($nodeType, $value = NULL)
    {
        $nodeType = $nodeType . 'Element';
        return new $nodeType($value);
    }
}
$dom = new MyDOMDocument;
$dom->loadXML('<animals/>');
var_dump( $dom->createElement('Dog', 'Sparky') ); // DogElement
var_dump( $dom->createElement('Cat', 'Tinky') ); // CatElement
echo $dom->saveXml();

Answer 2

I can't really pin point it but what you're trying has a certain smell, like Gordon already pointed out.
Anyway... you could use __call() to expose different methods on your extDOMElement object depending on the actual node (type/contents/...). For that purpose your extDOMElement object could store an helper object which is instantiated according to the "type" of the element and then delegate method calls to this helper object. Personally I don't like that too much as it doesn't exactly make documentation, testing and debugging any easier. If that sounds feasible to you I can write down a self-contained example.

---

This certainly needs comments/documentation ...work in progress since I don't have the time right now...

<?php
$doc = new MyDOMDocument('1.0', 'iso-8859-1');
$doc->loadxml('<animals>
  <Foo name="fido" />
  <Bar name="lucky" />
  <Foo name="scratchy" />
  <Ham name="flicka" />
  <Egg name="donald" />
</animals>');
$xpath = new DOMXPath($doc);
foreach( $xpath->query('//Foo') as $e ) {
  echo $e->name(), ': ', $e->foo(), "\n";
}
echo "----\n";
foreach( $xpath->query('//Bar') as $e ) {
  echo $e->name(), ': ', $e->bar(), "\n";
}
echo "====\n";
echo $doc->savexml();


class MyDOMElement extends DOMElement {
  protected $helper;

  public function getHelper() {
    // lazy loading and caching the helper object
    // since lookup/instantiation can be costly
    if ( is_null($this->helper) ) {
      $this->helper = $this->resolveHelper();
    }
    return $this->helper;
  }

  public function isType($t) {
    return $this->getHelper() instanceof $t;
  }

  public function __call($name, $args) {
    $helper = $this->getHelper();
    if ( !method_exists($helper, $name) ) {
      var_dump($name, $args, $helper);
      throw new Exception('yaddayadda');
    }
    return call_user_func_array( array($this->helper, $name), $args);
  }

  public function releaseHelper() {
    // you might want to consider something like this
    // to help php with the circular references
    // ...or maybe not, haven't tested the impact circual references have on php's gc
    $this->helper = null;
  }

  protected function resolveHelper() {
    // this is hardcored only for brevity's sake
    // add any kind of lookup/factory/... you like
    $rv = null;
    switch( $this->tagName ) {
      case 'Foo':
      case 'Bar':
        $cn = "DOMHelper".$this->tagName;
        return new $cn($this);
      default:
        return new DOMHelper($this);
        break;
    }
  }
}

class MyDOMDocument extends DOMDocument {
  public function __construct($version=null,$encoding=null) {
    parent::__construct($version,$encoding);
    $this->registerNodeClass('DOMElement', 'MyDOMElement');
  }
}

class DOMHelper {
  protected $node;
  public function __construct(DOMNode $node) {
    $this->node = $node;
  }
  public function name() { return $this->node->getAttribute("name"); }
}

class DOMHelperFoo extends DOMHelper {
  public function foo() {
    echo 'foo';
    $this->node->appendChild(  $this->node->ownerDocument->createElement('action', 'something'));
  }
}

class DOMHelperBar extends DOMHelper {
  public function bar() {
    echo 'bar';
    $this->node->setAttribute('done', '1');
  }
}

prints

fido: foo
scratchy: foo
----
lucky: bar
====
<?xml version="1.0"?>
<animals>
  <Foo name="fido"><action>something</action></Foo>
  <Bar name="lucky" done="1"/>
  <Foo name="scratchy"><action>something</action></Foo>
  <Ham name="flicka"/>
  <Egg name="donald"/>
</animals>