StringFilter::getExpression() - Code Metrics - Inspection of "Merge pull request #4448 from kielabokkie/add-miss..." - pamil/Sylius - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( cec9f3...d27170 )

by Kamil

created 2016-03-10 15:03 UTC

StringFilter::getExpression() D

↳ Parent: StringFilter

Complexity

Conditions	10
Paths	10

Size

Total Lines	32
Code Lines	29

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	32
rs	4.8196
cc	10
eloc	29
nc	10
nop	4

How to fix Complexity

<?php

/*
 * This file is part of the Sylius package.
 *
 * (c) Paweł Jędrzejewski
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Sylius\Component\Grid\Filter;

use Sylius\Component\Grid\Data\DataSourceInterface;
use Sylius\Component\Grid\Data\ExpressionBuilderInterface;
use Sylius\Component\Grid\Filtering\FilterInterface;

/**
 * @author Paweł Jędrzejewski <[email protected]>
 */
class StringFilter implements FilterInterface
{
    const NAME = 'string';

    const TYPE_EQUAL = 'equal';
    const TYPE_EMPTY = 'empty';
    const TYPE_NOT_EMPTY = 'not_empty';
    const TYPE_CONTAINS = 'contains';
    const TYPE_NOT_CONTAINS = 'not_contains';
    const TYPE_STARTS_WITH = 'starts_with';
    const TYPE_ENDS_WITH = 'ends_with';
    const TYPE_IN = 'in';
    const TYPE_NOT_IN = 'not_in';

    /**
     * {@inheritdoc}
     */
    public function apply(DataSourceInterface $dataSource, $name, $data, array $options)
    {
        $expressionBuilder = $dataSource->getExpressionBuilder();

        if (!is_array($data)) {
            $data = ['type' => self::TYPE_CONTAINS, 'value' => $data];
        }

        $fields = array_key_exists('fields', $options) ? $options['fields'] : [$name];

        $type = $data['type'];
        $value = array_key_exists('value', $data) ? $data['value'] : null;

        if (1 === count($fields)) {
            $expression = $this->getExpression($expressionBuilder, $type, $name, $value);
        } else {
            $expressions = [];

            foreach ($fields as $field) {
                $expressions[] = $this->getExpression($expressionBuilder, $type, $field, $value);
            }

            $expression = $expressionBuilder->orX($expressions);
        }

        $dataSource->restrict($expression);
    }

    /**
     * @param string $type
     * @param string $field
     * @param mixed  $value
     */
    private function getExpression(ExpressionBuilderInterface $expressionBuilder, $type, $field, $value)
    {
        switch ($type) {
            case self::TYPE_EQUAL:
                return $expressionBuilder->equals($field, $value);
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case self::TYPE_EMPTY:
                return $expressionBuilder->isNull($field);
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case self::TYPE_NOT_EMPTY:
                return $expressionBuilder->isNotNull($field);
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case self::TYPE_CONTAINS:
                return $expressionBuilder->like($field, '%'.$value.'%');
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case self::TYPE_NOT_CONTAINS:
                return $expressionBuilder->notLike($field, '%'.$value.'%');
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case self::TYPE_STARTS_WITH:
                return $expressionBuilder->like($field, $value.'%');
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case self::TYPE_ENDS_WITH:
                return $expressionBuilder->like($field, '%'.$value);
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case self::TYPE_IN:
                return $expressionBuilder->in($field, array_map('trim', explode(',', $value)));
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case self::TYPE_NOT_IN:
                return $expressionBuilder->notIn($field, array_map('trim', explode(',', $value)));
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
        }
    }
}


1			<?php
2
3			/*
4			* This file is part of the Sylius package.
5			*
6			* (c) Paweł Jędrzejewski
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Sylius\Component\Grid\Filter;
13
14			use Sylius\Component\Grid\Data\DataSourceInterface;
15			use Sylius\Component\Grid\Data\ExpressionBuilderInterface;
16			use Sylius\Component\Grid\Filtering\FilterInterface;
17
18			/**
19			* @author Paweł Jędrzejewski <[email protected]>
20			*/
21			class StringFilter implements FilterInterface
22			{
23			const NAME = 'string';
24
25			const TYPE_EQUAL = 'equal';
26			const TYPE_EMPTY = 'empty';
27			const TYPE_NOT_EMPTY = 'not_empty';
28			const TYPE_CONTAINS = 'contains';
29			const TYPE_NOT_CONTAINS = 'not_contains';
30			const TYPE_STARTS_WITH = 'starts_with';
31			const TYPE_ENDS_WITH = 'ends_with';
32			const TYPE_IN = 'in';
33			const TYPE_NOT_IN = 'not_in';
34
35			/**
36			* {@inheritdoc}
37			*/
38			public function apply(DataSourceInterface $dataSource, $name, $data, array $options)
39			{
40			$expressionBuilder = $dataSource->getExpressionBuilder();
41
42			if (!is_array($data)) {
43			$data = ['type' => self::TYPE_CONTAINS, 'value' => $data];
44			}
45
46			$fields = array_key_exists('fields', $options) ? $options['fields'] : [$name];
47
48			$type = $data['type'];
49			$value = array_key_exists('value', $data) ? $data['value'] : null;
50
51			if (1 === count($fields)) {
52			$expression = $this->getExpression($expressionBuilder, $type, $name, $value);
53			} else {
54			$expressions = [];
55
56			foreach ($fields as $field) {
57			$expressions[] = $this->getExpression($expressionBuilder, $type, $field, $value);
58			}
59
60			$expression = $expressionBuilder->orX($expressions);
61			}
62
63			$dataSource->restrict($expression);
64			}
65
66			/**
67			* @param string $type
68			* @param string $field
69			* @param mixed $value
70			*/
71			private function getExpression(ExpressionBuilderInterface $expressionBuilder, $type, $field, $value)
72			{
73			switch ($type) {
74			case self::TYPE_EQUAL:
75			return $expressionBuilder->equals($field, $value);
76			break;
			0 ignored issues – show Unused Code introduced 2016-03-10 15:25 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
77			case self::TYPE_EMPTY:
78			return $expressionBuilder->isNull($field);
79			break;
			0 ignored issues – show Unused Code introduced 2016-03-10 15:25 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
80			case self::TYPE_NOT_EMPTY:
81			return $expressionBuilder->isNotNull($field);
82			break;
			0 ignored issues – show Unused Code introduced 2016-03-10 15:25 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
83			case self::TYPE_CONTAINS:
84			return $expressionBuilder->like($field, '%'.$value.'%');
85			break;
			0 ignored issues – show Unused Code introduced 2016-03-10 15:25 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
86			case self::TYPE_NOT_CONTAINS:
87			return $expressionBuilder->notLike($field, '%'.$value.'%');
88			break;
			0 ignored issues – show Unused Code introduced 2016-03-10 15:25 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
89			case self::TYPE_STARTS_WITH:
90			return $expressionBuilder->like($field, $value.'%');
91			break;
			0 ignored issues – show Unused Code introduced 2016-03-10 15:25 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
92			case self::TYPE_ENDS_WITH:
93			return $expressionBuilder->like($field, '%'.$value);
94			break;
			0 ignored issues – show Unused Code introduced 2016-03-10 15:25 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
95			case self::TYPE_IN:
96			return $expressionBuilder->in($field, array_map('trim', explode(',', $value)));
97			break;
			0 ignored issues – show Unused Code introduced 2016-03-10 15:25 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
98			case self::TYPE_NOT_IN:
99			return $expressionBuilder->notIn($field, array_map('trim', explode(',', $value)));
100			break;
			0 ignored issues – show Unused Code introduced 2016-03-10 15:25 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
101			}
102			}
103			}
104

pamil / Sylius

Push — master ( cec9f3...d27170 )

StringFilter::getExpression() D

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like