Parser::noRecurseCall() - Code Metrics - Inspection of "Merge pull request #940 from geekwright/xmfv1-2-22" - geekwright/XoopsCore25 - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 91ef6c...9eba8c )

by Richard

created 2021-02-14 16:36 UTC

Parser::noRecurseCall() A

↳ Parent: Parser

Complexity

Conditions	6
Paths	6

Size

Total Lines	15
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	6
eloc	8
c	1
b	0
f	0
nc	6
nop	0
dl	0
loc	15
rs	9.2222

<?php

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2013 Jonathan Vollebregt ([email protected]), Rokas Šleinius ([email protected])
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

namespace Kint\Parser;

use DomainException;
use Exception;
use Kint\Object\BasicObject;
use Kint\Object\BlobObject;
use Kint\Object\InstanceObject;
use Kint\Object\Representation\Representation;
use Kint\Object\ResourceObject;
use ReflectionObject;
use stdClass;

class Parser
{
    /**
     * Plugin triggers.
     *
     * These are constants indicating trigger points for plugins
     *
     * BEGIN: Before normal parsing
     * SUCCESS: After successful parsing
     * RECURSION: After parsing cancelled by recursion
     * DEPTH_LIMIT: After parsing cancelled by depth limit
     * COMPLETE: SUCCESS | RECURSION | DEPTH_LIMIT
     *
     * While a plugin's getTriggers may return any of these
     */
    const TRIGGER_NONE = 0;
    const TRIGGER_BEGIN = 1;
    const TRIGGER_SUCCESS = 2;
    const TRIGGER_RECURSION = 4;
    const TRIGGER_DEPTH_LIMIT = 8;
    const TRIGGER_COMPLETE = 14;

    protected $caller_class;
    protected $depth_limit = false;
    protected $marker;
    protected $object_hashes = array();
    protected $parse_break = false;
    protected $plugins = array();

    /**
     * @param false|int   $depth_limit Maximum depth to parse data
     * @param null|string $caller      Caller class name
     */
    public function __construct($depth_limit = false, $caller = null)
    {
        $this->marker = \uniqid("kint\0", true);

        $this->caller_class = $caller;

        if ($depth_limit) {
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
            $this->depth_limit = $depth_limit;
        }
    }

    /**
     * Set the caller class.
     *
     * @param null|string $caller Caller class name
     */
    public function setCallerClass($caller = null)
    {
        $this->noRecurseCall();

        $this->caller_class = $caller;
    }

    public function getCallerClass()
    {
        return $this->caller_class;
    }

    /**
     * Set the depth limit.
     *
     * @param false|int $depth_limit Maximum depth to parse data
     */
    public function setDepthLimit($depth_limit = false)
    {
        $this->noRecurseCall();

        $this->depth_limit = $depth_limit;
    }

    public function getDepthLimit()
    {
        return $this->depth_limit;
    }

    /**
     * Disables the depth limit and parses a variable.
     *
     * This should not be used unless you know what you're doing!
     *
     * @param mixed       $var The input variable
     * @param BasicObject $o   The base object
     *
     * @return BasicObject
     */
    public function parseDeep(&$var, BasicObject $o)
    {
        $depth_limit = $this->depth_limit;
        $this->depth_limit = false;

        $out = $this->parse($var, $o);

        $this->depth_limit = $depth_limit;

        return $out;
    }

    /**
     * Parses a variable into a Kint object structure.
     *
     * @param mixed       $var The input variable
     * @param BasicObject $o   The base object
     *
     * @return BasicObject
     */
    public function parse(&$var, BasicObject $o)
    {
        $o->type = \strtolower(\gettype($var));

        if (!$this->applyPlugins($var, $o, self::TRIGGER_BEGIN)) {
            return $o;
        }

        switch ($o->type) {
            case 'array':
                return $this->parseArray($var, $o);
            case 'boolean':
            case 'double':
            case 'integer':
            case 'null':
                return $this->parseGeneric($var, $o);
            case 'object':
                return $this->parseObject($var, $o);
            case 'resource':
                return $this->parseResource($var, $o);
            case 'string':
                return $this->parseString($var, $o);
            default:
                return $this->parseUnknown($var, $o);
        }
    }

    public function addPlugin(Plugin $p)
    {
        if (!$types = $p->getTypes()) {
            return false;
        }

        if (!$triggers = $p->getTriggers()) {
            return false;
        }

        $p->setParser($this);

        foreach ($types as $type) {
            if (!isset($this->plugins[$type])) {
                $this->plugins[$type] = array(
                    self::TRIGGER_BEGIN => array(),
                    self::TRIGGER_SUCCESS => array(),
                    self::TRIGGER_RECURSION => array(),
                    self::TRIGGER_DEPTH_LIMIT => array(),
                );
            }

            foreach ($this->plugins[$type] as $trigger => &$pool) {
                if ($triggers & $trigger) {
                    $pool[] = $p;
                }
            }
        }

        return true;
    }

    public function clearPlugins()
    {
        $this->plugins = array();
    }

    public function haltParse()
    {
        $this->parse_break = true;
    }

    public function childHasPath(InstanceObject $parent, BasicObject $child)
    {
        if ('object' === $parent->type && (null !== $parent->access_path || $child->static || $child->const)) {
            if (BasicObject::ACCESS_PUBLIC === $child->access) {
                return true;
            }

            if (BasicObject::ACCESS_PRIVATE === $child->access && $this->caller_class) {
                if ($this->caller_class === $child->owner_class) {
                    return true;
                }
            } elseif (BasicObject::ACCESS_PROTECTED === $child->access && $this->caller_class) {
                if ($this->caller_class === $child->owner_class) {
                    return true;
                }

                if (\is_subclass_of($this->caller_class, $child->owner_class)) {
                    return true;
                }

                if (\is_subclass_of($child->owner_class, $this->caller_class)) {
                    return true;
                }
            }
        }

        return false;
    }

    /**
     * Returns an array without the recursion marker in it.
     *
     * DO NOT pass an array that has had it's marker removed back
     * into the parser, it will result in an extra recursion
     *
     * @param array $array Array potentially containing a recursion marker
     *
     * @return array Array with recursion marker removed
     */
    public function getCleanArray(array $array)
    {
        unset($array[$this->marker]);

        return $array;
    }

    protected function noRecurseCall()
    {
        $bt = \debug_backtrace(DEBUG_BACKTRACE_PROVIDE_OBJECT | DEBUG_BACKTRACE_IGNORE_ARGS);

        $caller_frame = array(
            'function' => __FUNCTION__,
        );

        while (isset($bt[0]['object']) && $bt[0]['object'] === $this) {
            $caller_frame = \array_shift($bt);
        }

        foreach ($bt as $frame) {
            if (isset($frame['object']) && $frame['object'] === $this) {
                throw new DomainException(__CLASS__.'::'.$caller_frame['function'].' cannot be called from inside a parse');
            }
        }
    }

    private function parseGeneric(&$var, BasicObject $o)
    {
        $rep = new Representation('Contents');
        $rep->contents = $var;
        $rep->implicit_label = true;
        $o->addRepresentation($rep);
        $o->value = $rep;

        $this->applyPlugins($var, $o, self::TRIGGER_SUCCESS);

        return $o;
    }

    /**
     * Parses a string into a Kint BlobObject structure.
     *
     * @param string      $var The input variable
     * @param BasicObject $o   The base object
     *
     * @return BasicObject
     */
    private function parseString(&$var, BasicObject $o)
    {
        $string = new BlobObject();
        $string->transplant($o);
        $string->encoding = BlobObject::detectEncoding($var);
        $string->size = BlobObject::strlen($var, $string->encoding);

        $rep = new Representation('Contents');
        $rep->contents = $var;
        $rep->implicit_label = true;

        $string->addRepresentation($rep);
        $string->value = $rep;

        $this->applyPlugins($var, $string, self::TRIGGER_SUCCESS);

        return $string;
    }

    /**
     * Parses an array into a Kint object structure.
     *
     * @param array       $var The input variable
     * @param BasicObject $o   The base object
     *
     * @return BasicObject
     */
    private function parseArray(array &$var, BasicObject $o)
    {
        $array = new BasicObject();
        $array->transplant($o);
        $array->size = \count($var);

        if (isset($var[$this->marker])) {
            --$array->size;
            $array->hints[] = 'recursion';

            $this->applyPlugins($var, $array, self::TRIGGER_RECURSION);

            return $array;
        }

        $rep = new Representation('Contents');
        $rep->implicit_label = true;
        $array->addRepresentation($rep);
        $array->value = $rep;

        if (!$array->size) {
            $this->applyPlugins($var, $array, self::TRIGGER_SUCCESS);

            return $array;
        }

        if ($this->depth_limit && $o->depth >= $this->depth_limit) {
            $array->hints[] = 'depth_limit';

            $this->applyPlugins($var, $array, self::TRIGGER_DEPTH_LIMIT);

            return $array;
        }

        $copy = \array_values($var);

        // It's really really hard to access numeric string keys in arrays,
        // and it's really really hard to access integer properties in
        // objects, so we just use array_values and index by counter to get
        // at it reliably for reference testing. This also affects access
        // paths since it's pretty much impossible to access these things
        // without complicated stuff you should never need to do.
        $i = 0;

        // Set the marker for recursion
        $var[$this->marker] = $array->depth;

        $refmarker = new stdClass();

        foreach ($var as $key => &$val) {
            if ($key === $this->marker) {
                continue;
            }

            $child = new BasicObject();
            $child->name = $key;
            $child->depth = $array->depth + 1;
            $child->access = BasicObject::ACCESS_NONE;
            $child->operator = BasicObject::OPERATOR_ARRAY;

            if (null !== $array->access_path) {
                if (\is_string($key) && (string) (int) $key === $key) {
                    $child->access_path = 'array_values('.$array->access_path.')['.$i.']'; // @codeCoverageIgnore
                } else {
                    $child->access_path = $array->access_path.'['.\var_export($key, true).']';
                }
            }

            $stash = $val;
            $copy[$i] = $refmarker;
            if ($val === $refmarker) {
                $child->reference = true;
                $val = $stash;
            }

            $rep->contents[] = $this->parse($val, $child);
            ++$i;
        }

        $this->applyPlugins($var, $array, self::TRIGGER_SUCCESS);
        unset($var[$this->marker]);

        return $array;
    }

    /**
     * Parses an object into a Kint InstanceObject structure.
     *
     * @param object      $var The input variable
     * @param BasicObject $o   The base object
     *
     * @return BasicObject
     */
    private function parseObject(&$var, BasicObject $o)
    {
        $hash = \spl_object_hash($var);
        $values = (array) $var;

        $object = new InstanceObject();
        $object->transplant($o);
        $object->classname = \get_class($var);
        $object->hash = $hash;
        $object->size = \count($values);

        if (isset($this->object_hashes[$hash])) {
            $object->hints[] = 'recursion';

            $this->applyPlugins($var, $object, self::TRIGGER_RECURSION);

            return $object;
        }

        $this->object_hashes[$hash] = $object;

        if ($this->depth_limit && $o->depth >= $this->depth_limit) {
            $object->hints[] = 'depth_limit';

            $this->applyPlugins($var, $object, self::TRIGGER_DEPTH_LIMIT);
            unset($this->object_hashes[$hash]);

            return $object;
        }

        $reflector = new ReflectionObject($var);

        if ($reflector->isUserDefined()) {
            $object->filename = $reflector->getFileName();
            $object->startline = $reflector->getStartLine();
        }

        $rep = new Representation('Properties');

        $copy = \array_values($values);
        $refmarker = new stdClass();
        $i = 0;

        // Reflection will not show parent classes private properties, and if a
        // property was unset it will happly trigger a notice looking for it.
        foreach ($values as $key => &$val) {
            // Casting object to array:
            // private properties show in the form "\0$owner_class_name\0$property_name";
            // protected properties show in the form "\0*\0$property_name";
            // public properties show in the form "$property_name";
            // http://www.php.net/manual/en/language.types.array.php#language.types.array.casting

            $child = new BasicObject();
            $child->depth = $object->depth + 1;
            $child->owner_class = $object->classname;
            $child->operator = BasicObject::OPERATOR_OBJECT;
            $child->access = BasicObject::ACCESS_PUBLIC;

            $split_key = \explode("\0", $key, 3);

            if (3 === \count($split_key) && '' === $split_key[0]) {
                $child->name = $split_key[2];
                if ('*' === $split_key[1]) {
                    $child->access = BasicObject::ACCESS_PROTECTED;
                } else {
                    $child->access = BasicObject::ACCESS_PRIVATE;
                    $child->owner_class = $split_key[1];
                }
            } elseif (KINT_PHP72) {
                $child->name = (string) $key;
            } else {
                $child->name = $key; // @codeCoverageIgnore
            }

            if ($this->childHasPath($object, $child)) {
                $child->access_path = $object->access_path;

                if (!KINT_PHP72 && \is_int($child->name)) {
                    $child->access_path = 'array_values((array) '.$child->access_path.')['.$i.']'; // @codeCoverageIgnore
                } elseif (\preg_match('/^[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*$/', $child->name)) {
                    $child->access_path .= '->'.$child->name;
                } else {
                    $child->access_path .= '->{'.\var_export((string) $child->name, true).'}';
                }
            }

            $stash = $val;
            $copy[$i] = $refmarker;
            if ($val === $refmarker) {
                $child->reference = true;
                $val = $stash;
            }

            $rep->contents[] = $this->parse($val, $child);
            ++$i;
        }

        $object->addRepresentation($rep);
        $object->value = $rep;
        $this->applyPlugins($var, $object, self::TRIGGER_SUCCESS);
        unset($this->object_hashes[$hash]);

        return $object;
    }

    /**
     * Parses a resource into a Kint ResourceObject structure.
     *
     * @param resource    $var The input variable
     * @param BasicObject $o   The base object
     *
     * @return BasicObject
     */
    private function parseResource(&$var, BasicObject $o)
    {
        $resource = new ResourceObject();
        $resource->transplant($o);
        $resource->resource_type = \get_resource_type($var);

        $this->applyPlugins($var, $resource, self::TRIGGER_SUCCESS);

        return $resource;
    }

    /**
     * Parses an unknown into a Kint object structure.
     *
     * @param mixed       $var The input variable
     * @param BasicObject $o   The base object
     *
     * @return BasicObject
     */
    private function parseUnknown(&$var, BasicObject $o)
    {
        $o->type = 'unknown';
        $this->applyPlugins($var, $o, self::TRIGGER_SUCCESS);

        return $o;
    }

    /**
     * Applies plugins for an object type.
     *
     * @param mixed       $var     variable
     * @param BasicObject $o       Kint object parsed so far
     * @param int         $trigger The trigger to check for the plugins
     *
     * @return bool Continue parsing
     */
    private function applyPlugins(&$var, BasicObject &$o, $trigger)
    {
        $break_stash = $this->parse_break;

        /** @var bool Psalm bug workaround */
        $this->parse_break = false;

        $plugins = array();

        if (isset($this->plugins[$o->type][$trigger])) {
            $plugins = $this->plugins[$o->type][$trigger];
        }

        foreach ($plugins as $plugin) {
            try {
                $plugin->parse($var, $o, $trigger);
            } catch (Exception $e) {
                \trigger_error(
                    'An exception ('.\get_class($e).') was thrown in '.$e->getFile().' on line '.$e->getLine().' while executing Kint Parser Plugin "'.\get_class($plugin).'". Error message: '.$e->getMessage(),
                    E_USER_WARNING
                );
            }

            if ($this->parse_break) {
                $this->parse_break = $break_stash;

                return false;
            }
        }

        $this->parse_break = $break_stash;

        return true;
    }
}


1			<?php
2
3			/*
4			* The MIT License (MIT)
5			*
6			* Copyright (c) 2013 Jonathan Vollebregt ([email protected]), Rokas Šleinius ([email protected])
7			*
8			* Permission is hereby granted, free of charge, to any person obtaining a copy of
9			* this software and associated documentation files (the "Software"), to deal in
10			* the Software without restriction, including without limitation the rights to
11			* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
12			* the Software, and to permit persons to whom the Software is furnished to do so,
13			* subject to the following conditions:
14			*
15			* The above copyright notice and this permission notice shall be included in all
16			* copies or substantial portions of the Software.
17			*
18			* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19			* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
20			* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
21			* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
22			* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23			* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24			*/
25
26			namespace Kint\Parser;
27
28			use DomainException;
29			use Exception;
30			use Kint\Object\BasicObject;
31			use Kint\Object\BlobObject;
32			use Kint\Object\InstanceObject;
33			use Kint\Object\Representation\Representation;
34			use Kint\Object\ResourceObject;
35			use ReflectionObject;
36			use stdClass;
37
38			class Parser
39			{
40			/**
41			* Plugin triggers.
42			*
43			* These are constants indicating trigger points for plugins
44			*
45			* BEGIN: Before normal parsing
46			* SUCCESS: After successful parsing
47			* RECURSION: After parsing cancelled by recursion
48			* DEPTH_LIMIT: After parsing cancelled by depth limit
49			* COMPLETE: SUCCESS \| RECURSION \| DEPTH_LIMIT
50			*
51			* While a plugin's getTriggers may return any of these
52			*/
53			const TRIGGER_NONE = 0;
54			const TRIGGER_BEGIN = 1;
55			const TRIGGER_SUCCESS = 2;
56			const TRIGGER_RECURSION = 4;
57			const TRIGGER_DEPTH_LIMIT = 8;
58			const TRIGGER_COMPLETE = 14;
59
60			protected $caller_class;
61			protected $depth_limit = false;
62			protected $marker;
63			protected $object_hashes = array();
64			protected $parse_break = false;
65			protected $plugins = array();
66
67			/**
68			* @param false\|int $depth_limit Maximum depth to parse data
69			* @param null\|string $caller Caller class name
70			*/
71			public function __construct($depth_limit = false, $caller = null)
72			{
73			$this->marker = \uniqid("kint\0", true);
74
75			$this->caller_class = $caller;
76
77			if ($depth_limit) {
			0 ignored issues – show Bug Best Practice introduced 2021-02-14 16:41 UTC by Report Bug Copy Issue Report The expression `$depth_limit` of type `false\|integer` is loosely compared to `true`; this is ambiguous if the integer can be 0. You might want to explicitly use `!== false` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `integer` values, zero is a special case, in particular the following results might be unexpected: 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 Loading history...
78			$this->depth_limit = $depth_limit;
79			}
80			}
81
82			/**
83			* Set the caller class.
84			*
85			* @param null\|string $caller Caller class name
86			*/
87			public function setCallerClass($caller = null)
88			{
89			$this->noRecurseCall();
90
91			$this->caller_class = $caller;
92			}
93
94			public function getCallerClass()
95			{
96			return $this->caller_class;
97			}
98
99			/**
100			* Set the depth limit.
101			*
102			* @param false\|int $depth_limit Maximum depth to parse data
103			*/
104			public function setDepthLimit($depth_limit = false)
105			{
106			$this->noRecurseCall();
107
108			$this->depth_limit = $depth_limit;
109			}
110
111			public function getDepthLimit()
112			{
113			return $this->depth_limit;
114			}
115
116			/**
117			* Disables the depth limit and parses a variable.
118			*
119			* This should not be used unless you know what you're doing!
120			*
121			* @param mixed $var The input variable
122			* @param BasicObject $o The base object
123			*
124			* @return BasicObject
125			*/
126			public function parseDeep(&$var, BasicObject $o)
127			{
128			$depth_limit = $this->depth_limit;
129			$this->depth_limit = false;
130
131			$out = $this->parse($var, $o);
132
133			$this->depth_limit = $depth_limit;
134
135			return $out;
136			}
137
138			/**
139			* Parses a variable into a Kint object structure.
140			*
141			* @param mixed $var The input variable
142			* @param BasicObject $o The base object
143			*
144			* @return BasicObject
145			*/
146			public function parse(&$var, BasicObject $o)
147			{
148			$o->type = \strtolower(\gettype($var));
149
150			if (!$this->applyPlugins($var, $o, self::TRIGGER_BEGIN)) {
151			return $o;
152			}
153
154			switch ($o->type) {
155			case 'array':
156			return $this->parseArray($var, $o);
157			case 'boolean':
158			case 'double':
159			case 'integer':
160			case 'null':
161			return $this->parseGeneric($var, $o);
162			case 'object':
163			return $this->parseObject($var, $o);
164			case 'resource':
165			return $this->parseResource($var, $o);
166			case 'string':
167			return $this->parseString($var, $o);
168			default:
169			return $this->parseUnknown($var, $o);
170			}
171			}
172
173			public function addPlugin(Plugin $p)
174			{
175			if (!$types = $p->getTypes()) {
176			return false;
177			}
178
179			if (!$triggers = $p->getTriggers()) {
180			return false;
181			}
182
183			$p->setParser($this);
184
185			foreach ($types as $type) {
186			if (!isset($this->plugins[$type])) {
187			$this->plugins[$type] = array(
188			self::TRIGGER_BEGIN => array(),
189			self::TRIGGER_SUCCESS => array(),
190			self::TRIGGER_RECURSION => array(),
191			self::TRIGGER_DEPTH_LIMIT => array(),
192			);
193			}
194
195			foreach ($this->plugins[$type] as $trigger => &$pool) {
196			if ($triggers & $trigger) {
197			$pool[] = $p;
198			}
199			}
200			}
201
202			return true;
203			}
204
205			public function clearPlugins()
206			{
207			$this->plugins = array();
208			}
209
210			public function haltParse()
211			{
212			$this->parse_break = true;
213			}
214
215			public function childHasPath(InstanceObject $parent, BasicObject $child)
216			{
217			if ('object' === $parent->type && (null !== $parent->access_path \|\| $child->static \|\| $child->const)) {
218			if (BasicObject::ACCESS_PUBLIC === $child->access) {
219			return true;
220			}
221
222			if (BasicObject::ACCESS_PRIVATE === $child->access && $this->caller_class) {
223			if ($this->caller_class === $child->owner_class) {
224			return true;
225			}
226			} elseif (BasicObject::ACCESS_PROTECTED === $child->access && $this->caller_class) {
227			if ($this->caller_class === $child->owner_class) {
228			return true;
229			}
230
231			if (\is_subclass_of($this->caller_class, $child->owner_class)) {
232			return true;
233			}
234
235			if (\is_subclass_of($child->owner_class, $this->caller_class)) {
236			return true;
237			}
238			}
239			}
240
241			return false;
242			}
243
244			/**
245			* Returns an array without the recursion marker in it.
246			*
247			* DO NOT pass an array that has had it's marker removed back
248			* into the parser, it will result in an extra recursion
249			*
250			* @param array $array Array potentially containing a recursion marker
251			*
252			* @return array Array with recursion marker removed
253			*/
254			public function getCleanArray(array $array)
255			{
256			unset($array[$this->marker]);
257
258			return $array;
259			}
260
261			protected function noRecurseCall()
262			{
263			$bt = \debug_backtrace(DEBUG_BACKTRACE_PROVIDE_OBJECT \| DEBUG_BACKTRACE_IGNORE_ARGS);
264
265			$caller_frame = array(
266			'function' => __FUNCTION__,
267			);
268
269			while (isset($bt[0]['object']) && $bt[0]['object'] === $this) {
270			$caller_frame = \array_shift($bt);
271			}
272
273			foreach ($bt as $frame) {
274			if (isset($frame['object']) && $frame['object'] === $this) {
275			throw new DomainException(__CLASS__.'::'.$caller_frame['function'].' cannot be called from inside a parse');
276			}
277			}
278			}
279
280			private function parseGeneric(&$var, BasicObject $o)
281			{
282			$rep = new Representation('Contents');
283			$rep->contents = $var;
284			$rep->implicit_label = true;
285			$o->addRepresentation($rep);
286			$o->value = $rep;
287
288			$this->applyPlugins($var, $o, self::TRIGGER_SUCCESS);
289
290			return $o;
291			}
292
293			/**
294			* Parses a string into a Kint BlobObject structure.
295			*
296			* @param string $var The input variable
297			* @param BasicObject $o The base object
298			*
299			* @return BasicObject
300			*/
301			private function parseString(&$var, BasicObject $o)
302			{
303			$string = new BlobObject();
304			$string->transplant($o);
305			$string->encoding = BlobObject::detectEncoding($var);
306			$string->size = BlobObject::strlen($var, $string->encoding);
307
308			$rep = new Representation('Contents');
309			$rep->contents = $var;
310			$rep->implicit_label = true;
311
312			$string->addRepresentation($rep);
313			$string->value = $rep;
314
315			$this->applyPlugins($var, $string, self::TRIGGER_SUCCESS);
316
317			return $string;
318			}
319
320			/**
321			* Parses an array into a Kint object structure.
322			*
323			* @param array $var The input variable
324			* @param BasicObject $o The base object
325			*
326			* @return BasicObject
327			*/
328			private function parseArray(array &$var, BasicObject $o)
329			{
330			$array = new BasicObject();
331			$array->transplant($o);
332			$array->size = \count($var);
333
334			if (isset($var[$this->marker])) {
335			--$array->size;
336			$array->hints[] = 'recursion';
337
338			$this->applyPlugins($var, $array, self::TRIGGER_RECURSION);
339
340			return $array;
341			}
342
343			$rep = new Representation('Contents');
344			$rep->implicit_label = true;
345			$array->addRepresentation($rep);
346			$array->value = $rep;
347
348			if (!$array->size) {
349			$this->applyPlugins($var, $array, self::TRIGGER_SUCCESS);
350
351			return $array;
352			}
353
354			if ($this->depth_limit && $o->depth >= $this->depth_limit) {
355			$array->hints[] = 'depth_limit';
356
357			$this->applyPlugins($var, $array, self::TRIGGER_DEPTH_LIMIT);
358
359			return $array;
360			}
361
362			$copy = \array_values($var);
363
364			// It's really really hard to access numeric string keys in arrays,
365			// and it's really really hard to access integer properties in
366			// objects, so we just use array_values and index by counter to get
367			// at it reliably for reference testing. This also affects access
368			// paths since it's pretty much impossible to access these things
369			// without complicated stuff you should never need to do.
370			$i = 0;
371
372			// Set the marker for recursion
373			$var[$this->marker] = $array->depth;
374
375			$refmarker = new stdClass();
376
377			foreach ($var as $key => &$val) {
378			if ($key === $this->marker) {
379			continue;
380			}
381
382			$child = new BasicObject();
383			$child->name = $key;
384			$child->depth = $array->depth + 1;
385			$child->access = BasicObject::ACCESS_NONE;
386			$child->operator = BasicObject::OPERATOR_ARRAY;
387
388			if (null !== $array->access_path) {
389			if (\is_string($key) && (string) (int) $key === $key) {
390			$child->access_path = 'array_values('.$array->access_path.')['.$i.']'; // @codeCoverageIgnore
391			} else {
392			$child->access_path = $array->access_path.'['.\var_export($key, true).']';
393			}
394			}
395
396			$stash = $val;
397			$copy[$i] = $refmarker;
398			if ($val === $refmarker) {
399			$child->reference = true;
400			$val = $stash;
401			}
402
403			$rep->contents[] = $this->parse($val, $child);
404			++$i;
405			}
406
407			$this->applyPlugins($var, $array, self::TRIGGER_SUCCESS);
408			unset($var[$this->marker]);
409
410			return $array;
411			}
412
413			/**
414			* Parses an object into a Kint InstanceObject structure.
415			*
416			* @param object $var The input variable
417			* @param BasicObject $o The base object
418			*
419			* @return BasicObject
420			*/
421			private function parseObject(&$var, BasicObject $o)
422			{
423			$hash = \spl_object_hash($var);
424			$values = (array) $var;
425
426			$object = new InstanceObject();
427			$object->transplant($o);
428			$object->classname = \get_class($var);
429			$object->hash = $hash;
430			$object->size = \count($values);
431
432			if (isset($this->object_hashes[$hash])) {
433			$object->hints[] = 'recursion';
434
435			$this->applyPlugins($var, $object, self::TRIGGER_RECURSION);
436
437			return $object;
438			}
439
440			$this->object_hashes[$hash] = $object;
441
442			if ($this->depth_limit && $o->depth >= $this->depth_limit) {
443			$object->hints[] = 'depth_limit';
444
445			$this->applyPlugins($var, $object, self::TRIGGER_DEPTH_LIMIT);
446			unset($this->object_hashes[$hash]);
447
448			return $object;
449			}
450
451			$reflector = new ReflectionObject($var);
452
453			if ($reflector->isUserDefined()) {
454			$object->filename = $reflector->getFileName();
455			$object->startline = $reflector->getStartLine();
456			}
457
458			$rep = new Representation('Properties');
459
460			$copy = \array_values($values);
461			$refmarker = new stdClass();
462			$i = 0;
463
464			// Reflection will not show parent classes private properties, and if a
465			// property was unset it will happly trigger a notice looking for it.
466			foreach ($values as $key => &$val) {
467			// Casting object to array:
468			// private properties show in the form "\0$owner_class_name\0$property_name";
469			// protected properties show in the form "\0*\0$property_name";
470			// public properties show in the form "$property_name";
471			// http://www.php.net/manual/en/language.types.array.php#language.types.array.casting
472
473			$child = new BasicObject();
474			$child->depth = $object->depth + 1;
475			$child->owner_class = $object->classname;
476			$child->operator = BasicObject::OPERATOR_OBJECT;
477			$child->access = BasicObject::ACCESS_PUBLIC;
478
479			$split_key = \explode("\0", $key, 3);
480
481			if (3 === \count($split_key) && '' === $split_key[0]) {
482			$child->name = $split_key[2];
483			if ('*' === $split_key[1]) {
484			$child->access = BasicObject::ACCESS_PROTECTED;
485			} else {
486			$child->access = BasicObject::ACCESS_PRIVATE;
487			$child->owner_class = $split_key[1];
488			}
489			} elseif (KINT_PHP72) {
490			$child->name = (string) $key;
491			} else {
492			$child->name = $key; // @codeCoverageIgnore
493			}
494
495			if ($this->childHasPath($object, $child)) {
496			$child->access_path = $object->access_path;
497
498			if (!KINT_PHP72 && \is_int($child->name)) {
499			$child->access_path = 'array_values((array) '.$child->access_path.')['.$i.']'; // @codeCoverageIgnore
500			} elseif (\preg_match('/^[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*$/', $child->name)) {
501			$child->access_path .= '->'.$child->name;
502			} else {
503			$child->access_path .= '->{'.\var_export((string) $child->name, true).'}';
504			}
505			}
506
507			$stash = $val;
508			$copy[$i] = $refmarker;
509			if ($val === $refmarker) {
510			$child->reference = true;
511			$val = $stash;
512			}
513
514			$rep->contents[] = $this->parse($val, $child);
515			++$i;
516			}
517
518			$object->addRepresentation($rep);
519			$object->value = $rep;
520			$this->applyPlugins($var, $object, self::TRIGGER_SUCCESS);
521			unset($this->object_hashes[$hash]);
522
523			return $object;
524			}
525
526			/**
527			* Parses a resource into a Kint ResourceObject structure.
528			*
529			* @param resource $var The input variable
530			* @param BasicObject $o The base object
531			*
532			* @return BasicObject
533			*/
534			private function parseResource(&$var, BasicObject $o)
535			{
536			$resource = new ResourceObject();
537			$resource->transplant($o);
538			$resource->resource_type = \get_resource_type($var);
539
540			$this->applyPlugins($var, $resource, self::TRIGGER_SUCCESS);
541
542			return $resource;
543			}
544
545			/**
546			* Parses an unknown into a Kint object structure.
547			*
548			* @param mixed $var The input variable
549			* @param BasicObject $o The base object
550			*
551			* @return BasicObject
552			*/
553			private function parseUnknown(&$var, BasicObject $o)
554			{
555			$o->type = 'unknown';
556			$this->applyPlugins($var, $o, self::TRIGGER_SUCCESS);
557
558			return $o;
559			}
560
561			/**
562			* Applies plugins for an object type.
563			*
564			* @param mixed $var variable
565			* @param BasicObject $o Kint object parsed so far
566			* @param int $trigger The trigger to check for the plugins
567			*
568			* @return bool Continue parsing
569			*/
570			private function applyPlugins(&$var, BasicObject &$o, $trigger)
571			{
572			$break_stash = $this->parse_break;
573
574			/** @var bool Psalm bug workaround */
575			$this->parse_break = false;
576
577			$plugins = array();
578
579			if (isset($this->plugins[$o->type][$trigger])) {
580			$plugins = $this->plugins[$o->type][$trigger];
581			}
582
583			foreach ($plugins as $plugin) {
584			try {
585			$plugin->parse($var, $o, $trigger);
586			} catch (Exception $e) {
587			\trigger_error(
588			'An exception ('.\get_class($e).') was thrown in '.$e->getFile().' on line '.$e->getLine().' while executing Kint Parser Plugin "'.\get_class($plugin).'". Error message: '.$e->getMessage(),
589			E_USER_WARNING
590			);
591			}
592
593			if ($this->parse_break) {
594			$this->parse_break = $break_stash;
595
596			return false;
597			}
598			}
599
600			$this->parse_break = $break_stash;
601
602			return true;
603			}
604			}
605

geekwright / XoopsCore25

Push — master ( 91ef6c...9eba8c )

Parser::noRecurseCall() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like