Backpack\CRUD\PanelTraits\Columns

Complexity

Total Complexity

38

Size/Duplication

Total Lines	287
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

55.34%

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	afterColumn()	0	4	1
A	beforeColumn()	0	4	1
A	addDefaultTypeToColumn()	0	10	2
A	addDefaultLabel()	0	10	3
A	removeColumn()	0	4	1
A	setColumnsDetails()	0	4	1
A	setColumnDetails()	0	4	1
A	setColumnLabel()	0	4	1
A	setColumnOrder()	0	4	1
A	setColumnsOrder()	0	4	1
A	getColumnsRelationships()	0	8	1
A	getColumns()	0	4	1
A	orderColumns()	0	4	1
A	remove()	0	6	1
B	setColumns()	0	32	6
B	addColumn()	0	25	5
A	addColumns()	0	8	3
A	moveColumn()	0	17	4
A	removeColumns()	0	8	3

<?php

namespace Backpack\CRUD\PanelTraits;

trait Columns
{
    // ------------
    // COLUMNS
    // ------------

    /**
     * Add a bunch of column names and their details to the CRUD object.
     *
     * @param [array or multi-dimensional array]
     */
    public function setColumns($columns)
    {
        // clear any columns already set
        $this->columns = [];

The property columns does not exist. Did you maybe forget to declare it?

        // if array, add a column for each of the items
        if (is_array($columns) && count($columns)) {
            foreach ($columns as $key => $column) {
                // if label and other details have been defined in the array
                if (is_array($column)) {
                    $this->addColumn($column);
                } else {
                    $this->addColumn([
                                    'name'  => $column,
                                    'label' => ucfirst($column),
                                    'type'  => 'text',
                                ]);
                }
            }
        }

        if (is_string($columns)) {
            $this->addColumn([
                                'name'  => $columns,
                                'label' => ucfirst($columns),
                                'type'  => 'text',
                                ]);
        }

        // This was the old setColumns() function, and it did not work:
        // $this->columns = array_filter(array_map([$this, 'addDefaultTypeToColumn'], $columns));

61% of this comment could be valid code. Did you maybe forget this after debugging?

    }

    /**
     * Add a column at the end of to the CRUD object's "columns" array.
     *
     * @param [string or array]
     */
    public function addColumn($column)
    {
        // if a string was passed, not an array, change it to an array
        if (! is_array($column)) {
            $column = ['name' => $column];
        }

        // make sure the column has a label
        $column_with_details = $this->addDefaultLabel($column);

        // make sure the column has a name
        if (! array_key_exists('name', $column_with_details)) {
            $column_with_details['name'] = 'anonymous_column_'.str_random(5);
        }

        array_filter($this->columns[$column_with_details['name']] = $column_with_details);

        // if this is a relation type field and no corresponding model was specified, get it from the relation method
        // defined in the main model
        if (isset($column_with_details['entity']) && ! isset($column_with_details['model'])) {
            $column_with_details['model'] = $this->getRelationModel($column_with_details['entity']);

It seems like getRelationModel() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        }

        return $this;
    }

    /**
     * Add multiple columns at the end of the CRUD object's "columns" array.
     *
     * @param [array of columns]
     */
    public function addColumns($columns)
    {
        if (count($columns)) {
            foreach ($columns as $key => $column) {
                $this->addColumn($column);
            }
        }
    }

    /**
     * Move the most recently added column after the given target column.
     *
     * @param string|array $targetColumn The target column name or array.
     */
    public function afterColumn($targetColumn)
    {
        $this->moveColumn($targetColumn, false);
    }

    /**
     * Move the most recently added column before the given target column.
     *
     * @param string|array $targetColumn The target column name or array.
     */
    public function beforeColumn($targetColumn)
    {
        $this->moveColumn($targetColumn);
    }

    /**
     * Move the most recently added column before or after the given target column. Default is before.
     *
     * @param string|array $targetColumn The target column name or array.
     * @param bool $before If true, the column will be moved before the target column, otherwise it will be moved after it.

This line exceeds maximum limit of 120 characters; contains 123 characters

     */
    private function moveColumn($targetColumn, $before = true)
    {
        // TODO: this and the moveField method from the Fields trait should be refactored into a single method and moved
        //       into a common class
        $targetColumnName = is_array($targetColumn) ? $targetColumn['name'] : $targetColumn;

        if (array_key_exists($targetColumnName, $this->columns)) {
            $targetColumnPosition = $before ? array_search($targetColumnName, array_keys($this->columns)) :
                array_search($targetColumnName, array_keys($this->columns)) + 1;

            $element = array_pop($this->columns);
            $beginningPart = array_slice($this->columns, 0, $targetColumnPosition, true);
            $endingArrayPart = array_slice($this->columns, $targetColumnPosition, null, true);

            $this->columns = array_merge($beginningPart, [$element['name'] => $element], $endingArrayPart);
        }
    }

    /**
     * Add the default column type to the given Column, inferring the type from the database column type.
     *
     * @param [column array]
     */
    public function addDefaultTypeToColumn($column)
    {
        if (array_key_exists('name', (array) $column)) {
            $default_type = $this->getFieldTypeFromDbColumnType($column['name']);

It seems like getFieldTypeFromDbColumnType() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            return array_merge(['type' => $default_type], $column);
        }

        return false;
    }

    /**
     * If a field or column array is missing the "label" attribute, an ugly error would be show.
     * So we add the field Name as a label - it's better than nothing.
     *
     * @param [field or column]
     */
    public function addDefaultLabel($array)

The return type could not be reliably inferred; please add a @return annotation.

    {
        if (! array_key_exists('label', (array) $array) && array_key_exists('name', (array) $array)) {
            $array = array_merge(['label' => ucfirst($this->makeLabel($array['name']))], $array);

It seems like makeLabel() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            return $array;
        }

        return $array;
    }

    /**
     * Remove a column from the CRUD panel by name.
     *
     * @param string $column The column name.
     */
    public function removeColumn($column)
    {
        array_forget($this->columns, $column);
    }

    /**
     * Remove multiple columns from the CRUD panel by name.
     *
     * @param array $columns Array of column names.
     */
    public function removeColumns($columns)
    {
        if (! empty($columns)) {
            foreach ($columns as $columnName) {
                $this->removeColumn($columnName);
            }
        }
    }

    /**
     * Remove an entry from an array.
     *
     * @param string $entity
     * @param array $fields
     * @return array values
     *
     * @deprecated This method is no longer used by internal code and is not recommended as it does not preserve the
     *             target array keys.
     * @see Columns::removeColumn() to remove a column from the CRUD panel by name.
     * @see Columns::removeColumns() to remove multiple columns from the CRUD panel by name.
     */
    public function remove($entity, $fields)
    {
        return array_values(array_filter($this->{$entity}, function ($field) use ($fields) {
            return ! in_array($field['name'], (array) $fields);
        }));
    }

    /**
     * Change attributes for multiple columns.
     *
     * @param [columns arrays]
     * @param [attributes and values array]
     */
    public function setColumnsDetails($columns, $attributes)
    {
        $this->sync('columns', $columns, $attributes);

It seems like sync() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Change attributes for a certain column.
     *
     * @param [string] Column name.
     * @param [attributes and values array]
     */
    public function setColumnDetails($column, $attributes)
    {
        $this->setColumnsDetails([$column], $attributes);
    }

    /**
     * Set label for a specific column.
     *
     * @param string $column
     * @param string $label
     */
    public function setColumnLabel($column, $label)
    {
        $this->setColumnDetails($column, ['label' => $label]);
    }

    /**
     * Order the columns in a certain way.
     *
     * @param [string] Column name.
     * @param [attributes and values array]
     */
    public function setColumnOrder($columns)

The parameter $columns is not used and could be removed.

    {
        // TODO
    }

    // ALIAS of setColumnOrder($columns)
    public function setColumnsOrder($columns)
    {
        $this->setColumnOrder($columns);
    }

    /**
     * Get the relationships used in the CRUD columns.
     * @return [array] Relationship names

The doc-type [array] could not be parsed: Unknown type name "" at position 0. [(view supported doc-types)

     */
    public function getColumnsRelationships()
    {
        $columns = $this->getColumns();

        return collect($columns)->pluck('entity')->reject(function ($value, $key) {

The parameter $key is not used and could be removed.

            return $value == null;
        })->toArray();
    }

    // ------------
    // TONE FUNCTIONS - UNDOCUMENTED, UNTESTED, SOME MAY BE USED
    // ------------
    // TODO: check them

    public function getColumns()

The return type could not be reliably inferred; please add a @return annotation.

    {
        return $this->sort('columns');

It seems like sort() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    public function orderColumns($order)
    {
        $this->setSort('columns', (array) $order);

It seems like setSort() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }
}