Mado\QueryBundle\Objects\Filter

Complexity

Total Complexity

13

Size/Duplication

Total Lines	110
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	box()	0	13	1
A	getFieldAndOperator()	0	3	1
A	getPath()	0	3	1
A	getOperator()	0	3	1
A	__construct()	0	6	1
A	buildRawFilter()	0	3	1
A	getField()	0	7	1
A	withFullPath()	0	12	1
A	getIds()	0	3	1
A	withPath()	0	13	2
A	getValue()	0	3	1
A	fromQueryStringFilter()	0	7	1

<?php

namespace Mado\QueryBundle\Objects;

class Filter
{
    private $rawFilter;

    private $ids;

    private $operator;

    public static function box(array $params)
    {
        $rawIds    = $params['ids'];
        $path      = $params['path'];

        $operator  = key($rawIds);
        $ids       = join(',', current($rawIds));

        return new self([
            'raw_filter' => self::buildRawFilter($path, $operator),
            'ids'        => $ids,
            'operator'   => $operator,
            'path'       => $path,
        ]);
    }

    private static function buildRawFilter($path, $operator)
    {
        return $path . '.id|' . $operator;
    }

    private function __construct(array $params)
    {
        $this->rawFilter = $params['raw_filter'];
        $this->ids       = $params['ids'];
        $this->operator  = $params['operator'];
        $this->path      = $params['path'];

The property path does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

    }

    public function getFieldAndOperator()
    {
        return $this->rawFilter;
    }

    public function getIds()
    {
        return $this->ids;
    }

    public function getOperator()
    {
        return $this->operator;
    }

    public function getPath()
    {
        return $this->path;
    }

    public function withPath($path)
    {
        $rawFilter = self::buildRawFilter($path, $this->operator);

        if ($path == '') {
            $rawFilter = str_replace('.', '', $rawFilter);
        }

        return new self([
            'raw_filter' => $rawFilter,
            'ids'        => $this->ids,
            'operator'   => $this->operator,
            'path'       => $path,
        ]);
    }

    public function withFullPath($path)
    {
        $explodedPath = explode('|', $path);

        $path = $explodedPath[0];
        $operator = $explodedPath[1];

        return new self([
            'raw_filter' => join('|', $explodedPath),
            'ids'        => $this->ids,
            'operator'   => $operator,
            'path'       => $path,
        ]);
    }

    public function getField()
    {
        $explodedPath = explode('|', $this->getFieldAndOperator());

        $field = $explodedPath[0];

        return $field;
    }

    public static function fromQueryStringFilter(array $params)
    {
        return new self([
            'raw_filter' => key($params),
            'ids' => current($params),
            'operator' => explode('|', key($params))[1],
            'path' => null,
        ]);
    }

    public function getValue()
    {
        return $this->ids;
    }
}