WhereClause::notLike() - Code Metrics - Inspection of ".scrutinizser.yml の修正" - EC-CUBE/ec-cube - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Pull Request — experimental/sf (#3236)

by Kentaro

created 2018-08-01 02:06 UTC

WhereClause::notLike() A

↳ Parent: WhereClause

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
nc	1
nop	3
dl	0
loc	4
rs	10
c	0
b	0
f	0
ccs	2
cts	2
cp	1
crap	1

<?php

/*
 * This file is part of EC-CUBE
 *
 * Copyright(c) LOCKON CO.,LTD. All Rights Reserved.
 *
 * http://www.lockon.co.jp/
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Eccube\Doctrine\Query;

use Doctrine\ORM\QueryBuilder;
use Doctrine\ORM\Query\Expr;

/**
 * WHERE句を組み立てるクラス。
 */
class WhereClause

{
    private $expr;

    /**
     * @var array
     */
    private $params;

    /**
     * WhereClause constructor.
     *
     * @param $expr
     * @param array $params
     */
    private function __construct($expr, $params = null)
    {
        $this->expr = $expr;
        $this->params = $params;
function aContainsB(array $needle = null, array  $haystack) {
    if (!$needle) {
        return false;
    }

    return array_intersect($haystack, $needle) == $haystack;
}
    }

    /**
     * @param Expr\Comparison $expr
     */
    private static function newWhereClause($expr, $x, $y)
    {
        if ($y) {
            if (is_array($y)) {
                return new WhereClause($expr, $y);
            } else {
                return new WhereClause($expr, [$x => $y]);
            }
        }

        return new WhereClause($expr);
    }

    /**
     * =条件式のファクトリメソッド。
     *
     * Example:
     *      WhereClause::eq('name', ':Name', 'hoge')
     *      WhereClause::eq('name', ':Name', ['Name' => 'hoge'])
     *
     * @param $x
     * @param $y
     * @param $param
     *
     * @return WhereClause
     */
    public static function eq($x, $y, $param)
    {
        return self::newWhereClause(self::expr()->eq($x, $y), $y, $param);
    }

    /**
     * <>条件式のファクトリメソッド。
     *
     * Example:
     *      WhereClause::neq('name', ':Name', 'hoge')
     *      WhereClause::neq('name', ':Name', ['Name' => 'hoge'])
     *
     * @param $x
     * @param $y
     * @param $param
     *
     * @return WhereClause
     */
    public static function neq($x, $y, $param)
    {
        return self::newWhereClause(self::expr()->neq($x, $y), $y, $param);
    }

    /**
     * IS NULL条件式のファクトリメソッド。
     *
     * Example:
     *      WhereClause::isNull('name')
     *
     * @param $x
     *
     * @return WhereClause
     */
    public static function isNull($x)
    {
        return new WhereClause(self::expr()->isNull($x));
    }

    /**
     * IS NOT NULL条件式のファクトリメソッド。
     *
     * Example:
     *      WhereClause::isNotNull('name')
     *
     * @param $x
     *
     * @return WhereClause
     */
    public static function isNotNull($x)
    {
        return new WhereClause(self::expr()->isNotNull($x));
    }

    /**
     * LIKE演算子のファクトリメソッド。
     *
     * Example:
     *      WhereClause::like('name', ':Name', '%hoge')
     *      WhereClause::like('name', ':Name', ['Name' => '%hoge'])
     *
     * @param $x
     * @param $y
     * @param $param
     *
     * @return WhereClause
     */
    public static function like($x, $y, $param)
    {
        return self::newWhereClause(self::expr()->like($x, $y), $y, $param);
    }

    /**
     * NOT LIKE演算子のファクトリメソッド。
     *
     * Example:
     *      WhereClause::notLike('name', ':Name', '%hoge')
     *      WhereClause::notLike('name', ':Name', ['Name' => '%hoge'])
     *
     * @param $x
     * @param $y
     * @param $param
     *
     * @return WhereClause
     */
    public static function notLike($x, $y, $param)
    {
        return self::newWhereClause(self::expr()->notLike($x, $y), $y, $param);
    }

    /**
     * IN演算子のファクトリメソッド。
     *
     * Example:
     *      WhereClause::in('name', ':Names', ['foo', 'bar'])
     *      WhereClause::in('name', ':Names', ['Names' => ['foo', 'bar']])
     *
     * @param $x
     * @param $y
     * @param $param
     *
     * @return WhereClause
     */
    public static function in($x, $y, $param)
    {
        return new WhereClause(self::expr()->in($x, $y), self::isMap($param) ? $param : [$y => $param]);
    }

    private static function isMap($arrayOrMap)
    {
        return array_values($arrayOrMap) !== $arrayOrMap;
    }

    /**
     * NOT IN演算子のファクトリメソッド。
     *
     * Example:
     *      WhereClause::notIn('name', ':Names', ['foo', 'bar'])
     *      WhereClause::notIn('name', ':Names', ['Names' => ['foo', 'bar']])
     *
     * @param $x
     * @param $y
     * @param $param
     *
     * @return WhereClause
     */
    public static function notIn($x, $y, $param)
    {
        return new WhereClause(self::expr()->notIn($x, $y), self::isMap($param) ? $param : [$y => $param]);
    }

    /**
     * BETWEEN演算子のファクトリメソッド。
     *
     * Example:
     *      WhereClause::between('price', ':PriceMin', ':PriceMax', [1000, 2000])
     *      WhereClause::between('price', ':PriceMin', ':PriceMax', ['PriceMin' => 1000, 'PriceMax' => 2000])
     *
     * @param $var
     * @param $x
     * @param $y
     * @param $params
     *
     * @return WhereClause
     */
    public static function between($var, $x, $y, $params)
    {
        return new WhereClause(self::expr()->between($var, $x, $y), self::isMap($params) ? $params : [$x => $params[0], $y => $params[1]]);
    }

    /**
     * >演算子のファクトリメソッド。
     *
     * Example:
     *      WhereClause::gt('price', ':Price', 1000)
     *      WhereClause::gt('price', ':Price', ['Price' => 1000])
     *
     * @param $x
     * @param $y
     * @param $param
     *
     * @return WhereClause
     */
    public static function gt($x, $y, $param)
    {
        return self::newWhereClause(self::expr()->gt($x, $y), $y, $param);
    }

    /**
     * >=演算子のファクトリメソッド。
     *
     * Example:
     *      WhereClause::gte('price', ':Price', 1000)
     *      WhereClause::gte('price', ':Price', ['Price' => 1000])
     *
     * @param $x
     * @param $y
     * @param $param
     *
     * @return WhereClause
     */
    public static function gte($x, $y, $param)
    {
        return self::newWhereClause(self::expr()->gte($x, $y), $y, $param);
    }

    /**
     * <演算子のファクトリメソッド。
     *
     * Example:
     *      WhereClause::lt('price', ':Price', 1000)
     *      WhereClause::lt('price', ':Price', ['Price' => 1000])
     *
     * @param $x
     * @param $y
     * @param $param
     *
     * @return WhereClause
     */
    public static function lt($x, $y, $param)
    {
        return self::newWhereClause(self::expr()->lt($x, $y), $y, $param);
    }

    /**
     * <=演算子のファクトリメソッド。
     *
     * Example:
     *      WhereClause::lte('price', ':Price', 1000)
     *      WhereClause::lte('price', ':Price', ['Price' => 1000])
     *
     * @param $x
     * @param $y
     * @param $param
     *
     * @return WhereClause
     */
    public static function lte($x, $y, $param)
    {
        return self::newWhereClause(self::expr()->lte($x, $y), $y, $param);
    }

    /**
     * @return Expr
     */
    private static function expr()
    {
        return new Expr();
    }

    public function build(QueryBuilder $builder)
    {
        $builder->andWhere($this->expr);
        if ($this->params) {

            foreach ($this->params as $key => $param) {
                $builder->setParameter($key, $param);
            }
        }
    }
}


1		<?php
2
3		/*
4		* This file is part of EC-CUBE
5		*
6		* Copyright(c) LOCKON CO.,LTD. All Rights Reserved.
7		*
8		* http://www.lockon.co.jp/
9		*
10		* For the full copyright and license information, please view the LICENSE
11		* file that was distributed with this source code.
12		*/
13
14		namespace Eccube\Doctrine\Query;
15
16		use Doctrine\ORM\QueryBuilder;
17		use Doctrine\ORM\Query\Expr;
18
19		/**
20		* WHERE句を組み立てるクラス。
21		*/
22		class WhereClause
		0 ignored issues – show Coding Style introduced 2018-06-22 08:49 UTC by Report Bug Copy Issue Report Since you have declared the constructor as private, maybe you should also declare the class as final. Loading history...
23		{
24		private $expr;
25
26		/**
27		* @var array
28		*/
29		private $params;
30
31		/**
32		* WhereClause constructor.
33		*
34		* @param $expr
35		* @param array $params
36		*/
37	24	private function __construct($expr, $params = null)
38		{
39	24	$this->expr = $expr;
40	24	$this->params = $params;
		0 ignored issues – show Documentation Bug introduced 2018-06-26 09:41 UTC by Report Bug Copy Issue Report It seems like `$params` can be `null`. However, the property `$params` is declared as `array`. Maybe change the type of the property to `array\|null` or add a type check? Our type inference engine has found an assignment of a scalar value (like a string, an integer or null) to a property which is an array. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property. To type hint that a parameter can be either an array or null, you can set a type hint of array and a default value of null. The PHP interpreter will then accept both an array or null for that parameter. function aContainsB(array $needle = null, array $haystack) { if (!$needle) { return false; } return array_intersect($haystack, $needle) == $haystack; } The function can be called with either null or an array for the parameter `$needle` but will only accept an array as `$haystack`. Loading history...
41		}
42
43		/**
44		* @param Expr\Comparison $expr
45		*/
46	16	private static function newWhereClause($expr, $x, $y)
47		{
48	16	if ($y) {
49	16	if (is_array($y)) {
50	5	return new WhereClause($expr, $y);
51		} else {
52	11	return new WhereClause($expr, [$x => $y]);
53		}
54		}
55
56	1	return new WhereClause($expr);
57		}
58
59		/**
60		* =条件式のファクトリメソッド。
61		*
62		* Example:
63		* WhereClause::eq('name', ':Name', 'hoge')
64		* WhereClause::eq('name', ':Name', ['Name' => 'hoge'])
65		*
66		* @param $x
67		* @param $y
68		* @param $param
69		*
70		* @return WhereClause
71		*/
72	5	public static function eq($x, $y, $param)
73		{
74	5	return self::newWhereClause(self::expr()->eq($x, $y), $y, $param);
75		}
76
77		/**
78		* <>条件式のファクトリメソッド。
79		*
80		* Example:
81		* WhereClause::neq('name', ':Name', 'hoge')
82		* WhereClause::neq('name', ':Name', ['Name' => 'hoge'])
83		*
84		* @param $x
85		* @param $y
86		* @param $param
87		*
88		* @return WhereClause
89		*/
90	1	public static function neq($x, $y, $param)
91		{
92	1	return self::newWhereClause(self::expr()->neq($x, $y), $y, $param);
93		}
94
95		/**
96		* IS NULL条件式のファクトリメソッド。
97		*
98		* Example:
99		* WhereClause::isNull('name')
100		*
101		* @param $x
102		*
103		* @return WhereClause
104		*/
105	1	public static function isNull($x)
106		{
107	1	return new WhereClause(self::expr()->isNull($x));
108		}
109
110		/**
111		* IS NOT NULL条件式のファクトリメソッド。
112		*
113		* Example:
114		* WhereClause::isNotNull('name')
115		*
116		* @param $x
117		*
118		* @return WhereClause
119		*/
120	1	public static function isNotNull($x)
121		{
122	1	return new WhereClause(self::expr()->isNotNull($x));
123		}
124
125		/**
126		* LIKE演算子のファクトリメソッド。
127		*
128		* Example:
129		* WhereClause::like('name', ':Name', '%hoge')
130		* WhereClause::like('name', ':Name', ['Name' => '%hoge'])
131		*
132		* @param $x
133		* @param $y
134		* @param $param
135		*
136		* @return WhereClause
137		*/
138	1	public static function like($x, $y, $param)
139		{
140	1	return self::newWhereClause(self::expr()->like($x, $y), $y, $param);
141		}
142
143		/**
144		* NOT LIKE演算子のファクトリメソッド。
145		*
146		* Example:
147		* WhereClause::notLike('name', ':Name', '%hoge')
148		* WhereClause::notLike('name', ':Name', ['Name' => '%hoge'])
149		*
150		* @param $x
151		* @param $y
152		* @param $param
153		*
154		* @return WhereClause
155		*/
156	1	public static function notLike($x, $y, $param)
157		{
158	1	return self::newWhereClause(self::expr()->notLike($x, $y), $y, $param);
159		}
160
161		/**
162		* IN演算子のファクトリメソッド。
163		*
164		* Example:
165		* WhereClause::in('name', ':Names', ['foo', 'bar'])
166		* WhereClause::in('name', ':Names', ['Names' => ['foo', 'bar']])
167		*
168		* @param $x
169		* @param $y
170		* @param $param
171		*
172		* @return WhereClause
173		*/
174	2	public static function in($x, $y, $param)
175		{
176	2	return new WhereClause(self::expr()->in($x, $y), self::isMap($param) ? $param : [$y => $param]);
177		}
178
179	6	private static function isMap($arrayOrMap)
180		{
181	6	return array_values($arrayOrMap) !== $arrayOrMap;
182		}
183
184		/**
185		* NOT IN演算子のファクトリメソッド。
186		*
187		* Example:
188		* WhereClause::notIn('name', ':Names', ['foo', 'bar'])
189		* WhereClause::notIn('name', ':Names', ['Names' => ['foo', 'bar']])
190		*
191		* @param $x
192		* @param $y
193		* @param $param
194		*
195		* @return WhereClause
196		*/
197	2	public static function notIn($x, $y, $param)
198		{
199	2	return new WhereClause(self::expr()->notIn($x, $y), self::isMap($param) ? $param : [$y => $param]);
200		}
201
202		/**
203		* BETWEEN演算子のファクトリメソッド。
204		*
205		* Example:
206		* WhereClause::between('price', ':PriceMin', ':PriceMax', [1000, 2000])
207		* WhereClause::between('price', ':PriceMin', ':PriceMax', ['PriceMin' => 1000, 'PriceMax' => 2000])
208		*
209		* @param $var
210		* @param $x
211		* @param $y
212		* @param $params
213		*
214		* @return WhereClause
215		*/
216	2	public static function between($var, $x, $y, $params)
217		{
218	2	return new WhereClause(self::expr()->between($var, $x, $y), self::isMap($params) ? $params : [$x => $params[0], $y => $params[1]]);
219		}
220
221		/**
222		* >演算子のファクトリメソッド。
223		*
224		* Example:
225		* WhereClause::gt('price', ':Price', 1000)
226		* WhereClause::gt('price', ':Price', ['Price' => 1000])
227		*
228		* @param $x
229		* @param $y
230		* @param $param
231		*
232		* @return WhereClause
233		*/
234	2	public static function gt($x, $y, $param)
235		{
236	2	return self::newWhereClause(self::expr()->gt($x, $y), $y, $param);
237		}
238
239		/**
240		* >=演算子のファクトリメソッド。
241		*
242		* Example:
243		* WhereClause::gte('price', ':Price', 1000)
244		* WhereClause::gte('price', ':Price', ['Price' => 1000])
245		*
246		* @param $x
247		* @param $y
248		* @param $param
249		*
250		* @return WhereClause
251		*/
252	2	public static function gte($x, $y, $param)
253		{
254	2	return self::newWhereClause(self::expr()->gte($x, $y), $y, $param);
255		}
256
257		/**
258		* <演算子のファクトリメソッド。
259		*
260		* Example:
261		* WhereClause::lt('price', ':Price', 1000)
262		* WhereClause::lt('price', ':Price', ['Price' => 1000])
263		*
264		* @param $x
265		* @param $y
266		* @param $param
267		*
268		* @return WhereClause
269		*/
270	2	public static function lt($x, $y, $param)
271		{
272	2	return self::newWhereClause(self::expr()->lt($x, $y), $y, $param);
273		}
274
275		/**
276		* <=演算子のファクトリメソッド。
277		*
278		* Example:
279		* WhereClause::lte('price', ':Price', 1000)
280		* WhereClause::lte('price', ':Price', ['Price' => 1000])
281		*
282		* @param $x
283		* @param $y
284		* @param $param
285		*
286		* @return WhereClause
287		*/
288	2	public static function lte($x, $y, $param)
289		{
290	2	return self::newWhereClause(self::expr()->lte($x, $y), $y, $param);
291		}
292
293		/**
294		* @return Expr
295		*/
296	24	private static function expr()
297		{
298	24	return new Expr();
299		}
300
301	24	public function build(QueryBuilder $builder)
302		{
303	24	$builder->andWhere($this->expr);
304	24	if ($this->params) {
		0 ignored issues – show Bug Best Practice introduced 2017-04-19 07:31 UTC by Report Bug Copy Issue Report The expression `$this->params` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
305	22	foreach ($this->params as $key => $param) {
306	22	$builder->setParameter($key, $param);
307		}
308		}
309		}
310		}
311

EC-CUBE / ec-cube

Pull Request — experimental/sf (#3236)

WhereClause::notLike() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like