Noitran\RQL\Parsers\Request\Illuminate\RequestParser

Complexity

Total Complexity

23

Size/Duplication

Total Lines	199
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	parseColumn()	0	9	2
A	__construct()	0	5	1
A	getQueryParameter()	0	3	1
A	parseExpression()	0	7	2
A	isValidDataType()	0	11	3
A	extractValue()	0	7	2
A	parse()	0	11	1
A	getAttributes()	0	3	1
A	init()	0	5	1
A	parseDataType()	0	17	3
A	parseRelation()	0	9	2
A	parseValue()	0	11	3
A	setQueryParameterName()	0	5	1

<?php

declare(strict_types=1);

namespace Noitran\RQL\Parsers\Request\Illuminate;

use Illuminate\Http\Request;
use Illuminate\Support\Str;
use Noitran\RQL\Exceptions\RuntimeException;
use Noitran\RQL\Parsers\AbstractParser;
use Noitran\RQL\Parsers\Model;

/**
 * Class RequestParser.
 */
class RequestParser extends AbstractParser
{
    /**
     * @var string
     */
    protected $queryParameterName;

    /**
     * @var Request
     */
    protected $request;

    /**
     * RequestParser constructor.
     *
     * @param Request $request
     */
    public function __construct(Request $request)
    {
        $this->request = $request;

        $this->init();
    }

    /**
     * @return RequestParser
     */
    public function init(): self
    {
        $this->setQueryParameterName();

        return $this;
    }

    /**
     * @return array
     */
    public function getAttributes(): array
    {
        return $this->request->toArray();
    }

    /**
     * @return RequestParser
     */
    public function setQueryParameterName(): self
    {
        $this->queryParameterName = config('rql.parsers.default_query_parameter', 'filter');

        return $this;
    }

    /**
     * @return string|array|null
     */
    public function getQueryParameter()
    {
        return $this->request->input($this->queryParameterName);
    }

    /**
     * @return mixed
     */
    public function parse(): Model
    {
        $model = new Model();

        $model->setRelation($this->parseRelation($this->filterParameter));

It seems like $this->parseRelation($this->filterParameter) can also be of type null; however, parameter $relation of Noitran\RQL\Parsers\Model::setRelation() does only seem to accept string, maybe add an additional type check?

The property filterParameter does not exist on Noitran\RQL\Parsers\Request\Illuminate\RequestParser. Did you maybe forget to declare it?

        $model->setField($this->parseColumn($this->filterParameter));
        $model->setExpression($this->parseExpression($this->filterValue));

The property filterValue does not exist on Noitran\RQL\Parsers\Request\Illuminate\RequestParser. Did you maybe forget to declare it?

        $model->setDataType($this->parseDataType($this->filterValue));
        $model->setValue($this->parseValue($this->filterValue));

        return $model;
    }

    /**
     * @param $filterParameter
     *
     * @return string|null
     */
    protected function parseRelation($filterParameter): ?string
    {
        if (false !== strpos($filterParameter, '.')) {
            $lastDotPosition = strrpos($filterParameter, '.');

            return substr($filterParameter, 0, $lastDotPosition);
        }

        return null;
    }

    /**
     * @param $filterParameter
     *
     * @return string
     */
    protected function parseColumn($filterParameter): string
    {
        if (false !== strpos($filterParameter, '.')) {
            $lastDotPosition = strrpos($filterParameter, '.');

            return substr($filterParameter, $lastDotPosition + 1);
        }

        return $filterParameter;
    }

    /**
     * @param $filterValue
     *
     * @return string
     */
    protected function parseExpression($filterValue): string
    {
        if (! \is_array($filterValue)) {
            return config('repositories.filtering.default_expression', '$eq');
        }

        return key($filterValue);

The expression return key($filterValue) could return the type null which is incompatible with the type-hinted return string. Consider adding an additional type-check to rule them out.

    }

    /**
     * @param $filterValue
     *
     * @throws RuntimeException
     *
     * @return string
     */
    protected function parseDataType($filterValue): string
    {
        $value = $this->extractValue($filterValue);

        if (false !== strpos($value, ':')) {
            $lastColonPosition = strpos($value, ':');

            $parsedDataType = substr($value, 0, $lastColonPosition);

            if (! $this->isValidDataType($parsedDataType)) {
                return config('repositories.filtering.default_data_type', '$string');
            }

            return $parsedDataType;
        }

        return config('repositories.filtering.default_data_type', '$string');
    }

    /**
     * @param $filterValue
     *
     * @return string
     */
    protected function parseValue($filterValue): string
    {
        $value = $this->extractValue($filterValue);

        if (Str::startsWith($value, ['$']) && false !== strpos($value, ':')) {
            $lastColonPosition = strpos($value, ':');

            return substr($value, $lastColonPosition + 1);
        }

        return $value;
    }

    /**
     * @param $filterValue
     *
     * @return string
     */
    private function extractValue($filterValue): string
    {
        if (! \is_array($filterValue)) {
            return $filterValue;
        }

        return array_shift($filterValue);
    }

    /**
     * @param $dataType
     * @param bool $strict
     *
     * @throws RuntimeException
     *
     * @return bool
     */
    private function isValidDataType($dataType, $strict = false): bool
    {
        if (! \in_array($dataType, config('repositories.filtering.allowed_data_types', '$string'), true)) {
            if ($strict) {
                throw new RuntimeException('Invalid/Unallowed data type passed.');
            }

            return false;
        }

        return true;
    }
}