Kint\Renderer\Renderer

Complexity

Total Complexity

14

Size/Duplication

Total Lines	103
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	2

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
	render()	0	1	?
A	__construct()	0	4	1
A	matchPlugins()	0	12	3
A	parserPlugins()	0	4	1
A	preRender()	0	4	1
A	postRender()	0	4	1
A	sortPropertiesFull()	0	14	3
B	sortProperties()	0	23	4

<?php

namespace Kint\Renderer;

use Kint\Object\BasicObject;
use Kint\Object\InstanceObject;

abstract class Renderer

Renderer does not seem to conform to the naming convention (^Abstract|Factory$).

{
    const SORT_NONE = 0;
    const SORT_VISIBILITY = 1;
    const SORT_FULL = 2;

    protected $parameters;

    abstract public function render(BasicObject $o);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

Avoid variables with short names like $o. Configured minimum length is 3.

    /**
     * It's a constructor. It constructs.
     *
     * @param array $parameters Array with initial kint state information
     */
    public function __construct(array $parameters)
    {
        $this->parameters = $parameters;
    }

    /**
     * Returns the first compatible plugin available.
     *
     * @param array $plugins Array of hints to class strings
     * @param array $hints   Array of object hints
     *
     * @return array Array of hints to class strings filtered and sorted by object hints
     */
    public function matchPlugins(array $plugins, array $hints)
    {
        $out = array();

        foreach ($hints as $key) {
            if (isset($plugins[$key])) {
                $out[$key] = $plugins[$key];
            }
        }

        return $out;
    }

    public function parserPlugins(array $plugins)
    {
        return $plugins;
    }

    public function preRender()
    {
        return '';
    }

    public function postRender()
    {
        return '';
    }

    public static function sortPropertiesFull(BasicObject $a, BasicObject $b)

Avoid variables with short names like $a. Configured minimum length is 3.

Avoid variables with short names like $b. Configured minimum length is 3.

    {
        $sort = BasicObject::sortByAccess($a, $b);
        if ($sort) {
            return $sort;
        }

        $sort = BasicObject::sortByName($a, $b);
        if ($sort) {
            return $sort;
        }

        return InstanceObject::sortByHierarchy($a->owner_class, $b->owner_class);
    }

    /**
     * Sorts an array of BasicObject.
     *
     * @param BasicObject[] $contents Object properties to sort
     * @param int           $sort
     *
     * @return BasicObject[]
     */
    public static function sortProperties(array $contents, $sort)
    {
        switch ($sort) {
            case self::SORT_VISIBILITY:
                $containers = array(
                    BasicObject::ACCESS_PUBLIC => array(),
                    BasicObject::ACCESS_PROTECTED => array(),
                    BasicObject::ACCESS_PRIVATE => array(),
                    BasicObject::ACCESS_NONE => array(),
                );

                foreach ($contents as $item) {
                    $containers[$item->access][] = $item;
                }

                return call_user_func_array('array_merge', $containers);
            case self::SORT_FULL:
                usort($contents, array('Kint\\Renderer\\Renderer', 'sortPropertiesFull'));
                // fall through
            default:
                return $contents;
        }
    }
}