Foo\Grid\Factory

Complexity

Total Complexity

11

Size/Duplication

Total Lines	121
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
B	createGrid()	0	27	2
A	createTableBody()	0	21	3
A	createTableRowCell()	0	15	3
A	createTableHeader()	0	13	3

<?php

declare(strict_types = 1);

namespace Foo\Grid;

use Foo\Grid\Cell\Cell;
use Foo\Grid\Collection\Actions;
use Foo\Grid\Collection\Cells;
use Foo\Grid\Collection\Rows;
use Foo\Grid\Row\Row;
use Foo\Grid\Table\Table;
use Foo\Translate\ITranslator;
use Opulence\Orm\IEntity;

class Factory
{
    const CELL_ACTIONS_CONTENT = 'grid:actions';
    const CELL_ACTIONS_GROUP   = 'actions';

    /**
     * @param array            $entities
     * @param array            $getters
     * @param array            $headers
     * @param array            $headerAttributes
     * @param array            $bodyAttributes
     * @param array            $tableAttributes
     * @param array            $gridAttributes
     * @param Actions|null     $cellActions
     * @param Actions|null     $gridActions
     * @param ITranslator|null $translator
     *
     * @return Grid
     */
    public static function createGrid(
        array $entities,
        array $getters,
        array $headers,
        array $headerAttributes = [],
        array $bodyAttributes = [],
        array $tableAttributes = [],
        array $gridAttributes = [],
        Actions $cellActions = null,
        Actions $gridActions = null,
        ITranslator $translator = null
    ) {
        $tableBody   = static::createTableBody($entities, $getters, $bodyAttributes, $cellActions);

Since createTableBody() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of createTableBody() to at least protected.

        $tableHeader = static::createTableHeader($headers, $headerAttributes, $cellActions);

Since createTableHeader() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of createTableHeader() to at least protected.

        $table = new Table($tableBody, $tableHeader, $tableAttributes);

It seems like $tableBody defined by static::createTableBody($entities, $getters, $bodyAttributes, $cellActions) on line 47 can also be of type array; however, Foo\Grid\Table\Table::__construct() does only seem to accept object<Foo\Grid\Collection\Rows>, maybe add an additional type check?

It seems like $tableHeader defined by static::createTableHeader($headers, $headerAttributes, $cellActions) on line 48 can also be of type array; however, Foo\Grid\Table\Table::__construct() does only seem to accept object<Foo\Grid\Collection\Cells>, maybe add an additional type check?

        $grid = new Grid($table, null, $gridActions, $gridAttributes);

        $grid->setIndentation(8);

        if ($translator) {
            $grid->setTranslator($translator);
        }

        return $grid;
    }

    /**
     * @param array        $entities
     * @param array        $getters
     * @param array        $bodyAttributes
     * @param Actions|null $actions
     *
     * @return array|Rows
     */
    private static function createTableBody(
        array $entities,
        array $getters,
        array $bodyAttributes = [],
        Actions $actions = null
    ) {
        $tableBody = new Rows();

        foreach ($entities as $entity) {
            $cells = static::createTableRowCell($getters, $bodyAttributes, $entity);

Since createTableRowCell() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of createTableRowCell() to at least protected.

            $rowActions = $actions ? $actions->duplicate() : null;

            $row = new Row($cells, $rowActions);

It seems like $cells defined by static::createTableRowCell($getters, $bodyAttributes, $entity) on line 80 can also be of type array; however, Foo\Grid\Row\Row::__construct() does only seem to accept object<Foo\Grid\Collection\Cells>, maybe add an additional type check?

            $row->setEntity($entity);

            $tableBody[] = $row;
        }

        return $tableBody;
    }

    /**
     * @param array   $getters
     * @param array   $bodyAttributes
     * @param IEntity $entity
     *
     * @return array|Cells
     */
    private static function createTableRowCell(
        array $getters,
        array $bodyAttributes,
        IEntity $entity
    ) {
        $cells = new Cells();

        foreach ($getters as $group => $getter) {
            $content = is_callable($getter) ? $getter($entity) : (string)$entity->$getter();

            $cells[] = new Cell($content, $group, $bodyAttributes, Cell::BODY);
        }

        return $cells;
    }

    /**
     * @param array        $headers
     * @param array        $headerAttributes
     * @param Actions|null $actions
     *
     * @return array|Cells
     */
    private static function createTableHeader(array $headers, array $headerAttributes = [], Actions $actions = null)
    {
        $cells = new Cells(Cells::HEAD);
        foreach ($headers as $group => $content) {
            $cells[] = new Cell($content, $group, $headerAttributes, Cell::HEAD);
        }

        if ($actions) {
            $cells[] = new Cell(static::CELL_ACTIONS_CONTENT, static::CELL_ACTIONS_GROUP, [], Cell::HEAD);
        }

        return $cells;
    }
}