root/trunk/patXMLPretty/Engine/DOM.php

<?php
/**
 * File containing the patXMLPretty_Engine_DOM class.
 *
 * @package        patXMLPretty
 * @subpackage     Engine
 * @author        Sebastian 'The Argh' Mordziol <argh@php-tools.net>
 * @see         patXMLPretty_Engine_DOM
 */

/**
 * Notice: unknown/unsupported node type
 */
 define( 'PATXMLPRETTY_ENGINE_DOM_NOTICE_UNKNOWN_NODE_TYPE', 'patXMLPretty_Engine_DOM:01' );

/**
 * Error: invalid source XML document, could not be parsed
 *
 */
 define( 'PATXMLPRETTY_ENGINE_DOM_ERROR_INVALID_SOURCE_DOCUMENT', 'patXMLPretty_Engine_DOM:02' );

/**
 * Warning: wrong PHP version
 */
 define( 'PATXMLPRETTY_ENGINE_DOM_WARNING_WRONG_PHPVERSION', 'patXMLPretty_Engine_DOM:01' );

/**
 * DOM parsing engine that used the PHP5 DOM parser to create the
 * elements structure used by patXMLPretty renderers, as well as
 * some meta information about the document.
 *
 * @package        patXMLPretty
 * @subpackage     Engine
 * @author        Sebastian 'The Argh' Mordziol <argh@php-tools.net>
 * @version        0.1.0
 * @license        LGPL
 * @link        http://www.php-tools.net
 * @see         patXMLPretty_Engine
 */
class patXMLPretty_Engine_DOM extends patXMLPretty_Engine
{
   /**
    * Stores the name of the engine
    *
    * @access    private
    * @var        string
    */
    var $name = 'DOM';

   /**
    * Stores the engine's options:
    *
    * <ul>
    *     <li>
    *         <b>parseDoctype</b> [yes|no] default: no<br/>
    *         Sets whether to parse a doctype declaration if present. If the renderer supports it, the doctype will be included in the generated highlighted source.
    *    </li>
    *     <li>
    *         <b>inputType</b> [xml|html] default: xml<br/>
    *         Sets the type of input to handle.
    *     </li>
    * </ul>
    *
    * @access    private
    * @var         array
    */
    var $options = array(
        'parseDoctype' => 'no',
        'inputType' => 'xml'
    );

   /**
    * Parses the XML source and creates the array-based
    * elements tree used internally by the renderers to
    * create the highlighted XML source.
    *
    * @access    public
    * @param    string
    * @return    array|patError
    */
    function parse( $xmlSource )
    {
        // check for php5
        if( substr( phpversion(), 0, 1 ) < 5 ) {
            $error = patErrorManager::raiseWarning(
                PATXMLPRETTY_ENGINE_DOM_WARNING_WRONG_PHPVERSION,
                $this->userMessages['warning'],
                'You cannot use the DOM parsing engine with PHP versions prior to PHP5.'
            );

            return $error;
        }

        // create the DOM object
        $dom = new DOMDocument();
        $dom->preserveWhiteSpace = true;
        $dom->substituteEntities = false;

        // manage the selected input type to parse
        // either HTML or XML.
        $method = 'loadXML';
        if( $this->getOption( 'inputType' ) == 'html' ) {
            $method = 'loadHTML';
        }

        // use output buffering to capture parsing messages
        ob_start();
        $success = $dom->$method( $xmlSource );
        $messages = ob_get_contents();
        ob_end_clean();

        // parsing successful?
        if( !$success ) {
            $error = patErrorManager::raiseError(
                PATXMLPRETTY_ENGINE_DOM_ERROR_INVALID_SOURCE_DOCUMENT,
                $this->userMessages['error'],
                'The XML source could not be parsed properly, the DOM parser '.
                'reported errors. Original parser messages:<br/><br/>'.strip_tags( $messages )
            );

            return $error;
        }

        $doctype = null;
        if( $this->getOption( 'parseDoctype' ) == 'yes' ) {
            $doctype = $this->_detectDoctype( $xmlSource );
        }

        // create the output array with document
        // information and the elements tree.
        $output = array(
            'document' => $this->_create_document( $dom ),
            'elements' => $this->_create_tree( $dom->documentElement ),
            'doctype' => $doctype
        );

        return $output;
    }

   /**
    * Creates the array containing information about the
    * XML document, like its encoding or version.
    *
    * @access    private
    * @param    DOMDocument
    * @return    array
    */
    function _create_document( $dom )
    {
        $encoding = 'UTF-8';
        if( !empty( $dom->encoding ) ) {
            $encoding = $dom->encoding;
        }

        $standalone = 'no';
        if( $dom->standalone ) {
            $standalone = 'yes';
        }

        $document = array(
            'encoding' => $encoding,
            'version' => $dom->version,
            'standalone' => $standalone,
        );

        return $document;
    }

   /**
    * Creates the elements tree recursively.
    *
    * @access    private
    * @param    DOMNode
    * @return    array|bool
    */
    function _create_tree( $node )
    {
        $nodeType = $this->_translate_node_type( $node->nodeType );
        if( !$nodeType ) {
            return false;
        }

        // the node data collection
        $nodeData = array();
        $nodeData['name'] = $node->nodeName;
        $nodeData['type'] = $nodeType;
        $nodeData['text'] = null;
        $nodeData['attributes'] = null;
        $nodeData['children'] = null;

        $method = '_handleNode_'.$nodeType;
        if( method_exists( $this, $method ) ) {
            $success = $this->$method( $node, $nodeData );
            if( !$success ) {
                $result = false;
                return $result;
            }
        }

        // check for attributes
        if( $node->hasAttributes() ) {
            $nodeData['attributes'] = array();
            foreach( $node->attributes as $attribute ) {
                $nodeData['attributes'][$attribute->name] = $attribute->value;
            }
        }

        // recurse into subnodes
        if( $node->hasChildNodes() ) {
            $children = array();
            foreach( $node->childNodes as $childNode ) {
                // check for weird errors with attribute declaration nodes
                // which have child nodes with a NULL value...
                if( !is_object( $childNode ) ) {
                    continue;
                }

                if( $childNode->nodeType == XML_TEXT_NODE ) {
                    $nodeData['text'] .= $childNode->textContent;
                    continue;
                }

                $child = $this->_create_tree( $childNode );
                if( $child ) {
                    $children[] = $child;
                }
            }

            if( !empty( $children ) ) {
                $nodeData['children'] = $children;
            }
        }

        return $nodeData;
    }

   /**
    * Special handler for comment nodes
    *
    * @access    private
    * @param    DOMNode
    * @param     array
    * @return    bool
    */
    function _handleNode_comment( $node, &$nodeData )
    {
        $nodeData['text'] = $node->textContent;

        $result = true;
        return $result;
    }

   /**
    * Special handler for cdata sections
    *
    * @access    private
    * @param    DOMNode
    * @param     array
    * @return    bool
    */
    function _handleNode_cdata( $node, &$nodeData )
    {
        $nodeData['text'] = $node->textContent;

        $result = true;
        return $result;
    }

   /**
    * Special handler for entity references (like &amp;)
    *
    * @access    private
    * @param    DOMNode
    * @param     array
    * @return    bool
    */
    function _handleNode_entityReference( $node, &$nodeData )
    {
        $nodeData['text'] = $node->textContent;

        $result = true;
        return $result;
    }

   /**
    * Translates DOM-specific node codes to the internal
    * node designations.
    *
    * @access    private
    * @param    int
    * @return    string|bool false
    */
    function _translate_node_type( $nodeType )
    {
        $nodeTypes = array(
            XML_COMMENT_NODE => 'comment',
            XML_ELEMENT_NODE => 'default',
            XML_CDATA_SECTION_NODE => 'cdata',
            XML_ENTITY_REF_NODE => 'entityReference',
            XML_ENTITY_DECL_NODE => 'entityDeclaration',
        );

        if( !isset( $nodeTypes[$nodeType] ) ) {
            patErrorManager::raiseNotice(
                PATXMLPRETTY_ENGINE_DOM_NOTICE_UNKNOWN_NODE_TYPE,
                $this->userMessages['warning'],
                'Unknown DOM node type ['.$nodeType.'], the patXMLPretty DOM engine does '.
                'not handle that node type yet, it will simply be ignored (including all '.
                'child nodes).'
            );

            $result = false;
            return $result;
        }

        return $nodeTypes[$nodeType];
    }
}

?>