Kint\Parser\Parser::parseObject()

Complexity

Conditions	30
Paths	> 20000

Size

Total Lines	135
Code Lines	82

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    private function parseObject(object &$var, ContextInterface $c): AbstractValue
    {
        $hash = \spl_object_hash($var);
        $classname = \get_class($var);

        if (isset($this->object_hashes[$hash])) {
            $object = new InstanceValue($c, $classname, $hash, \spl_object_id($var));
            $object->flags |= AbstractValue::FLAG_RECURSION;

            return $this->applyPluginsComplete($var, $object, self::TRIGGER_RECURSION);
        }

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

        $cdepth = $c->getDepth();
        $ap = $c->getAccessPath();

        if ($this->depth_limit && $cdepth >= $this->depth_limit) {
            $object = new InstanceValue($c, $classname, $hash, \spl_object_id($var));
            $object->flags |= AbstractValue::FLAG_DEPTH_LIMIT;

            $object = $this->applyPluginsComplete($var, $object, self::TRIGGER_DEPTH_LIMIT);

            unset($this->object_hashes[$hash]);

            return $object;
        }

        if (KINT_PHP81) {
            $props = $this->getPropsOrdered(new ReflectionObject($var));
        } else {
            $props = $this->getPropsOrderedOld(new ReflectionObject($var)); // @codeCoverageIgnore
        }

        $values = (array) $var;
        $properties = [];

        foreach ($props as $rprop) {
            $rprop->setAccessible(true);
            $name = $rprop->getName();

            // 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
            $key = $name;
            if ($rprop->isProtected()) {
                $key = "\0*\0".$name;
            } elseif ($rprop->isPrivate()) {
                $key = "\0".$rprop->getDeclaringClass()->getName()."\0".$name;
            }
            $initialized = \array_key_exists($key, $values);
            if ($key === (string) (int) $key) {
                $key = (int) $key;
            }

            if ($rprop->isDefault()) {
                $child = new PropertyContext(
                    $name,
                    $rprop->getDeclaringClass()->getName(),
                    ClassDeclaredContext::ACCESS_PUBLIC
                );

                $child->readonly = KINT_PHP81 && $rprop->isReadOnly();

                if ($rprop->isProtected()) {
                    $child->access = ClassDeclaredContext::ACCESS_PROTECTED;
                } elseif ($rprop->isPrivate()) {
                    $child->access = ClassDeclaredContext::ACCESS_PRIVATE;
                }

                if (KINT_PHP84) {
                    if ($rprop->isProtectedSet()) {
                        $child->access_set = ClassDeclaredContext::ACCESS_PROTECTED;
                    } elseif ($rprop->isPrivateSet()) {
                        $child->access_set = ClassDeclaredContext::ACCESS_PRIVATE;
                    }

                    $hooks = $rprop->getHooks();
                    if (isset($hooks['get'])) {
                        $child->hooks |= PropertyContext::HOOK_GET;
                        if ($hooks['get']->returnsReference()) {
                            $child->hooks |= PropertyContext::HOOK_GET_REF;
                        }
                    }
                    if (isset($hooks['set'])) {
                        $child->hooks |= PropertyContext::HOOK_SET;

                        $child->hook_set_type = (string) $rprop->getSettableType();
                        if ($child->hook_set_type !== (string) $rprop->getType()) {
                            $child->hooks |= PropertyContext::HOOK_SET_TYPE;
                        } elseif ('' === $child->hook_set_type) {
                            $child->hook_set_type = null;
                        }
                    }
                }
            } else {
                $child = new ClassOwnedContext($name, $rprop->getDeclaringClass()->getName());
            }

            $child->reference = $initialized && null !== ReflectionReference::fromArrayElement($values, $key);
            $child->depth = $cdepth + 1;

            if (null !== $ap && $child->isAccessible($this->caller_class)) {
                /** @psalm-var string $child->name */
                if (Utils::isValidPhpName($child->name)) {
                    $child->access_path = $ap.'->'.$child->name;
                } else {
                    $child->access_path = $ap.'->{'.\var_export($child->name, true).'}';
                }
            }

            if (KINT_PHP84 && $rprop->isVirtual()) {
                $properties[] = new VirtualValue($child);
            } elseif (!$initialized) {
                $properties[] = new UninitializedValue($child);
            } else {
                $properties[] = $this->parse($values[$key], $child);
            }
        }

        $object = new InstanceValue($c, $classname, $hash, \spl_object_id($var));
        if ($props) {

The expression $props of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $object->setChildren($properties);
        }

        if ($properties) {
            $object->addRepresentation(new ContainerRepresentation('Properties', $properties));
        }

        $object = $this->applyPluginsComplete($var, $object, self::TRIGGER_SUCCESS);
        unset($this->object_hashes[$hash]);

        return $object;
    }