DOM.php

<?php
/*
    This file is part of Erebot, a modular IRC bot written in PHP.

    Copyright © 2010 François Poirotte

    Erebot is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Erebot is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Erebot.  If not, see <http://www.gnu.org/licenses/>.
*/

namespace Erebot;

if (!defined('XML_PARSE_BIG_LINES')) {
    define('XML_PARSE_BIG_LINES', 1 << 22);
}

class DOM extends \DomDocument
{
    protected $errors;

    public function __construct($version = null, $encoding = null)
    {
        $this->clearErrors();
        if ($version === null && $encoding === null) {
            parent::__construct();
        } elseif ($encoding === null) {
            parent::__construct($version);
        } else {
            parent::__construct($version, $encoding);
        }
    }

    public function relaxNGValidate($filename, $schematron = true)
    {
        $success = parent::relaxNGValidate($filename);
        return $this->schematronValidation(
            'file',
            $filename,
            'RNG',
            $success,
            $schematron
        );
    }

    public function relaxNGValidateSource($source, $schematron = true)
    {
        $success = parent::relaxNGValidateSource($source);
        return $this->schematronValidation(
            'string',
            $source,
            'RNG',
            $success,
            $schematron
        );
    }

    public function schemaValidate($filename, $schematron = true)
    {
        $success = parent::schemaValidate($filename);
        return $this->schematronValidation(
            'file',
            $filename,
            'XSD',
            $success,
            $schematron
        );
    }

    public function schemaValidateSource($source, $schematron = true)
    {
        $success = parent::schemaValidateSource($source);
        return $this->schematronValidation(
            'string',
            $source,
            'XSD',
            $success,
            $schematron
        );
    }

    protected function schematronValidation(
        $source,
        $data,
        $schemaSource,
        $success,
        $schematron
    ) {
        try {
            $base = dirname(__DIR__) .
                    DIRECTORY_SEPARATOR . 'data' .
                    DIRECTORY_SEPARATOR;
            $xsl1 = $base . 'ExtractSchFrom' . $schemaSource . '.xsl';
            $skeleton = $base . 'iso_schematron_skeleton_for_xslt1.xsl';
        } catch (\Exception $e) {
            return false;
        }

        $quiet = !libxml_use_internal_errors();
        if (!$quiet) {
            $this->errors = array_merge($this->errors, libxml_get_errors());
            libxml_clear_errors();
        }
        if (!$success || !$schematron) {
            return $success;
        }

        $schema = new \DomDocument();
        if ($source === 'file') {
            $success = $schema->load($data, XML_PARSE_BIG_LINES);
        } else {
            $success = $schema->loadXML($data, XML_PARSE_BIG_LINES);
        }

        if (!$quiet) {
            $this->errors = array_merge($this->errors, libxml_get_errors());
            libxml_clear_errors();
        }
        if (!$success) {
            return false;
        }

        // Load the extracting stylesheet.
        $extractor  = new \DomDocument();
        $success    = $extractor->loadXML(file_get_contents($xsl1), XML_PARSE_BIG_LINES);
        if (!$quiet) {
            $this->errors = array_merge($this->errors, libxml_get_errors());
            libxml_clear_errors();
        }
        if (!$success) {
            return false;
        }

        // Generate a Schematron schema from the rules
        // embedded in the RNG or XSD schema.
        $processor = new \XSLTProcessor();
        $processor->importStylesheet($extractor);
        $result = $processor->transformToDoc($schema);
        if ($result === false) {
            return false;
        }

        // Load the Schematron skeleton.
        $validator  = new \DomDocument();
        $success    = $validator->loadXML(file_get_contents($skeleton), XML_PARSE_BIG_LINES);
        if (!$quiet) {
            $this->errors = array_merge($this->errors, libxml_get_errors());
            libxml_clear_errors();
        }
        if (!$success) {
            return false;
        }

        // Generate the validation XML stylesheet
        // using the Schematron schema & skeleton.
        $processor->importStylesheet($validator);
        $result = $processor->transformToDoc($result);
        if ($result === false) {
            return false;
        }

        // Apply the validation stylesheet to the document.
        $processor = new \XSLTProcessor();
        $processor->registerPHPFunctions('\\Erebot\\DOM::getNodeLineNo');
        $processor->importStylesheet($result);
        $result = $processor->transformToDoc($this);
        if ($result === false) {
            return false;
        }

        $valid  = true;
        foreach ($result->documentElement->childNodes as $child) {
            if ($child->nodeType !== XML_ELEMENT_NODE) {
                continue;
            }

            if ($child->localName !== 'assertionFailure') {
                continue;
            }

            $valid = false;

            // If running in quiet mode, don't report errors.
            if ($quiet) {
                continue;
            }

            $error = new \LibXMLError();
            $error->level   = LIBXML_ERR_ERROR;
            $error->code    = 0;
            $error->column  = 0;
            $error->message = '';
            $error->file    = $this->documentURI;
            $error->line    = 0;
            $error->path    = '';

            foreach ($child->childNodes as $subchild) {
                if ($subchild->nodeType !== XML_ELEMENT_NODE) {
                    continue;
                }
                if ($subchild->localName === 'description' && $error->message === '') {
                    $error->message = $subchild->textContent;
                } elseif ($subchild->localName === 'location' && $error->path === '') {
                    $error->path = $subchild->textContent;
                } elseif ($subchild->localName === 'line') {
                    $error->line = (int) $subchild->textContent;
                }
            }
            $this->errors[] = $error;
        }
        return $valid;
    }

    public function validate($schematron = false)
    {
        $success    = parent::validate();
        $quiet      = !libxml_use_internal_errors();
        if (!$quiet) {
            $this->errors = array_merge($this->errors, libxml_get_errors());
            libxml_clear_errors();
        }
        return $success;
    }

    public function getErrors()
    {
        return $this->errors;
    }

    public function clearErrors()
    {
        $this->errors = array();
    }

    public static function getNodeLineNo(array $nodes)
    {
        if (count($nodes) !== 1 || !($nodes[0] instanceof \DOMNode )) {
            throw new \Exception();
        }
        return $nodes[0]->getLineNo();
    }
}