kint\inc\KintParser::_parse_object()

Complexity

Conditions	20
Paths	964

Size

Total Lines	132
Code Lines	75

Duplication

Lines	9
Ratio	6.82 %

Code Coverage

Tests	23
CRAP Score	127.9346

Importance

Changes

0

<?php
  private static function _parse_object(&$variable, KintVariableData $variableData)
  {
    if (function_exists('spl_object_hash')) {
      $hash = spl_object_hash($variable);
    } else {
      ob_start();
      /** @noinspection ForgottenDebugOutputInspection */
      /** @noinspection ReferenceMismatchInspection */
      var_dump($variable);

var_dump($variable); looks like debug code. Are you sure you do not want to remove it? This might expose sensitive data.

      preg_match('[#(\d+)]', ob_get_clean(), $match);
      $hash = $match[1];
    }

    $castedArray = (array)$variable;
    $variableData->type = get_class($variable);
    $variableData->size = count($castedArray);

    if (isset(self::$_objects[$hash])) {
      $variableData->value = '*RECURSION*';

      return false;
    }
    if (self::_checkDepth()) {
      $variableData->extendedValue = '*DEPTH TOO GREAT*';

It seems like '*DEPTH TOO GREAT*' of type string is incompatible with the declared type array<integer,object<kint\inc\KintVariableData>> of property $extendedValue.

      return false;
    }

    # ArrayObject (and maybe ArrayIterator, did not try yet) unsurprisingly consist of mainly dark magic.
    # What bothers me most, var_dump sees no problem with it, and ArrayObject also uses a custom,
    # undocumented serialize function, so you can see the properties in internal functions, but
    # can never iterate some of them if the flags are not STD_PROP_LIST. Fun stuff.
    if (
        $variableData->type === 'ArrayObject'
        ||
        is_subclass_of($variable, 'ArrayObject')
    ) {

      /* @var $variable \ArrayObject */

      $arrayObjectFlags = $variable->getFlags();
      $variable->setFlags(\ArrayObject::STD_PROP_LIST);
    }

    self::$_objects[$hash] = true; // TODO: store reflectorObject here for alternatives cache
    $reflector = new \ReflectionObject($variable);

    # add link to definition of user-land objects
    if (
        Kint::$fileLinkFormat
        &&
        Kint::enabled() === Kint::MODE_RICH
        &&
        $reflector->isUserDefined()
    ) {
      $url = Kint::getIdeLink($reflector->getFileName(), $reflector->getStartLine());

      $class = (strpos($url, 'http://') === 0) ? 'class="kint-ide-link" ' : '';
      $variableData->type = "<a {$class}href=\"{$url}\">{$variableData->type}</a>";
    }
    $variableData->size = 0;

    $extendedValue = array();
    $encountered = array();

    # copy the object as an array as it provides more info than Reflection (depends)
    foreach ($castedArray as $key => $value) {
      /* casting object to array:
       * integer properties are inaccessible;
       * private variables have the class name prepended to the variable name;
       * protected variables have a '*' prepended to the variable name.
       * These prepended values have null bytes on either side.
       * http://www.php.net/manual/en/language.types.array.php#language.types.array.casting
       */
      if ($key[0] === "\x00") {

        $access = $key[1] === '*' ? 'protected' : 'private';

        // Remove the access level from the variable name.
        $key = substr($key, strrpos($key, "\x00") + 1);
      } else {
        $access = 'public';
      }

      $encountered[$key] = true;

      $output = self::factory($value, self::escape($key));
      $output->access = $access;
      $output->operator = '->';
      $extendedValue[] = $output;
      $variableData->size++;
    }

    foreach ($reflector->getProperties() as $property) {
      $name = $property->name;
      if (
          isset($encountered[$name])
          ||
          $property->isStatic()
      ) {
        continue;
      }

      if ($property->isProtected()) {

This code seems to be duplicated across your project.

        $property->setAccessible(true);
        $access = 'protected';
      } elseif ($property->isPrivate()) {
        $property->setAccessible(true);
        $access = 'private';
      } else {
        $access = 'public';
      }

      $value = $property->getValue($variable);

      $output = self::factory($value, self::escape($name));
      $output->access = $access;
      $output->operator = '->';
      $extendedValue[] = $output;
      $variableData->size++;
    }

    if (isset($arrayObjectFlags)) {
      $variable->setFlags($arrayObjectFlags);
    }

    if ($variableData->size) {
      $variableData->extendedValue = $extendedValue;
    }

    return true;
  }