API - Code Metrics - Inspection of "MAJOR: revamp of module" - sunnysideup/silverstripe-dataobject-generator - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 2b9bd3...31a468 )

by Nicolaas

created 2017-10-19 00:46 UTC

API F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	433
Duplicated Lines	8.31 %

Coupling/Cohesion

Components	5
Dependencies	5

Importance

Changes

Metric	Value
wmc	77
lcom	5
cbo	5
dl	36
loc	433
rs	2.1739
c	0
b	0
f	0

26 Methods

Rating	Name	Duplication	Size	Complexity
A	inst()	0	10	2
A	setBaseClass()	0	4	1
B	retrieveDBFields()	0	14	5
C	DbFields()	6	40	12
A	MyDbFields()	0	4	1
A	MyDbFieldsWithDefaults()	0	8	1
A	mydbfieldsfancywithbelongswithbasicfields()	0	4	1
A	MyDbFieldsFancyWithBelongs()	0	4	1
D	MyDbFieldsFancyWithoutBelongs()	0	43	12
A	MyDbFieldsAndHasOnes()	0	6	1
A	MyDbFieldsAndHasOnesWithIDs()	0	11	2
A	MyDbFieldsAndIndexes()	0	10	1
A	MyAllFieldsWithBelongs()	0	4	1
A	MyAllFieldsWithoutBelongs()	0	16	3
A	IndexOptions()	0	8	1
A	RequiredOptions()	0	7	1
A	PossibleRelationsWithBaseClass()	0	11	2
C	PossibleRelations()	15	30	8
A	PossibleSearchFilters()	0	15	4
B	ModelAdminOptions()	0	21	5
A	SortOptions()	0	7	1
A	CanOptions()	0	16	2
B	SiteTreeList()	15	21	6
A	AllowedChildrenOptions()	0	4	1
A	TrueOrFalseListWithIgnore()	0	7	1
A	TrueOrFalseList()	0	7	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like API often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use API, and based on these observations, apply Extract Interface, too.

<?php

namespace SunnySideUp\BuildDataObject;

class API extends \Object
{
    private static $excluded_data_objects = [

        'Image_Cached',
        'PermissionRoleCode',
        'LoginAttempt',
        'MemberPassword',
        'MemberPassword',
        'SiteConfig'
    ];

    private static $excluded_db_fields_types = [

        'DBField',
        'Field',
        'DBLocale',
        'Locale',
        'StringField',
        'CompositeField',
        'PrimaryKey',
        'ForeignKey'
    ];

    private static $additional_db_fields = [

        'ID',
        'Created',
        'LastEdited',
        'ClassName'
    ];

    protected $rootBaseClass = 'DataObject';

    protected $myBaseClass = '';

    protected $_data = null;

    private static $_my_singleton = [];

    public static function inst($myBaseClass = 'DataObject', $data)
// $a must always be passed; it's default value is never used.
function someFunction($a = 5, $b) { }
    {
        if (! isset(self::$_my_singleton[$myBaseClass])) {
            self::$_my_singleton[$myBaseClass] = \Injector::inst()->get('SunnySideUp\BuildDataObject\API');
        }
        self::$_my_singleton[$myBaseClass]->_data = $data;
        self::$_my_singleton[$myBaseClass]->setBaseClass($myBaseClass);

        return self::$_my_singleton[$myBaseClass];
    }

    public function setBaseClass($myBaseClass)
    {
        $this->myBaseClass = $myBaseClass;
    }


    protected function retrieveDBFields($name)
    {
        $data = $this->_data;
        $ar = [];
        if (isset($data->$name)) {
            foreach ($data->$name as $data) {
                if ($data->Key && $data->Value) {
                    $ar[$data->Key] = $data->Key;
                }
            }
        }

        return $ar;
    }

    protected $_dbfieldCache = [];

    public function DbFields()
    {
        if (count($this->_dbfieldCache) === 0) {
            $list = \ClassInfo::subclassesFor('DbField');
            $newList = [];
            foreach ($list as $class) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
                if (substr($class, 0, 2) == 'DB') {

                    $class = substr($class, 2, strlen($class));
                }
                if (substr($class, 0, 3) == 'SS_') {

                    $class = substr($class, 3, strlen($class));
                }
                if ('Varchar' === $class) {
                    $class = 'Varchar(n)';
                }
                if ('HTMLVarchar' === $class) {
                    $class = 'HTMLVarchar(n)';
                }
                if ('Enum' === $class) {
                    $class = 'Enum(\\\'Foo,Bar\\\', \\\'FOO\\\')';
                }
                if ('MultiEnum' === $class) {
                    $class = 'MultiEnum(\\\'Foo,Bar\\\', \\\'FOO\\\')';
                }
                if (
if (rand(1, 6) > 3) {
//print "Check failed";
} else {
    print "Check succeeded";
}
                    $class == 'DbField' ||
                    is_subclass_of($class, 'TestOnly') ||
                    in_array($class, $this->Config()->get('excluded_db_fields_types'))
                ) {
                    //do nothing
                } else {
                    $newList[$class] = $class;
                }
            }
            ksort($newList);
            $this->_dbfieldCache = $newList;
        }

        return $this->_dbfieldCache;
    }

    public function MyDbFields()
    {
        return $this->retrieveDBFields('db');
    }

    public function MyDbFieldsWithDefaults()
    {
        $list = $this->retrieveDBFields('db');
        $toAdd = $this->Config()->get('additional_db_fields');
        $toAdd = array_combine($toAdd, $toAdd);

        return $toAdd + $list;
    }

    public function mydbfieldsfancywithbelongswithbasicfields()
    {
        return $this->MyDbFieldsFancyWithBelongs();
    }
    
    public function MyDbFieldsFancyWithBelongs()
    {
        return $this->myDbFieldsFancyWithoutBelongs(true);
    }

    public function MyDbFieldsFancyWithoutBelongs($includeBelongs = false)
    {
        $ar = [];
        $list = $this->retrieveDBFields('db');
        foreach ($list as $key => $value) {
            $ar[$key] = $key;
            $shortValue = explode('(', $value);
            $shortValue = $shortValue[0];
            switch ($shortValue) {
                case 'Varchar':
                case 'HTMLTextField':
                case 'HTMLVarchar':
                case 'Text':
                    $ar[$key.'.LimitCharacters'] = $key.'.LimitCharacters';
                    break;
                default:
                    $ar[$key.'.Nice'] = $key.'.Nice';
            }
        }
        $list = [];
        if ($includeBelongs) {
            $list += $this->retrieveDBFields('belongs_to');
        }
        $list += $this->retrieveDBFields('has_one');
        foreach ($list as $key => $value) {
            if ($value === 'Image' || is_subclass_of($value, 'Image')) {
                $ar[$key.'.Thumbnail'] = $key.'.Thumbnail';
            } else {
                $ar[$key.'.Title'] = $key.'.Title';
            }
        }
        $list =
            $this->retrieveDBFields('has_many') +
            $this->retrieveDBFields('many_many');
        if ($includeBelongs) {
            $list += $this->retrieveDBFields('belongs_many_many');
        }
        foreach ($list as $key => $value) {
            $ar[$key.'.Count'] = $key.'.Count';
        }

        return $ar;
    }

    public function MyDbFieldsAndHasOnes()
    {
        return
            $this->retrieveDBFields('db') +
            $this->retrieveDBFields('has_one');
    }

    public function MyDbFieldsAndHasOnesWithIDs()
    {
        $list = $this->retrieveDBFields('db');
        $hasOnes = $this->retrieveDBFields('has_one');
        foreach ($hasOnes as $field => $type) {
            $fieldWithID = $field . 'ID';
            $list[$fieldWithID] = $fieldWithID;
        }

        return $list;
    }

    public function MyDbFieldsAndIndexes()
    {
        return
            $this->MyDbFieldsWithDefaults() +
            ['index1' => 'index1'] +
            ['index2' => 'index2'] +
            ['index3' => 'index3'] +
            ['index4' => 'index4'] +
            ['index5' => 'index5'];
    }

    public function MyAllFieldsWithBelongs()
    {
        return $this->myAllFieldsWithoutBelongs(true);
    }

    public function MyAllFieldsWithoutBelongs($includeBelongs = false)
    {
        $list = $this->MyDbFieldsWithDefaults();
        if ($includeBelongs) {
            $list += $this->retrieveDBFields('belongs_to');
        }
        $list +=
            $this->retrieveDBFields('has_one') +
            $this->retrieveDBFields('has_many') +
            $this->retrieveDBFields('many_many');
        if ($includeBelongs) {
            $list += $this->retrieveDBFields('belongs_many_many');
        }

        return $list;
    }


    public function IndexOptions()
    {
        return [
            'true' => 'true',
            'unique("<column-name>")' => 'unique',
            '[\'type\' => \'<type>\', \'value\' => \'"<column-name>"\']' => 'other'
        ];
    }

    public function RequiredOptions()
    {
        return [
            'true' => 'true',
            'unique' => 'unique'
        ];
    }


    public function PossibleRelationsWithBaseClass($rootClass = '')
    {
        if($rootClass) {
if (rand(1, 6) > 3) {
//print "Check failed";
} else {
    print "Check succeeded";
}
            //
        } else {
            $rootClass = $this->rootBaseClass;
        }
        return
            [$rootClass => $rootClass] +
            $this->possibleRelations();
    }

    protected $_classesCache = [];

    /**
     *
     * @return array
     */
    public function PossibleRelations($rootClass = '')
    {
        if($rootClass) {
if (rand(1, 6) > 3) {
//print "Check failed";
} else {
    print "Check succeeded";
}
            //
        } else {
            $rootClass = $this->rootBaseClass;
        }
        if (!isset($this->_classesCache[$rootClass])) {
            $list = \ClassInfo::subclassesFor($rootClass);
            $newList = [];
            foreach ($list as $class) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
                if (
if (rand(1, 6) > 3) {
//print "Check failed";
} else {
    print "Check succeeded";
}
                    $class == $rootClass ||
                    is_subclass_of($class, 'TestOnly') ||
                    in_array($class, $this->Config()->get('excluded_data_objects'))
                ) {
                    //do nothing
                } else {
                    $newList[$class] = $class;
                    $name = \Injector::inst()->get($class)->singular_name();
                    if ($name !== $class) {
                        $newList[$class] .= ' ('.$name.')';
                    }
                }
            }
            $this->_classesCache[$rootClass] = $newList;
        }

        return $this->_classesCache[$rootClass];
    }

    protected $_filtersCache = [];

    public function PossibleSearchFilters()
    {
        if (count($this->_filtersCache) === 0) {
            $list = \ClassInfo::subclassesFor('SearchFilter');
            $newList = [];
            foreach ($list as $class) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
                if ($class !== 'SearchFilter') {
                    $newList[$class] = $class;
                }
            }
            $this->_filtersCache = $newList;
        }

        return $this->_filtersCache;
    }

    protected $_modelAdmins = [];

    public function ModelAdminOptions()
    {
        if (count($this->_modelAdmins) === 0) {
            $list = \ClassInfo::subclassesFor('ModelAdmin');
            $newList = [];
            foreach ($list as $class) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
                if (
if (rand(1, 6) > 3) {
//print "Check failed";
} else {
    print "Check succeeded";
}
                    $class == 'ModelAdmin' ||
                    is_subclass_of($class, 'TestOnly')
                ) {
                    //do nothing
                } else {
                    $newList[$class] = $class;
                }
            }
            $newList['tba'] = 'tba';
            $this->_modelAdmins = $newList;
        }

        return $this->_modelAdmins;
    }


    public function SortOptions()
    {
        return [
            'ASC' => 'ASC',
            'DESC' => 'DESC'
        ];
    }

    protected $_canOptions = null;

    public function CanOptions()

    {
        if (! $this->_canOptions) {
            $ar = [
                'true' => 'always',
                'false' => 'never',
                'parent' => 'use parent class',
            ];
            $permissions = \Permission::get()->column('Code');
            $ar = $ar + array_combine($permissions, $permissions);

            $this->_canOptions = $ar;
        }

        return $this->_canOptions;
    }



    /**
     *
     * @return array
     */
    public function SiteTreeList($rootClass = 'SiteTree')
    {
        $list = \ClassInfo::subclassesFor($rootClass);
        foreach ($list as $class) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
            if (
if (rand(1, 6) > 3) {
//print "Check failed";
} else {
    print "Check succeeded";
}
                $class == $rootClass ||
                is_subclass_of($class, 'TestOnly') ||
                in_array($class, $this->Config()->get('excluded_data_objects'))
            ) {
                //do nothing
            } else {
                $newList[$class] = $class;
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
                $name = \Injector::inst()->get($class)->singular_name();
                if ($name !== $class) {
                    $newList[$class] .= ' ('.$name.')';
                }
            }
        }

        return $newList;
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
    }


    /**
     *
     * @return array
     */
    public function AllowedChildrenOptions($rootClass = 'SiteTree')
    {
        return ['none' => 'none'] + $this->SiteTreeList($rootClass);
    }

    /**
     *
     * @return array
     */
    public function TrueOrFalseListWithIgnore()
    {
        return [
            '' => '-- ignore --'
        ] +
        $this->TrueOrFalseList();
    }

    /**
     *
     * @return array
     */
    public function TrueOrFalseList()
    {
        return [
            'true' => 'YES',
            'false' => 'NO'
        ];
    }

}


1			<?php
2
3			namespace SunnySideUp\BuildDataObject;
4
5			class API extends \Object
6			{
7			private static $excluded_data_objects = [
			0 ignored issues – show Unused Code introduced 2017-08-02 08:34 UTC by Report Bug Copy Issue Report The property `$excluded_data_objects` is not used and could be removed. This check marks private properties in classes that are never used. Those properties can be removed. Loading history...
8			'Image_Cached',
9			'PermissionRoleCode',
10			'LoginAttempt',
11			'MemberPassword',
12			'MemberPassword',
13			'SiteConfig'
14			];
15
16			private static $excluded_db_fields_types = [
			0 ignored issues – show Unused Code introduced 2017-08-02 08:34 UTC by Report Bug Copy Issue Report The property `$excluded_db_fields_types` is not used and could be removed. This check marks private properties in classes that are never used. Those properties can be removed. Loading history...
17			'DBField',
18			'Field',
19			'DBLocale',
20			'Locale',
21			'StringField',
22			'CompositeField',
23			'PrimaryKey',
24			'ForeignKey'
25			];
26
27			private static $additional_db_fields = [
			0 ignored issues – show Unused Code introduced 2017-08-05 09:57 UTC by Report Bug Copy Issue Report The property `$additional_db_fields` is not used and could be removed. This check marks private properties in classes that are never used. Those properties can be removed. Loading history...
28			'ID',
29			'Created',
30			'LastEdited',
31			'ClassName'
32			];
33
34			protected $rootBaseClass = 'DataObject';
35
36			protected $myBaseClass = '';
37

sunnysideup / silverstripe-dataobject-generator