Node.php

<?php
/*
 * This file is part of XRL, a simple XML-RPC Library for PHP.
 *
 * Copyright (c) 2012, XRL Team. All rights reserved.
 * XRL is licensed under the 3-clause BSD License.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace fpoirotte\XRL;

class Node
{
    protected $properties;

    const XML_ERR_INTERNAL_ERROR        = 1;
    const XML_ERR_NO_MEMORY             = 2;
    const XML_ERR_DOCUMENT_EMPTY        = 4;
    const XML_ERR_DOCUMENT_END          = 5;
    const XML_ERR_INVALID_CHAR          = 9;
    const XML_ERR_UNKNOWN_ENCODING      = 31;
    const XML_ERR_UNSUPPORTED_ENCODING  = 32;

    public function __construct(\XMLReader $reader, $validate, $subtrees)
    {
        do {
            // We must silence read()/next() as old PHPs (5.3.x) emit warnings
            // which get caught by PHPUnit and other custom error handlers
            // when the methods fail and this is known to cause some issues.
            if (($subtrees && !@$reader->read()) ||
                (!$subtrees && !@$reader->next())) {
                $error = libxml_get_last_error();

                // We reached the end of the document.
                // This is not an error per-se,
                // but it causes read() to fail anyway.
                // We throw a special error which gets caught
                // and dealt with appropriately by the caller.
                if ($error === false) {
                    throw new \InvalidArgumentException('End of document');
                }

                switch ($error->code) {
                    case self::XML_ERR_UNKNOWN_ENCODING:
                    case self::XML_ERR_UNSUPPORTED_ENCODING:
                        throw new \fpoirotte\XRL\Faults\UnsupportedEncodingException();

                    // Internal & memory errors are too hard to recreate
                    // and are thus excluded from code coverage analysis.
                    // @codeCoverageIgnoreStart
                    case self::XML_ERR_INTERNAL_ERROR:
                    case self::XML_ERR_NO_MEMORY:
                        throw new \fpoirotte\XRL\Faults\InternalErrorException();
                    // @codeCoverageIgnoreEnd

                    case self::XML_ERR_INVALID_CHAR:
                        throw new \fpoirotte\XRL\Faults\InvalidCharacterException();

                    // Generic error handling.
                    default:
                        throw new \fpoirotte\XRL\Faults\NotWellFormedException();
                }
            }

            if ($validate && !$reader->isValid()) {
                $errors = '';
                foreach (libxml_get_errors() as $error) {
                    $message    = trim($error->message);
                    $file       = $error->file;
                    $line       = $error->line;
                    $column     = $error->column;
                    $errors .= "$message in '$file' on line $line, column $column\n";
                }
                if ($errors) {
                    throw new \fpoirotte\XRL\Faults\InvalidXmlRpcException(trim($errors));
                } else {
                    // Use a generic error message in case the specific reason
                    // for the error cannot be pin-pointed.
                    throw new \fpoirotte\XRL\Faults\InvalidXmlRpcException();
                }
            }

            $subtrees = true;
        } while ($reader->nodeType === \XMLReader::SIGNIFICANT_WHITESPACE);

        $fields = array(
            'isEmptyElement',
            'localName',
            'namespaceURI',
            'nodeType',
            'value',
        );

        $this->properties = array();
        foreach ($fields as $field) {
            $this->properties[$field] = $reader->$field;
        }
        $name = $reader->localName;
        if ($reader->namespaceURI !== '') {
            $name = '{' . $reader->namespaceURI . '}' . $name;
        }
        $this->properties['name'] = $name;
    }

    public function __get($field)
    {
        if (!isset($this->properties[$field])) {
            throw new \UnexpectedValueException("Unknown property '$field'");
        }

        return $this->properties[$field];
    }

    public function emptyNodeExpansionWorked()
    {
        if ($this->properties['nodeType'] == \XMLReader::ELEMENT &&
            $this->properties['isEmptyElement'] == true) {
            $this->properties['nodeType'] = \XMLReader::END_ELEMENT;
            $this->properties['isEmptyElement'] = false;
            return true;
        }
        return false;
    }
}