+global\LampagerTransformer::transform()

Complexity

Conditions	2
Paths	1

Size

Total Lines

32

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	9
CRAP Score	2

Importance

Changes

0

1 Method

Rating	Name	Duplication	Size	Complexity
A		0	31	2

<?php

App::uses('LampagerArrayCursor', 'Lampager.Model');
App::uses('LampagerPaginator', 'Lampager.Model');
App::uses('Sqlite', 'Model/Datasource/Database');

use Lampager\Cursor;

The type Lampager\Cursor was not found. Maybe you did not declare it correctly or list all dependencies?

use Lampager\Query;
use Lampager\Query\Select;
use Lampager\Query\SelectOrUnionAll;
use Lampager\Query\UnionAll;
use Lampager\Query\ConditionGroup;

class LampagerTransformer
{
    /** @var LampagerPaginator */
    protected $paginator;

    public function __construct(LampagerPaginator $paginator)
    {
        $this->paginator = $paginator;
    }

    /**
     * Transform Query to CakePHP query.
     *
     * @param  Query $query Query.
     * @return array        Options for Model::find.
     */
    public function transform(Query $query)
    {
        $model = $this->paginator->builder;
        return [
            // Compiled by static::compileSelect
            'conditions' => null,

            // Compiled by static::compileLimit
            'limit' => null,

            // Sort the result set
            'order' => $this->compileOrderBy($query->selectOrUnionAll()),

            // Used along with ArrayProcessor
            'config' => $query,

            // Create subquery and inner join with it
            'joins' => array_merge(
                [
                    [
                        'type' => 'INNER',
                        'table' => $this->compileSelectOrUnionAll($query->selectOrUnionAll()),
                        'alias' => LampagerPaginator::class,
                        'conditions' => [
                            LampagerPaginator::class . ".{$model->primaryKey} = {$model->alias}.{$model->primaryKey}",
                        ],
                    ],
                ],
                $this->paginator->query['joins'] ?: []
            ),
        ] + $this->paginator->query;
    }

    /**
     * Build query from the cursor.
     *
     * @param  Cursor|int[]|string[] $cursor Cursor.
     * @return array                         Options for Model::find.
     */
    public function build($cursor = [])
    {
        return $this->transform($this->paginator->configure(new LampagerArrayCursor($this->paginator->builder, $cursor)));

It seems like $cursor can also be of type Lampager\Cursor; however, parameter $cursor of LampagerArrayCursor::__construct() does only seem to accept array, maybe add an additional type check?

    }

    /**
     * @param  SelectOrUnionAll $selectOrUnionAll
     * @return string
     */
    protected function compileSelectOrUnionAll(SelectOrUnionAll $selectOrUnionAll)
    {
        if ($selectOrUnionAll instanceof Select) {
            return '(' . $this->compileSelect($selectOrUnionAll) . ')';
        }

        if ($selectOrUnionAll instanceof UnionAll) {
            $supportQuery = $this->compileSelect($selectOrUnionAll->supportQuery());
            $mainQuery = $this->compileSelect($selectOrUnionAll->mainQuery());

            if ($this->paginator->builder->getDataSource() instanceof Sqlite) {
                return '(SELECT * FROM (' . $supportQuery . ') UNION ALL SELECT * FROM (' . $mainQuery . '))';
            }

            return '((' . $supportQuery . ') UNION ALL (' . $mainQuery . '))';
        }

        // @codeCoverageIgnoreStart
        throw new \LogicException('Unreachable here');
        // @codeCoverageIgnoreEnd
    }

    /**
     * @param  Select $select
     * @return string
     */
    protected function compileSelect(Select $select)
    {
        $model = $this->paginator->builder;
        $query = $this->paginator->query;

        /** @var DboSource $db */
        $db = $model->getDataSource();

        return $db->buildStatement([
            'limit' => $this->compileLimit($select),
            'order' => $this->compileOrderBy($select),
            'conditions' => array_merge_recursive(
                $this->compileWhere($select),
                $query['conditions'] ?: []
            ),
            'alias' => $model->alias,
            'table' => $db->fullTableName($model),
            'fields' => [
                $db->name("{$model->alias}.{$model->primaryKey}"),
            ],
        ], $model);
    }

    /**
     * @param  Select   $select
     * @return string[]
     */
    protected function compileWhere(Select $select)
    {
        $conditions = [];
        foreach ($select->where() as $group) {
            $conditions['OR'][] = iterator_to_array($this->compileWhereGroup($group));
        }
        return $conditions;
    }

    /**
     * @param  ConditionGroup     $group
     * @return \Generator<string,string>
     */
    protected function compileWhereGroup(ConditionGroup $group)
    {
        foreach ($group as $condition) {
            $column = $condition->left() . ' ' . $condition->comparator();
            $value = $condition->right();
            yield $column => $value;
        }
    }

    /**
     * @param  SelectOrUnionAll $selectOrUnionAll
     * @return string[]
     */
    protected function compileOrderBy(SelectOrUnionAll $selectOrUnionAll)
    {
        /** @var Select $select */
        if ($selectOrUnionAll instanceof Select) {
            $select = $selectOrUnionAll;
        }
        if ($selectOrUnionAll instanceof UnionAll) {
            $select = $selectOrUnionAll->mainQuery();
        }

        // @codeCoverageIgnoreStart
        if (!isset($select)) {
            throw new \LogicException('Unreachable here');
        }
        // @codeCoverageIgnoreEnd

        $orders = [];
        foreach ($select->orders() as $order) {

The variable $select does not seem to be defined for all execution paths leading up to this point.

            $orders[$order->column()] = $order->order();
        }
        return $orders;
    }

    /**
     * @param  Select $select
     * @return int
     */
    protected function compileLimit(Select $select)
    {
        return $select->limit()->toInteger();
    }
}