API - Code Metrics - Inspection of "Merge branch 'master' of https://github.com/sunnys..." - sunnysideup/silverstripe-dataobject-generator - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d2b2ff...5bea60 )

by Nicolaas

created 2017-08-05 09:56 UTC

API F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	338
Duplicated Lines	1.78 %

Coupling/Cohesion

Components	6
Dependencies	5

Importance

Changes

Metric	Value
wmc	64
lcom	6
cbo	5
dl	6
loc	338
rs	3.4883
c	0
b	0
f	0

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 $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) {
                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 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() {
        return
            [$this->myBaseClass => $this->myBaseClass] +
            $this->possibleRelations();
    }

    protected $_classesCache = [];

    public function PossibleRelations()
    {
        if(count($this->_classesCache) === 0) {
            $list = \ClassInfo::subclassesFor($this->myBaseClass);
            $newList = [];
            $newList = [];
            foreach($list as $class) {
                if(
if (rand(1, 6) > 3) {
//print "Check failed";
} else {
    print "Check succeeded";
}
                    $class == $this->myBaseClass ||
                    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 = $newList;
        }

        return $this->_classesCache;
    }

    protected $_filtersCache = [];

    public function PossibleSearchFilters()
    {
        if(count($this->_filtersCache) === 0) {
            $list = \ClassInfo::subclassesFor('SearchFilter');
            $newList = [];
            foreach($list as $class) {
                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) {
                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;
    }


}


1			<?php
2
3			namespace SunnySideUp\BuildDataObject;
4
5			class API extends \Object
6			{
7
8			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...
9			'Image_Cached',
10			'PermissionRoleCode',
11			'LoginAttempt',
12			'MemberPassword',
13			'MemberPassword',
14			'SiteConfig'
15			];
16
17			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...
18			'DBField',
19			'Field',
20			'DBLocale',
21			'Locale',
22			'StringField',
23			'CompositeField',
24			'PrimaryKey',
25			'ForeignKey'
26			];
27
28			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...
29			'ID',
30			'Created',
31			'LastEdited',
32			'ClassName'
33			];
34
35
36			protected $myBaseClass = '';
37
38			protected $_data = null;
39
40			private static $_my_singleton = [];
41
42			public static function inst($myBaseClass = 'DataObject', $data)
			0 ignored issues – show Coding Style introduced 2017-08-02 08:34 UTC by Report Bug Copy Issue Report Parameters which have default values should be placed at the end. If you place a parameter with a default value before a parameter with a default value, the default value of the first parameter will never be used as it will always need to be passed anyway: // $a must always be passed; it's default value is never used. function someFunction($a = 5, $b) { } Loading history...
43			{
44			if(! isset(self::$_my_singleton[$myBaseClass])) {
45			self::$_my_singleton[$myBaseClass] = \Injector::inst()->get('SunnySideUp\BuildDataObject\API');
46			}
47			self::$_my_singleton[$myBaseClass]->_data = $data;
48			self::$_my_singleton[$myBaseClass]->setBaseClass($myBaseClass);
49
50			return self::$_my_singleton[$myBaseClass];
51			}
52
53			public function setBaseClass($myBaseClass)
54			{
55			$this->myBaseClass = $myBaseClass;
56			}
57
58
59			protected function retrieveDBFields($name)
60			{
61			$data = $this->_data;
62			$ar = [];
63			if(isset($data->$name)) {
64			foreach($data->$name as $data) {
65			if($data->Key && $data->Value) {
66			$ar[$data->Key] = $data->Key;
67			}
68			}
69			}
70
71			return $ar;
72			}
73
74			protected $_dbfieldCache = [];
75
76			public function DbFields()
77			{
78			if(count($this->_dbfieldCache) === 0) {
79			$list = \ClassInfo::subclassesFor('DbField');
80			$newList = [];
81			foreach($list as $class) {
82			if(substr($class, 0, 2) == 'DB') {
83			$class = substr($class, 2, strlen($class));
84			}
85			if(substr($class, 0, 3) == 'SS_') {
86			$class = substr($class, 3, strlen($class));
87			}
88			if('Varchar' === $class) {
89			$class = 'Varchar(n)';
90			}
91			if('HTMLVarchar' === $class) {
92			$class = 'HTMLVarchar(n)';
93			}
94			if('Enum' === $class) {
95			$class = 'Enum(\\\'Foo,Bar\\\', \\\'FOO\\\')';
96			}
97			if('MultiEnum' === $class) {
98			$class = 'MultiEnum(\\\'Foo,Bar\\\', \\\'FOO\\\')';
99			}
100			if(
			0 ignored issues – show Unused Code introduced 2017-08-02 08:34 UTC by Report Bug Copy Issue Report This `if` statement is empty and can be removed. This check looks for the bodies of `if` statements that have no statements or where all statements have been commented out. This may be the result of changes for debugging or the code may simply be obsolete. These `if` bodies can be removed. If you have an empty if but statements in the `else` branch, consider inverting the condition. if (rand(1, 6) > 3) { //print "Check failed"; } else { print "Check succeeded"; } could be turned into if (rand(1, 6) <= 3) { print "Check succeeded"; } This is much more concise to read. Loading history...
101			$class == 'DbField' \|\|
102			is_subclass_of($class, 'TestOnly') \|\|
103			in_array($class, $this->Config()->get('excluded_db_fields_types'))
104			) {
105			//do nothing
106			} else {
107			$newList[$class] = $class;
108			}
109			}
110			ksort($newList);
111			$this->_dbfieldCache = $newList;
112			}
113
114			return $this->_dbfieldCache;
115			}
116
117			public function MyDbFields()
118			{
119			return $this->retrieveDBFields('db');
120			}
121
122			public function MyDbFieldsWithDefaults()
123			{
124			$list = $this->retrieveDBFields('db');
125			$toAdd = $this->Config()->get('additional_db_fields')
126			$toAdd = array_combine($toAdd, $toAdd);
			0 ignored issues – show Bug introduced 2017-08-05 09:57 UTC by Report Bug Copy Issue Report This code did not parse for me. Apparently, there is an error somewhere around this line: Syntax error, unexpected T_VARIABLE Loading history...
127
128			return $toAdd + $list;
129			}
130
131			public function MyDbFieldsFancyWithBelongs()
132			{
133			return $this->myDbFieldsFancyWithoutBelongs(true);
134			}
135
136			public function MyDbFieldsFancyWithoutBelongs($includeBelongs = false)
137			{
138			$ar = [];
139			$list = $this->retrieveDBFields('db');
140			foreach($list as $key => $value) {
141			$ar[$key] = $key;
142			$shortValue = explode('(',$value);
143			$shortValue = $shortValue[0];
144			switch($shortValue) {
145			case 'Varchar':
146			case 'HTMLTextField':
147			case 'HTMLVarchar':
148			case 'Text':
149			$ar[$key.'.LimitCharacters'] = $key.'.LimitCharacters';
150			break;
151			default:
152			$ar[$key.'.Nice'] = $key.'.Nice';
153			}
154			}
155			$list = [];
156			if($includeBelongs) {
157			$list += $this->retrieveDBFields('belongs_to');
158			}
159			$list += $this->retrieveDBFields('has_one');
160			foreach($list as $key => $value) {
161			if($value === 'Image' \|\| is_subclass_of($value, 'Image')) {
162			$ar[$key.'.Thumbnail'] = $key.'.Thumbnail';
163			} else {
164			$ar[$key.'.Title'] = $key.'.Title';
165			}
166			}
167			$list =
168			$this->retrieveDBFields('has_many') +
169			$this->retrieveDBFields('many_many');
170			if($includeBelongs) {
171			$list += $this->retrieveDBFields('belongs_many_many');
172			}
173			foreach($list as $key => $value) {
174			$ar[$key.'.Count'] = $key.'.Count';
175			}
176
177			return $ar;
178			}
179
180			public function MyDbFieldsAndHasOnes()
181			{
182			return
183			$this->retrieveDBFields('db') +
184			$this->retrieveDBFields('has_one');
185			}
186
187			public function MyDbFieldsAndHasOnesWithIDs()
188			{
189			$list = $this->retrieveDBFields('db');
190			$hasOnes = $this->retrieveDBFields('has_one');
191			foreach($hasOnes as $field => $type) {
192			$fieldWithID = $field . 'ID';
193			$list[$fieldWithID] = $fieldWithID;
194			}
195
196			return $list;
197			}
198
199			public function MyDbFieldsAndIndexes()
200			{
201			return
202			$this->MyDbFieldsWithDefaults() +
203			['index1' => 'index1'] +
204			['index2' => 'index2'] +
205			['index3' => 'index3'] +
206			['index4' => 'index4'] +
207			['index5' => 'index5'];
208			}
209
210			public function MyAllFieldsWithBelongs()
211			{
212			return $this->myAllFieldsWithoutBelongs(true);
213			}
214
215			public function MyAllFieldsWithoutBelongs($includeBelongs = false)
216			{
217			$list = $this->MyDbFieldsWithDefaults();
218			if($includeBelongs) {
219			$list += $this->retrieveDBFields('belongs_to');
220			}
221			$list +=
222			$this->retrieveDBFields('has_one') +
223			$this->retrieveDBFields('has_many') +
224			$this->retrieveDBFields('many_many');
225			if($includeBelongs) {
226			$list += $this->retrieveDBFields('belongs_many_many');
227			}
228
229			return $list;
230			}
231
232
233			public function IndexOptions()
234			{
235			return [
236			'true' => 'true',
237			'unique("<column-name>")' => 'unique',
238			'[\'type\' => \'<type>\', \'value\' => \'"<column-name>"\']' => 'other'
239			];
240			}
241
242			public function RequiredOptions()
243			{
244			return [
245			'true' => 'true',
246			'unique' => 'unique'
247			];
248			}
249
250
251			public function PossibleRelationsWithBaseClass() {
252			return
253			[$this->myBaseClass => $this->myBaseClass] +
254			$this->possibleRelations();
255			}
256
257			protected $_classesCache = [];
258
259			public function PossibleRelations()
260			{
261			if(count($this->_classesCache) === 0) {
262			$list = \ClassInfo::subclassesFor($this->myBaseClass);
263			$newList = [];
264			$newList = [];
265			foreach($list as $class) {
266			if(
			0 ignored issues – show Unused Code introduced 2017-08-02 08:34 UTC by Report Bug Copy Issue Report This `if` statement is empty and can be removed. This check looks for the bodies of `if` statements that have no statements or where all statements have been commented out. This may be the result of changes for debugging or the code may simply be obsolete. These `if` bodies can be removed. If you have an empty if but statements in the `else` branch, consider inverting the condition. if (rand(1, 6) > 3) { //print "Check failed"; } else { print "Check succeeded"; } could be turned into if (rand(1, 6) <= 3) { print "Check succeeded"; } This is much more concise to read. Loading history...
267			$class == $this->myBaseClass \|\|
268			is_subclass_of($class, 'TestOnly') \|\|
269			in_array($class, $this->Config()->get('excluded_data_objects'))
270			) {
271			//do nothing
272			} else {
273			$newList[$class] = $class;
274			$name = \Injector::inst()->get($class)->singular_name();
275			if($name !== $class) {
276			$newList[$class] .= ' ('.$name.')';
277			}
278			}
279			}
280			$this->_classesCache = $newList;
281			}
282
283			return $this->_classesCache;
284			}
285
286			protected $_filtersCache = [];
287
288			public function PossibleSearchFilters()
289			{
290			if(count($this->_filtersCache) === 0) {
291			$list = \ClassInfo::subclassesFor('SearchFilter');
292			$newList = [];
293			foreach($list as $class) {
294			if($class !== 'SearchFilter') {
295			$newList[$class] = $class;
296			}
297			}
298			$this->_filtersCache = $newList;
299			}
300
301			return $this->_filtersCache;
302			}
303
304			protected $_modelAdmins = [];
305
306			public function ModelAdminOptions()
307			{
308			if(count($this->_modelAdmins) === 0) {
309			$list = \ClassInfo::subclassesFor('ModelAdmin');
310			$newList = [];
311			foreach($list as $class) {
312			if(
			0 ignored issues – show Unused Code introduced 2017-08-02 08:34 UTC by Report Bug Copy Issue Report This `if` statement is empty and can be removed. This check looks for the bodies of `if` statements that have no statements or where all statements have been commented out. This may be the result of changes for debugging or the code may simply be obsolete. These `if` bodies can be removed. If you have an empty if but statements in the `else` branch, consider inverting the condition. if (rand(1, 6) > 3) { //print "Check failed"; } else { print "Check succeeded"; } could be turned into if (rand(1, 6) <= 3) { print "Check succeeded"; } This is much more concise to read. Loading history...
313			$class == 'ModelAdmin' \|\|
314			is_subclass_of($class, 'TestOnly')
315			) {
316			//do nothing
317			} else {
318			$newList[$class] = $class;
319			}
320			}
321			$newList['tba'] = 'tba';
322			$this->_modelAdmins = $newList;
323			}
324
325			return $this->_modelAdmins;
326			}
327
328
329			public function SortOptions()
330			{
331			return [
332			'ASC' => 'ASC',
333			'DESC' => 'DESC'
334			];
335			}
336
337			protected $_canOptions = null;
338
339			public function CanOptions()
340			{
341			if(! $this->_canOptions) {
342			$ar = [
343			'true' => 'always',
344			'false' => 'never',
345			'parent' => 'use parent class',
346			];
347			$permissions = \Permission::get()->column('Code');
348			$ar = $ar + array_combine($permissions, $permissions);
349
350			$this->_canOptions = $ar;
351			}
352
353			return $this->_canOptions;
354			}
355
356
357			}
358

sunnysideup / silverstripe-dataobject-generator