kint\parsers\custom\Kint_Parsers_ClassMethods

Complexity

Total Complexity

32

Size/Duplication

Total Lines	165
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	1
Bugs	0	Features	0

1 Method

Rating	Name	Duplication	Size	Complexity
D	_parse()	0	152	32

<?php

namespace kint\parsers\custom;

use kint\inc\KintParser;
use kint\inc\KintVariableData;
use kint\Kint;

/**
 * Class Kint_Parsers_ClassMethods
 */
class Kint_Parsers_ClassMethods extends KintParser
{
  /**
   * @var array
   */
  private static $cache = array();

  /**
   * @param mixed $variable
   *
   * @return bool
   */
  protected function _parse(&$variable)
  {
    if (!is_object($variable)) {
      return false;
    }

    $className = get_class($variable);

    # assuming class definition will not change inside one request
    if (!isset(self::$cache[$className])) {
      $reflection = new \ReflectionClass($variable);

      $public = $private = $protected = array();

      // Class methods
      foreach ($reflection->getMethods() as $method) {
        $params = array();

        // Access type
        $access = implode(' ', \Reflection::getModifierNames($method->getModifiers()));

        // Method parameters
        foreach ($method->getParameters() as $param) {
          $paramString = '';

          if ($param->isArray()) {
            $paramString .= 'array ';
          } else {
            try {
              $paramClassName = $param->getClass();
              if ($paramClassName) {
                $paramString .= $paramClassName->name . ' ';
              }
            } catch (\ReflectionException $e) {
              preg_match('/\[\s\<\w+?>\s([\w]+)/', (string)$param, $matches);
              $paramClassName = isset($matches[1]) ? $matches[1] : '';

              $paramString .= ' UNDEFINED CLASS (' . $paramClassName . ') ';
            }
          }

          $paramString .= ($param->isPassedByReference() ? '&' : '') . '$' . $param->getName();

          if ($param->isDefaultValueAvailable()) {
            if (is_array($param->getDefaultValue())) {
              $arrayValues = array();
              foreach ($param->getDefaultValue() as $key => $value) {
                $arrayValues[] = $key . ' => ' . $value;
              }

              $defaultValue = 'array(' . implode(', ', $arrayValues) . ')';
            } elseif ($param->getDefaultValue() === null) {
              $defaultValue = 'NULL';
            } elseif ($param->getDefaultValue() === false) {
              $defaultValue = 'false';
            } elseif ($param->getDefaultValue() === true) {
              $defaultValue = 'true';
            } elseif ($param->getDefaultValue() === '') {
              $defaultValue = '""';
            } else {
              $defaultValue = $param->getDefaultValue();
            }

            $paramString .= ' = ' . $defaultValue;
          }

          $params[] = $paramString;
        }

        $output = new KintVariableData;

        // Simple DocBlock parser, look for @return
        $docBlock = $method->getDocComment();
        if ($docBlock) {
          $matches = array();
          if (preg_match_all('/@(\w+)\s+(.*)\r?\n/m', $docBlock, $matches)) {
            $lines = array_combine($matches[1], $matches[2]);
            if (isset($lines['return'])) {
              $output->operator = '->';
              # since we're outputting code, assumption that the string is utf8 is most likely correct
              # and saves resources
              $output->type = self::escape($lines['return'], 'UTF-8');
            }
          }
        }

        $output->name = ($method->returnsReference() ? '&' : '') . $method->getName() . '('
                        . implode(', ', $params) . ')';
        $output->access = $access;

        if (is_string($docBlock)) {
          $lines = array();
          foreach (explode("\n", $docBlock) as $line) {
            $line = trim($line);

            if (in_array($line, array('/**', '/*', '*/'), true)) {
              continue;
            } elseif (strpos($line, '*') === 0) {
              $line = substr($line, 1);
            }

            $lines[] = self::escape(trim($line), 'UTF-8');

trim($line) cannot be passed to escape() as the parameter $value expects a reference.

          }

          $output->extendedValue = implode("\n", $lines) . "\n\n";

It seems like implode(' ', $lines) . ' ' of type string is incompatible with the declared type array<integer,object<kint\inc\KintVariableData>> of property $extendedValue.

        }

        $declaringClass = $method->getDeclaringClass();
        $declaringClassName = $declaringClass->getName();

        if ($declaringClassName !== $className) {
          /** @noinspection PhpToStringImplementationInspection */
          $output->extendedValue .= "<small>Inherited from <i>{$declaringClassName}</i></small>\n";
        }

        $fileName = Kint::shortenPath($method->getFileName()) . ':' . $method->getStartLine();
        /** @noinspection PhpToStringImplementationInspection */
        $output->extendedValue .= "<small>Defined in {$fileName}</small>";

        $sortName = $access . $method->getName();

        if ($method->isPrivate()) {
          $private[$sortName] = $output;
        } elseif ($method->isProtected()) {
          $protected[$sortName] = $output;
        } else {
          $public[$sortName] = $output;
        }
      }

      if (!$private && !$protected && !$public) {

The expression $private 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.

The expression $protected 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.

The expression $public 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.

        self::$cache[$className] = false;
      }

      ksort($public);
      ksort($protected);
      ksort($private);

      /** @noinspection AdditionOperationOnArraysInspection */
      self::$cache[$className] = $public + $protected + $private;
    }

    if (count(self::$cache[$className]) === 0) {
      return false;
    }

    $this->value = self::$cache[$className];
    $this->type = 'Available methods';
    $this->size = count(self::$cache[$className]);

    return true;
  }
}