Recca0120\Repository\Compilers\CollectionCompiler

Complexity

Total Complexity

33

Size/Duplication

Total Lines	190
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	3

Test Coverage

Coverage

77.78%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	having()	0	4	1
A	with()	0	4	1
A	join()	0	4	1
A	select()	0	4	1
A	compileParameters()	0	4	1
D	where()	0	40	9
A	order()	0	10	2
C	checkOperator()	0	27	11
B	orderComparer()	0	21	6

<?php

namespace Recca0120\Repository\Compilers;

use BadMethodCallException;
use Illuminate\Support\Arr;
use Recca0120\Repository\Expression;

class CollectionCompiler extends Compiler
{
    /**
     * where.
     *
     * @param mixed $model
     * @param array $actions
     * @return mixed
     */
    public function where($model, $actions)
    {
        $filters = [];
        foreach ($actions as $action) {
            $method = $action['method'];
            $parameters = $action['parameters'];
            if (count($parameters) === 3) {
                list($key, $operator, $value) = $parameters;
            } else {
                list($key, $value) = $parameters;
                $operator = '=';
            }
            if ($value instanceof Expression) {
                $value = $value->getValue();
            }

            $filters[$method][] = [$key, $operator, $value];
        }

        $model = $model->filter(function ($item) use ($filters) {
            foreach ($filters as $method => $rules) {
                switch ($method) {
                    case 'where':
                    case 'having':
                        foreach ($rules as $parameters) {
                            if ($this->checkOperator($item, $parameters) === false) {
                                return false;
                            }
                        }
                        break;
                    default:
                        throw new BadMethodCallException('Call to undefined method '.static::class."::{$method}()");
                }
            }

            return true;
        });

        return $model;
    }

    /**
     * having.
     *
     * @param mixed $model
     * @param array $actions
     * @return mixed
     */
    public function having($model, $actions)
    {
        return $this->where($model, $actions);
    }

    /**
     * order.
     *
     * @param mixed $model
     * @param array $actions
     * @return mixed
     */
    public function order($model, $actions)
    {
        $sort = [];
        foreach ($actions as $action) {
            $parameters = $action['parameters'];
            $sort[$parameters[0]] = Arr::get($parameters, 1, 'asc');
        }

        return $model->sort($this->orderComparer($sort));
    }

    /**
     * with.
     *
     * @param mixed $model
     * @param array $actions
     * @return mixed
     */
    public function with($model, $actions)

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

    {
        return $model;
    }

    /**
     * join.
     *
     * @param mixed $model
     * @param array $actions
     * @return mixed
     */
    public function join($model, $actions)

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

    {
        return $model;
    }

    /**
     * select.
     *
     * @param mixed $model
     * @param array $actions
     * @return mixed
     */
    public function select($model, $actions)

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

    {
        return $model;
    }

    /**
     * checkOperator.
     *
     * @param mixed$item
     * @param array $parameters
     * @return bool
     */
    protected function checkOperator($item, $parameters)
    {
        list($key, $operator, $value) = $parameters;
        $retrieved = $item[$key];
        switch ($operator) {
            case '=':
            case '==':
                return $retrieved == $value;
            case '!=':
            case '<>':
                return $retrieved != $value;
            case '<':
                return $retrieved < $value;
            case '>':
                return $retrieved > $value;
            case '<=':
                return $retrieved <= $value;
            case '>=':
                return $retrieved >= $value;
            case '===':
                return $retrieved === $value;
            case '!==':
                return $retrieved !== $value;
        }

        return false;
    }

    /**
     * orderComparer.
     *
     * @param array $sort
     * @return \Closure
     */
    protected function orderComparer($sort)
    {
        return function ($first, $second) use ($sort) {
            foreach ($sort as $key => $orderType) {
                // normalize sort direction
                $orderType = strtolower($orderType);
                $value1 = data_get($first, $key);
                $value2 = data_get($second, $key);

                if ($value1 < $value2) {
                    return $orderType === 'asc' ? -1 : 1;
                }

                if ($value1 > $value2) {
                    return $orderType === 'asc' ? 1 : -1;
                }
            }
            // all elements were equal
            return 0;
        };
    }

    /**
     * compileParameters.
     *
     * @param array $parameters
     * @return array
     */
    protected function compileParameters($parameters)
    {
        return $parameters;
    }
}