API::MyAllFieldsWithoutBelongs() - Code Metrics - sunnysideup/silverstripe-dataobject-generator - Measure and Improve Code Quality continuously with Scrutinizer

API::MyAllFieldsWithoutBelongs() A
last analyzed 2018-04-27 01:15 UTC

↳ Parent: API

Complexity

Conditions	3
Paths	4

Size

Total Lines	16
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	16
rs	9.4285
c	0
b	0
f	0
cc	3
eloc	11
nc	4
nop	1

<?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));
                } elseif (substr($class, 0, 3) == 'SS_') {
                    $class = substr($class, 3, strlen($class));
                } elseif ('Varchar' === $class) {
                    $class = 'Varchar';
                } elseif ('HTMLVarchar' === $class) {
                    $class = 'HTMLVarchar(255)';
                } elseif ('Enum' === $class) {
                    $class = 'Enum(\\\'Foo,Bar\\\', \\\'FOO\\\')';
                } elseif ('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;
                }
            }
            $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.'.CMSThumbnail'] = $key.'.CMSThumbnail';
            } 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;
        }
        $list =
            [$rootClass => $rootClass] +
            $this->possibleRelations();
        asort($list);

        return $list;
    }

    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 = [
                'one' => 'only one (useful for can create)',
                '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

API::MyAllFieldsWithoutBelongs() A last analyzed 2018-04-27 01:15 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like

API::MyAllFieldsWithoutBelongs() A
last analyzed 2018-04-27 01:15 UTC