ConfigList::getListOfConfigs() - Code Metrics - sunnysideup/silverstripe-config_manager - Measure and Improve Code Quality continuously with Scrutinizer

ConfigList::getListOfConfigs() B
last analyzed 2023-01-09 04:11 UTC

↳ Parent: ConfigList
Complexity

Conditions	10
Paths	16
Size

Total Lines	71
Code Lines	47
Duplication

Lines	0
Ratio	0 %
Importance

Changes	2
Bugs	0	Features	0
Metric	Value
cc	10
eloc	47
nc	16
nop	0
dl	0
loc	71
rs	7.2896
c	2
b	0
f	0
How to fix Long Method Complexity

<?php

namespace Sunnysideup\ConfigManager\Api;

use ReflectionClass;
use SilverStripe\Config\Collections\DeltaConfigCollection;
use SilverStripe\Control\Director;
use SilverStripe\Core\ClassInfo;
use SilverStripe\Core\Config\Config;
use SilverStripe\Core\Config\Configurable;
use SilverStripe\Core\Extensible;
use SilverStripe\Core\Extension;
use SilverStripe\Core\Injector\Injectable;

class ConfigList
{
    use Extensible;
    use Injectable;
    use Configurable;

    private static $exceptional_classes = [
        Extension::class,
    ];

    private static $do_not_show = [
        'extra_methods',
        'built_in_methods',
    ];

    // protected $locationIncludes = [];
    //
    // protected $classNameIncludes = [];
    //
    // public function setLocationIncludes($a)
    // {
    //     $this->locationIncludes = $a;
    //
    //     return $this;
    // }
    //
    // public function setClassNameIncludes($a)
    // {
    //     $this->classNameIncludes = $a;
    //
    //     return $this;
    // }

    public function getListOfConfigs(): array
    {
        $resultArray = [];

        $doNotShow = $this->Config()->get('do_not_show');

        $config = Config::inst();
        $alsoSet = $config->getAll();
        $base = Director::baseFolder();

        $classes = $this->configurableClasses();
        foreach ($classes as $class) {
            $reflector = new ReflectionClass($class);
            $fileName = $reflector->getFilename();
            $fileName = str_replace($base, '', $fileName);

            //lists
            $staticListDelta = $this->getDeltas($config, $class);
            $staticListDelta = $this->getDeltas(/** @scrutinizer ignore-type */ $config, $class);
            $staticListDynamic = array_keys($alsoSet[strtolower($class)]);
            $defaultLists = $this->getDefaultLists($reflector, $doNotShow);
            $originalValues = $defaultLists['OriginalValues'];

            $lists = [
                //do first so that they will always show up
                'runtime' => $staticListDelta,
                'system' => $defaultLists['Caching'],
                'caching' => $defaultLists['System'],
                'property' => $defaultLists['Property'],
                //needs to be last so that only dynamic ones that are
                //not set as property are included
                'dynamic' => $staticListDynamic,
            ];

            foreach ($lists as $type => $list) {
                foreach ($list as $property) {
                    $key = str_replace('/', '-', $fileName . '-' . $property);
                    if (! isset($resultArray[$key])) {
                        $value = $config->get($class, $property, Config::UNINHERITED);
                        $hasValue = (bool) $value;
                        $originalValue = isset($originalValues[$property]) ? $originalValues[$property] : '';
                        if (is_object($value)) {
                            $value = 'object';
                        }
                        $isDefault = true;
                        $default = '';
                        if ($originalValue !== $value) {
                            $isDefault = false;
                            if ($value && $originalValue) {
                                $default = $originalValue;
                            }
                        }
                        $hasDefault = (bool) $originalValue;
                        $resultArray[$key] = array_merge(
                            $this->getClassIntel($class),
                            [
                                'FileLocation' => $fileName,
                                'Property' => $property,
                                'Type' => $type,
                                'IsDefault' => $isDefault,
                                'HasDefault' => $hasDefault,
                                'HasValue' => $hasValue,
                                'Default' => $default,
                                'Value' => $value,
                            ]
                        );
                    }
                }
            }
        }

        return $resultArray;
    }

    /**
     * info about static.
     *
     * @param ReflectionClass $reflector
     * @param array            $doNotShow
     */
    protected function getDefaultLists($reflector, array $doNotShow): array
    {
        //vars
        $staticListSystem = [];
        $staticListCaching = [];
        $staticListProperty = [];
        $originalValues = [];
        //start loop
        $statics = $reflector->getStaticProperties();
        foreach (array_keys($statics) as $property) {
            $propertyObject = $reflector->getProperty($property);
            if ($propertyObject->isPrivate()) {
                $propertyObject->setAccessible(true);
                $originalValues[$property] = $propertyObject->getValue($reflector);

                if (in_array($property, $doNotShow, true)) {
                    $staticListSystem[$property] = $property;
                } elseif ('_' === substr($property, 0, 1) ||
                    false !== strpos($property, 'cache')
                ) {
                    $staticListCaching[$property] = $property;
                } else {
                    $staticListProperty[$property] = $property;
                }
            }
        }

        return [
            'System' => $staticListSystem,
            'Caching' => $staticListCaching,
            'Property' => $staticListProperty,
            'OriginalValues' => $originalValues,
        ];
    }

    /**
     * info about class.
     */
    protected function getClassIntel(string $class): array
    {
        $vendor = 'n/a';
        $package = 'n/a';
        $shorterClassname = $class;
        $classNameArray = explode('\\', $class);
        $shortClassName = ClassInfo::shortName($class);
        $ancestry = ClassInfo::ancestry($class);
        $childClasses = ClassInfo::subclassesFor($class, false);
        if (count($classNameArray) > 1) {
            $vendor = $classNameArray[0];
            $package = $classNameArray[1];
            array_shift($classNameArray);
            array_shift($classNameArray);
            $shorterClassname = implode(' / ', $classNameArray);
        }

        return [
            'Vendor' => $vendor,
            'Package' => $package,
            'ClassName' => $class,
            'ShorterClassName' => $shorterClassname,
            'ShortClassName' => $shortClassName,
            'ParentClasses' => $ancestry,
            'ChildClasses' => $childClasses,
        ];
    }

    /**
     * get values set at run time (deltas / changed ones).
     *
     * @param Config $config
     * @param string $className
     */
    protected function getDeltas($config, $className): array
    {
        $deltaList = [];
        if ($config instanceof DeltaConfigCollection) {

            $deltas = $config->getDeltas($className);
            if (count($deltas)) {
                foreach ($deltas as $deltaInners) {
                    if (isset($deltaInners['config'])) {
                        $deltaList = array_merge(
                            $deltaList,
                            array_keys($deltaInners['config'])
                        );
                    }
                }
            }
        }

        return $deltaList;
    }

    /**
     * get a list of class with the Configurable Trait.
     */
    protected function configurableClasses(): array
    {
        $definedClasses = ClassInfo::allClasses();

        return array_filter(
            $definedClasses,
            function ($className) {
                if (class_exists($className)) {
                    $autoload = true;
                    $traits = [];
                    $class = $className;
                    // Get traits of all parent classes
                    do {
                        $traits = array_merge(class_uses($class, $autoload), $traits);
                        $class = get_parent_class($class);
                        if (in_array($class, $this->Config()->get('exceptional_classes'), true)) {
                            $traits[Configurable::class] = Configurable::class;
                        }
                    } while ($class);

                    // Get traits of all parent traits
                    $traitsToSearch = $traits;
                    while (! empty($traitsToSearch)) {
                        $newTraits = class_uses(array_pop($traitsToSearch), $autoload);
                        $traits = array_merge($newTraits, $traits);
                        $traitsToSearch = array_merge($newTraits, $traitsToSearch);
                    }

                    foreach (array_keys($traits) as $trait) {
                        $traits = array_merge(class_uses($trait, $autoload), $traits);
                    }

                    return isset($traits[Configurable::class]);
                }
            }
        );
    }
}

sunnysideup / silverstripe-config_manager

ConfigList::getListOfConfigs() B last analyzed 2023-01-09 04:11 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

ConfigList::getListOfConfigs() B
last analyzed 2023-01-09 04:11 UTC
