ElementList

Complexity

Total Complexity

17

Size/Duplication

Total Lines	152
Duplicated Lines	23.03 %

Coupling/Cohesion

Components	1
Dependencies	14

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
B	getCMSFields()	0	57	5
D	getAvailableTypes()	35	46	10
A	WidgetControllers()	0	12	2

<?php

/**
 * A list contains nested {@link BaseElement} such as a list of related files.
 *
 * @package elemental
 */
class ElementList extends BaseElement

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

{

    private static $db = array(

Consider using a different property name as you override a private property of the parent class.

The property $db is not used and could be removed.

        'ListDescription' => 'HTMLText'
    );

    private static $has_many = array(

Consider using a different property name as you override a private property of the parent class.

The property $has_many is not used and could be removed.

        'Elements' => 'BaseElement'
    );

    private static $duplicate_relations = array(

The property $duplicate_relations is not used and could be removed.

        'Elements'
    );

    private static $title = "Element List Element";

Consider using a different property name as you override a private property of the parent class.

The property $title is not used and could be removed.

    private static $description = "Orderable list of elements";

Consider using a different property name as you override a private property of the parent class.

The property $description is not used and could be removed.

    private static $enable_title_in_template = true;

Consider using a different property name as you override a private property of the parent class.

The property $enable_title_in_template is not used and could be removed.

    /**
     * @return FieldList
     */
    public function getCMSFields()
    {
        $elements = $this->Elements();

The method Elements() does not exist on ElementList. Did you maybe mean all_allowed_elements()?

        $isInDb = $this->isInDB();

        $this->beforeUpdateCMSFields(function ($fields) use ($elements, $isInDb) {
            $fields->removeByName('Root.Elements');
            $fields->removeByName('Elements');

            $desc = HTMLEditorField::create('ListDescription', 'List Description');
            $desc->setRightTitle('Optional');
            $fields->addFieldToTab('Root.Main', $desc);

            if ($isInDb) {
                $adder = new ElementalGridFieldAddNewMultiClass('buttons-before-left');

                $list = $this->getAvailableTypes();

                if($list) {

The expression $list of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                    $adder->setClasses($list);
                }

                $config = GridFieldConfig_RecordEditor::create(100);
                $config->addComponent(new GridFieldSortableRows('Sort'));
                $config->removeComponentsByType('GridFieldAddNewButton');
                $config->removeComponentsByType('GridFieldSortableHeader');
                $config->removeComponentsByType('GridFieldDeleteAction');
                $config->removeComponentsByType('GridFieldAddExistingAutocompleter');
                $config->addComponent(new GridFieldTitleHeader());
                $config->addComponent($adder);
                $config->addComponent($autocompleter = new ElementalGridFieldAddExistingAutocompleter('buttons-before-right'));

                if ($this->owner->canDelete()) {

The property owner does not exist on object<ElementList>. Since you implemented __get, maybe consider adding a @property annotation.

                    $config->addComponent(new ElementalGridFieldDeleteAction());
                }

                if($list) {

The expression $list of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                    $autocompleter->setSearchList(
                        BaseElement::get()->filter('ClassName', array_keys($list))
                    );
                }

                $widgetArea = new GridField(
                    'Elements',
                    Config::inst()->get("ElementPageExtension", 'elements_title'),
                    $elements,
                    $config
                );

                $fields->addFieldToTab('Root.Main', $widgetArea);
            } else {
                $fields->addFieldToTab('Root.Main', LiteralField::create('warn', '<p class="message notice">Once you save this object you will be able to add items</p>'));
            }
        });

        return parent::getCMSFields();
    }

    /**
     * @return array
     */
    public function getAvailableTypes() {
        if (is_array($this->config()->get('allowed_elements'))) {
            $list = $this->config()->get('allowed_elements');

            if($this->config()->get('sort_types_alphabetically') !== false) {

This code seems to be duplicated across your project.

                $sorted = array();

                foreach ($list as $class) {
                    $inst = singleton($class);

                    if ($inst->canCreate()) {
                        $sorted[$class] = singleton($class)->i18n_singular_name();
                    }
                }

                $list = $sorted;
                asort($list);
            }
        } else {

This code seems to be duplicated across your project.

            $classes = ClassInfo::subclassesFor('BaseElement');
            $list = array();
            unset($classes['BaseElement']);

            $disallowedElements = (array) $this->config()->get('disallowed_elements');

            if (!in_array('ElementVirtualLinked', $disallowedElements)) {
                array_push($disallowedElements, 'ElementVirtualLinked');
            }

            foreach ($classes as $class) {

The expression $classes of type null|array is not guaranteed to be traversable. How about adding an additional type check?

                $inst = singleton($class);

                if (!in_array($class, $disallowedElements) && $inst->canCreate()) {
                    $list[$class] = singleton($class)->i18n_singular_name();
                }
            }

            asort($list);
        }

        if (method_exists($this, 'sortElementalOptions')) {
            $this->sortElementalOptions($list);

The method sortElementalOptions does not exist on object<ElementList>? Since you implemented __call, maybe consider adding a @method annotation.

        }

        return $list;
    }

    /**
     * Used in template instead of {@link Widgets()} to wrap each widget in its
     * controller, making it easier to access and process form logic and
     * actions stored in {@link WidgetController}.
     *
     * @return SS_List - Collection of {@link WidgetController} instances.
     */
    public function WidgetControllers() {
        $controllers = new ArrayList();

        foreach($this->Elements()->filter('Enabled', 1) as $widget) {

The method Elements() does not exist on ElementList. Did you maybe mean all_allowed_elements()?

            $controller = $widget->getController();

            $controller->init();
            $controllers->push($controller);
        }

        return $controllers;
    }
}