Simple PoPo handling

[staabm]

hope its ok to open a support request here.

In my use-case I have a lot of xml which maps 1:1 to PlainOldPHPObjects like

 <order_response xmlns="http://mydomain.de/myobject">
 <request_id>4711</request_id>
 <order_id>54752</order_id>
 <status>INITIALIZED</status>
 <success>true</success>
 </order_response>

and classes like

class OrderResponse
{
    public $request_id;
    public $order_id;
    public $status;
    public $success;
}

no attributes involved. max complexitiy is having some "subobjects" (complex-properties).

is it really required to implement in all my POPO Objects per class xmlDeserialize and xmlSerialize logic? Or is there a simpler way to achieve that?

Any guidance is welcome ;)

[staabm]

I tried a lot of different things, but cant get something to work which I am comfortable with.

have things like

class PoPoXmlElement implements Sabre\Xml\Element
{
    private $popo;
    private $namespace;

    public function __construct($popo, $namespace)
    {
        $this->popo = $popo;
        $this->namespace = $namespace;
    }

    static function xmlDeserialize(Sabre\Xml\Reader $reader)
    {
        if ($reader->isEmptyElement) {
            throw new Exception(__CLASS__ . ' does not support empty elements');
        }

        $obj = clone $this->popo;

        $reader->read();
        do {

            if ($reader->nodeType === Sabre\Xml\Reader::ELEMENT && $reader->namespaceURI == $this->namespace) {

                $obj->{$reader->localName} = $reader->parseCurrentElement()['value'];
            } else {
                $reader->read();
            }
        } while ($reader->nodeType !== Sabre\Xml\Reader::END_ELEMENT);

        $reader->read();

        return $obj;
    }

    function xmlSerialize(Sabre\Xml\Writer $writer)
    {
        $writer->write($this->popo);
    }
}

but with this I have problems that I cannot reference $this in xmlDeserialize.
At best my Popo objects wont contain any xml/library dependent logic.

[evert]

This is all very interesting, because you're definitely running into issues that I hadn't anticipated. If you're willing to give your Popo objects their own xmlDeserializer it's all very simple, because you can just call:

$obj = new self;

but because you're separating the deserializers from the actual object you're deserializing, you're running into issues. Basically your main issue is that you want to re-use the same deserializer in a lot of different places, but pass a different configuration every time.

One way to solve this is to ditch the Element class, and just use plain closures for deserializers.

This works

$reader->elementMap['{http://mydomain.de/myobject}order_response'] = function(Reader $reader) {

};

but that doesn't give you a generic deserializer yet. If your deserializer looks like this though:

$popoDeserializer = function(Reader $reader, $popo, $namespace) {

};

Then you could just configure your element map as such:

$reader->elementMap['{http://mydomain.de/myobject}order_response'] = function(Reader $reader) {
   $popoDeserializer($reader, "OrderResponse", "http://mydomain.de/myobject");
};

Could this be done better? I'm not sure? Would you want to be able to pass configuration at all times or is this good enough? Definitely open to ideas.

Now on the serializing end... again the library is kind of designed for objects to be able to serialize themselves. I do have two ideas that could be useful though:

1. If an object does not implement XmlSerializable, we could just by default serialize all its keys and values. Very simple.
2. We could also add a separate "classMap" similar to the "elementMap" that's used during writing instead of reading, and allows uses to create custom serializers for objects that don't implement XmlSerializable. This could be useful too if for example you'd want to have a standard way to serialize, say, PHP DateTime objects.

Let me know if either of those sound appealing. I'd totally be open to either or both.

[staabm]

Actually we need some magic/workarounds because xmlDeserialize() is static.
Thats the actual design flaw.

To get the "configuration" part into a proper class it requires some dark magic, global state or similar.
(In case we aim for library independent popo objects and a separate serializer)

[evert]

Well, I don't think that xmlDeserialize being static is the worst thing... but I would say, simply don't use XmlDeserializable at all for cases such as yours. Just use standard callbacks so you can easily pass state using closures.

I also have another thought regarding the reader... it would also be possible to create a small separate function that just returns a reference to a deserializer for a value. Then you would be able to subclass the reader and do basically whatever you need.

[evert]

And remember that you can definitely change things up in this way as well:

// Note that we don't implement XmlDeserializable here
class MyDeserializer {

   // Not static
   function xmlDeserialize(Reader $reader) {
   }

}

// and then

$myDeserializer = new MyDeserializer();

$elementMap['...'] = [$myDeserializer, 'xmlDeserialize'];

[evert]

But for what it's worth I'm not running into a very similar issue. I want to improve reading XML in VObject and I also need to pass parser state around.

[staabm]

I will try your suggestions, thanks for the input.

Initally I thought I could get something from Sabre\Xml\Service but couldnt find docs or real world samples.

[evert]

The service is basically just a 'convenience wrapper'. It doesn't add any features.

[staabm]

This is my first attempt, which works pretty ok right now, even for nested structures:

$popoDeserializer = function(Sabre\Xml\Reader $reader, $popo, $namespace)
{
    if ($reader->isEmptyElement) {
        throw new Exception(__CLASS__ . ' does not support empty elements');
    }

    $reader->read();
    do {

        if ($reader->nodeType === Sabre\Xml\Reader::ELEMENT && $reader->namespaceURI == $namespace) {

            $popo->{$reader->localName} = $reader->parseCurrentElement()['value'];
        } else {
            $reader->read();
        }
    } while ($reader->nodeType !== Sabre\Xml\Reader::END_ELEMENT);

    $reader->read();

    return $popo;
};

class OrderResponse
{
    public $request_id;
    public $order_id;
    public $status_status;
    public $success;
}

class OrderStatus
{
    public $status;
}

$xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <order_response xmlns="http://b2bOrder.mydomain.de">
 <request_id>4711</request_id>
 <order_id>54752</order_id>
    <order_status xmlns="http://b2bOrder.mydomain.de">
         <status>INITIALIZED</status>
    </order_status>
 <success>true</success>
 </order_response>';

$reader = new Sabre\Xml\Reader();
$reader->elementMap = array(
    '{http://b2bOrder.mydomain.de}order_response' => function (Sabre\Xml\Reader $reader) use ($popoDeserializer) {
        return $popoDeserializer($reader, new OrderResponse(), 'http://b2bOrder.mydomain.de');
    },
    '{http://b2bOrder.complex.de}order_status' => function (Sabre\Xml\Reader $reader) use ($popoDeserializer) {
        return $popoDeserializer($reader, new OrderStatus(), 'http://b2bOrder.mydomain.de');
    },
);
$reader->xml($xml);
var_dump($reader->parse());

/* Output:
array(3) {
  ["name"]=>
  string(42) "{http://b2bOrder.complex.de}order_response"
  ["value"]=>
  object(OrderResponse)#7 (5) {
    ["request_id"]=>
    string(4) "4711"
    ["order_id"]=>
    string(5) "54752"
    ["status_status"]=>
    NULL
    ["success"]=>
    string(4) "true"
    ["order_status"]=>
    object(OrderStatus)#8 (1) {
      ["status"]=>
      string(11) "INITIALIZED"
    }
  }
  ["attributes"]=>
  array(0) {
  }
}
*/

I am wondering where the attributes are coming from, because my deserializer doesnt add those..

next step: writing xml

[staabm]

Soooo.. Writing:

The Writer atm does not support callables for xml-serialization, actually it doesnt support object types at all.

I have the same goal here:

• popo should not contain xml logic

Actually I expect the following use-case - as an overall picture:

$xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <order_response xmlns="http://b2bOrder.complex.de">
 <request_id>4711</request_id>
 <order_id>54752</order_id>
    <order_status xmlns="http://b2bOrder.complex.de">
         <status>INITIALIZED</status>
    </order_status>
 <success>true</success>
 </order_response>';

define("XMLNS_ORDER", "http://b2bOrder.complex.de");
$reader = new Sabre\Xml\Reader();
$reader->elementMap = array(
    '{'. XMLNS_ORDER .'}order_response' => function (Sabre\Xml\Reader $reader) use ($popoDeserializer) {
        return $popoDeserializer($reader, new OrderResponse(), XMLNS_ORDER);
    },
    '{'. XMLNS_ORDER .'}order_status' => function (Sabre\Xml\Reader $reader) use ($popoDeserializer) {
        return $popoDeserializer($reader, new OrderStatus(), XMLNS_ORDER);
    },
    // ....
);
$reader->xml($xml);
$orderResponse = $reader->parse()['value'];

$writer = new Sabre\Xml\Writer();
$writer->openMemory();
// API calls to be defined...
$writer->write($orderResponse);
assert($writer->outputMemory() === $xml);

At best I need to define the xml <-> object mapping only in one place and can "re-use" it for reading and writing.

[evert]

I am wondering where the attributes are coming from, because my deserializer doesnt add those..

The top-level array with the name, value and attributes key can't be changed. However, you could look at the Service object. There you can use parse and expect and both of these functions will actually strip the top-level array and just return the first value element, which is what most people want.

Using expect you can automatically throw an exception if the top-level element name was not what you wanted.

popo should not contain xml logic

What I would want to propose is to add a new classMap that allows you to define serializers (using callbacks) based on their class. That should solve your problem. If you like that idea, let me know and I'll be happy to work on that today.

[staabm]

allows you to define serializers (using callbacks) based on their class. That should solve your problem. If you like that idea, let me know and I'll be happy to work on that today.

I guess this could work.

[evert]

Alright, lets do that. Unless you have different ideas?