DOMDocumentPlugin::parse() - Code Metrics - Inspection of "MethodObject: Don't make docstring representations..." - jnvsor/kint - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Push — test ( 528f91...abcbcc )

by Jonathan

created 2018-01-09 19:00 UTC

DOMDocumentPlugin::parse() B

↳ Parent: DOMDocumentPlugin

Complexity

Conditions	5
Paths	4

Size

Total Lines	10
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	5
eloc	7
nc	4
nop	3
dl	0
loc	10
rs	8.8571
c	0
b	0
f	0

<?php

namespace Kint\Parser;

use DOMNamedNodeMap;
use DOMNode;
use DOMNodeList;
use Kint\Object\BasicObject;
use Kint\Object\InstanceObject;
use Kint\Object\Representation\Representation;

/**
 * The DOMDocument parser plugin is particularly useful as it is both the only
 * way to see inside the DOMNode without print_r, and the only way to see mixed
 * text and node inside XML (SimpleXMLElement will strip out the text).
 */
class DOMDocumentPlugin extends Plugin
{
    /**
     * List of properties to skip parsing.
     *
     * The properties of a DOMNode can do a *lot* of damage to debuggers. The
     * DOMNode contains not one, not two, not three, not four, not 5, not 6,
     * not 7 but 8 different ways to recurse into itself:
     * * firstChild
     * * lastChild
     * * previousSibling
     * * nextSibling
     * * ownerDocument
     * * parentNode
     * * childNodes
     * * attributes
     *
     * All of this combined: the tiny SVGs used as the caret in Kint are already
     * enough to make parsing and rendering take over a second, and send memory
     * usage over 128 megs. So we blacklist every field we don't strictly need
     * and hope that that's good enough.
     *
     * In retrospect - this is probably why print_r does the same
     *
     * @var array
     */
    public static $blacklist = array(
        'parentNode' => 'DOMNode',
        'firstChild' => 'DOMNode',
        'lastChild' => 'DOMNode',
        'previousSibling' => 'DOMNode',
        'nextSibling' => 'DOMNode',
        'ownerDocument' => 'DOMDocument',
    );

    /**
     * Show all properties and methods.
     *
     * @var bool
     */
    public static $verbose = false;

    public function getTypes()
    {
        return array('object');
    }

    public function getTriggers()

    {
        return Parser::TRIGGER_SUCCESS;
    }

    public function parse(&$var, BasicObject &$o, $trigger)

    {
        if (!$o instanceof InstanceObject) {
            return;
        } elseif ($var instanceof DOMNamedNodeMap || $var instanceof DOMNodeList) {
            return $this->parseList($var, $o, $trigger);
        } elseif ($var instanceof DOMNode) {
            return $this->parseNode($var, $o, $trigger);
        }
    }

    protected function parseList(&$var, InstanceObject &$o, $trigger)

    {
        // Recursion should never happen, should always be stopped at the parent
        // DOMNode.  Depth limit on the other hand we're going to skip since
        // that would show an empty iterator and rather useless. Let the depth
        // limit hit the children (DOMNodeList only has DOMNode as children)
        if ($trigger & Parser::TRIGGER_RECURSION) {
            return;
        }

        $o->size = $var->length;
        if ($o->size === 0) {
            $o->replaceRepresentation(new Representation('Iterator'));
            $o->size = null;

            return;
        }

        // Depth limit
        // Make empty iterator representation since we need it in DOMNode to point out depth limits
        if ($this->parser->getDepthLimit() && $o->depth + 1 >= $this->parser->getDepthLimit()) {
            $b = new BasicObject();

            $b->name = $o->classname.' Iterator Contents';
            $b->access_path = 'iterator_to_array('.$o->access_path.')';
            $b->depth = $o->depth + 1;
            $b->hints[] = 'depth_limit';

            $r = new Representation('Iterator');

            $r->contents = array($b);
            $o->replaceRepresentation($r, 0);

            return;
        }

        $data = iterator_to_array($var);

        $r = new Representation('Iterator');
        $o->replaceRepresentation($r, 0);

        foreach ($data as $key => $item) {
            $base_obj = new BasicObject();

            $base_obj->depth = $o->depth + 1;

            $base_obj->name = $item->nodeName;


            if ($o->access_path) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                if ($var instanceof DOMNamedNodeMap) {
                    $base_obj->access_path = $o->access_path.'->getNamedItem('.var_export($key, true).')';

                } elseif ($var instanceof DOMNodeList) {
                    $base_obj->access_path = $o->access_path.'->item('.var_export($key, true).')';

                } else {
                    $base_obj->access_path = 'iterator_to_array('.$o->access_path.')';

                }
            }

            $r->contents[] = $this->parser->parse($item, $base_obj);

        }
    }

    protected function parseNode(&$var, InstanceObject &$o, $trigger)

    {
        // Fill the properties
        // They can't be enumerated through reflection or casting,
        // so we have to trust the docs and try them one at a time
        $known_properties = array(

            'nodeValue',
            'childNodes',
            'attributes',
        );

        if (self::$verbose) {
            $known_properties = array(

                'nodeName',
                'nodeValue',
                'nodeType',
                'parentNode',
                'childNodes',
                'firstChild',
                'lastChild',
                'previousSibling',
                'nextSibling',
                'attributes',
                'ownerDocument',
                'namespaceURI',
                'prefix',
                'localName',
                'baseURI',
                'textContent',
            );
        }

        $childNodes = array();
        $attributes = array();

        $rep = $o->value;

        foreach ($known_properties as $prop) {

            $prop_obj = $this->parseProperty($o, $prop, $var);

            $rep->contents[] = $prop_obj;


            if ($prop === 'childNodes') {
                $childNodes = $prop_obj->getRepresentation('iterator');

            } elseif ($prop === 'attributes') {
                $attributes = $prop_obj->getRepresentation('iterator');

            }
        }

        if (!self::$verbose) {
            $o->removeRepresentation('methods');
            $o->removeRepresentation('properties');
        }

        // Attributes and comments and text nodes don't
        // need children or attributes of their own
        if (in_array($o->classname, array('DOMAttr', 'DOMText', 'DOMComment'))) {
            return;
        }

        // Set the attributes
        if ($attributes) {
            $a = new Representation('Attributes');

            foreach ($attributes->contents as $attribute) {
                $a->contents[] = self::textualNodeToString($attribute);
            }
            $o->addRepresentation($a, 0);
        }

        // Set the children
        if ($childNodes) {
            $c = new Representation('Children');


            if (count($childNodes->contents) === 1 && ($node = reset($childNodes->contents)) && in_array('depth_limit', $node->hints)) {
                $node = $node->transplant(new InstanceObject());
                $node->name = 'childNodes';
                $node->classname = 'DOMNodeList';
                $c->contents = array($node);
            } else {
                foreach ($childNodes->contents as $index => $node) {
                    // Shortcircuit text nodes to plain strings
                    if ($node->classname === 'DOMText' || $node->classname === 'DOMComment') {
                        $node = self::textualNodeToString($node);

                        // And remove them if they're empty
                        if (ctype_space($node->value->contents) || $node->value->contents === '') {
                            continue;
                        }
                    }

                    $c->contents[] = $node;
                }
            }

            $o->addRepresentation($c, 0);
        }

        if (isset($c) && count($c->contents)) {
            $o->size = count($c->contents);
        }

        if (!$o->size) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            $o->size = null;
        }
    }

    protected function parseProperty(InstanceObject $o, $prop, &$var)

    {
        // Duplicating (And slightly optimizing) the Parser::parseObject() code here
        $base_obj = new BasicObject();

        $base_obj->depth = $o->depth + 1;

        $base_obj->owner_class = $o->classname;

        $base_obj->name = $prop;

        $base_obj->operator = BasicObject::OPERATOR_OBJECT;

        $base_obj->access = BasicObject::ACCESS_PUBLIC;


        if ($o->access_path !== null) {
            $base_obj->access_path = $o->access_path;


            if (preg_match('/^[A-Za-z0-9_]+$/', $base_obj->name)) {

                $base_obj->access_path .= '->'.$base_obj->name;

            } else {
                $base_obj->access_path .= '->{'.var_export($base_obj->name, true).'}';

            }
        }

        if (!isset($var->$prop)) {
            $base_obj->type = 'null';

        } elseif (isset(self::$blacklist[$prop])) {
            $base_obj = $base_obj->transplant(new InstanceObject());

            $base_obj->hints[] = 'blacklist';

            $base_obj->classname = self::$blacklist[$prop];

        } elseif ($prop === 'attributes') {
            $base_obj = $this->parser->parseDeep($var->$prop, $base_obj);

        } else {
            $base_obj = $this->parser->parse($var->$prop, $base_obj);

        }

        return $base_obj;

    }

    protected static function textualNodeToString(InstanceObject $o)

    {
        if (empty($o->value) || empty($o->value->contents) || empty($o->classname)) {
            return;
        }

        if (!in_array($o->classname, array('DOMText', 'DOMAttr', 'DOMComment'))) {
            return;
        }

        foreach ($o->value->contents as $property) {
            if ($property->name === 'nodeValue') {
                $ret = clone $property;
                $ret->name = $o->name;

                return $ret;
            }
        }
    }
}


1			<?php
2
3			namespace Kint\Parser;
4
5			use DOMNamedNodeMap;
6			use DOMNode;
7			use DOMNodeList;
8			use Kint\Object\BasicObject;
9			use Kint\Object\InstanceObject;
10			use Kint\Object\Representation\Representation;
11
12			/**
13			* The DOMDocument parser plugin is particularly useful as it is both the only
14			* way to see inside the DOMNode without print_r, and the only way to see mixed
15			* text and node inside XML (SimpleXMLElement will strip out the text).
16			*/
17			class DOMDocumentPlugin extends Plugin
18			{
19			/**
20			* List of properties to skip parsing.
21			*
22			* The properties of a DOMNode can do a lot of damage to debuggers. The
23			* DOMNode contains not one, not two, not three, not four, not 5, not 6,
24			* not 7 but 8 different ways to recurse into itself:
25			* * firstChild
26			* * lastChild
27			* * previousSibling
28			* * nextSibling
29			* * ownerDocument
30			* * parentNode
31			* * childNodes
32			* * attributes
33			*
34			* All of this combined: the tiny SVGs used as the caret in Kint are already
35			* enough to make parsing and rendering take over a second, and send memory
36			* usage over 128 megs. So we blacklist every field we don't strictly need
37			* and hope that that's good enough.
38			*
39			* In retrospect - this is probably why print_r does the same
40			*

jnvsor / kint

Push — test ( 528f91...abcbcc )

DOMDocumentPlugin::parse() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like