Eccube\Doctrine\Query\WhereClause

Complexity

Total Complexity

25

Size/Duplication

Total Lines	271
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	2

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	newWhereClause()	0	11	3
A	eq()	0	4	1
A	neq()	0	4	1
A	isNull()	0	4	1
A	isNotNull()	0	4	1
A	like()	0	4	1
A	notLike()	0	4	1
A	in()	0	4	2
A	isMap()	0	4	1
A	notIn()	0	4	2
A	between()	0	4	2
A	gt()	0	4	1
A	gte()	0	4	1
A	lt()	0	4	1
A	lte()	0	4	1
A	expr()	0	4	1
A	build()	0	8	3

<?php
/*
 * This file is part of EC-CUBE
 *
 * Copyright(c) 2000-2017 LOCKON CO.,LTD. All Rights Reserved.
 *
 * http://www.lockon.co.jp/
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

namespace Eccube\Doctrine\Query;


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

/**
 * WHERE句を組み立てるクラス。
 *
 * @package Eccube\Doctrine\Query
 */
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;

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?

    }

    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);

Missing blank line before return statement

    }

    /**

Doc comment for parameter "$x" missing

Doc comment for parameter "$y" missing

Doc comment for parameter "$param" missing

     * =条件式のファクトリメソッド。
     *
     * Example:
     *      WhereClause::eq('name', ':Name', 'hoge')
     *      WhereClause::eq('name', ':Name', ['Name' => 'hoge'])
     *
     * @param $x

Missing parameter name

     * @param $y

Missing parameter name

     * @param $param

Missing parameter name

     * @return WhereClause
     */
    public static function eq($x, $y, $param)

Declare public methods first, then protected ones and finally private ones

    {
        return self::newWhereClause(self::expr()->eq($x, $y), $y, $param);
    }

    /**

Doc comment for parameter "$x" missing

Doc comment for parameter "$y" missing

Doc comment for parameter "$param" missing

     * <>条件式のファクトリメソッド。
     *
     * Example:
     *      WhereClause::neq('name', ':Name', 'hoge')
     *      WhereClause::neq('name', ':Name', ['Name' => 'hoge'])
     *
     * @param $x

Missing parameter name

     * @param $y

Missing parameter name

     * @param $param

Missing parameter name

     * @return WhereClause
     */
    public static function neq($x, $y, $param)
    {
        return self::newWhereClause(self::expr()->neq($x, $y), $y, $param);
    }

    /**

Doc comment for parameter "$x" missing

     * IS NULL条件式のファクトリメソッド。
     *
     * Example:
     *      WhereClause::isNull('name')
     *
     * @param $x

Missing parameter name

     * @return WhereClause
     */
    public static function isNull($x)
    {
        return new WhereClause(self::expr()->isNull($x));
    }

    /**

Doc comment for parameter "$x" missing

     * IS NOT NULL条件式のファクトリメソッド。
     *
     * Example:
     *      WhereClause::isNotNull('name')
     *
     * @param $x

Missing parameter name

     * @return WhereClause
     */
    public static function isNotNull($x)
    {
        return new WhereClause(self::expr()->isNotNull($x));
    }

    /**

Doc comment for parameter "$x" missing

Doc comment for parameter "$y" missing

Doc comment for parameter "$param" missing

     * LIKE演算子のファクトリメソッド。
     *
     * Example:
     *      WhereClause::like('name', ':Name', '%hoge')
     *      WhereClause::like('name', ':Name', ['Name' => '%hoge'])
     *
     * @param $x

Missing parameter name

     * @param $y

Missing parameter name

     * @param $param

Missing parameter name

     * @return WhereClause
     */
    public static function like($x, $y, $param)
    {
        return self::newWhereClause(self::expr()->like($x, $y), $y, $param);
    }

    /**

Doc comment for parameter "$x" missing

Doc comment for parameter "$y" missing

Doc comment for parameter "$param" missing

     * NOT LIKE演算子のファクトリメソッド。
     *
     * Example:
     *      WhereClause::notLike('name', ':Name', '%hoge')
     *      WhereClause::notLike('name', ':Name', ['Name' => '%hoge'])
     *
     * @param $x

Missing parameter name

     * @param $y

Missing parameter name

     * @param $param

Missing parameter name

     * @return WhereClause
     */
    public static function notLike($x, $y, $param)
    {
        return self::newWhereClause(self::expr()->notLike($x, $y), $y, $param);
    }

    /**

Doc comment for parameter "$x" missing

Doc comment for parameter "$y" missing

Doc comment for parameter "$param" missing

     * IN演算子のファクトリメソッド。
     *
     * Example:
     *      WhereClause::in('name', ':Names', ['foo', 'bar'])
     *      WhereClause::in('name', ':Names', ['Names' => ['foo', 'bar']])
     *
     * @param $x

Missing parameter name

     * @param $y

Missing parameter name

     * @param $param

Missing parameter name

     * @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;
    }

    /**

Doc comment for parameter "$x" missing

Doc comment for parameter "$y" missing

Doc comment for parameter "$param" missing

     * NOT IN演算子のファクトリメソッド。
     *
     * Example:
     *      WhereClause::notIn('name', ':Names', ['foo', 'bar'])
     *      WhereClause::notIn('name', ':Names', ['Names' => ['foo', 'bar']])
     *
     * @param $x

Missing parameter name

     * @param $y

Missing parameter name

     * @param $param

Missing parameter name

     * @return WhereClause
     */
    public static function notIn($x, $y, $param)

Declare public methods first, then protected ones and finally private ones

    {
        return new WhereClause(self::expr()->notIn($x, $y), self::isMap($param) ? $param : [$y => $param]);
    }

    /**

Doc comment for parameter "$var" missing

Doc comment for parameter "$x" missing

Doc comment for parameter "$y" missing

Doc comment for parameter "$params" missing

     * BETWEEN演算子のファクトリメソッド。
     *
     * Example:
     *      WhereClause::between('price', ':PriceMin', ':PriceMax', [1000, 2000])
     *      WhereClause::between('price', ':PriceMin', ':PriceMax', ['PriceMin' => 1000, 'PriceMax' => 2000])
     *
     * @param $var

Missing parameter name

     * @param $x

Missing parameter name

     * @param $y

Missing parameter name

     * @param $params

Missing parameter name

     * @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]]);
    }

    /**

Doc comment for parameter "$x" missing

Doc comment for parameter "$y" missing

Doc comment for parameter "$param" missing

     * >演算子のファクトリメソッド。
     *
     * Example:
     *      WhereClause::gt('price', ':Price', 1000)
     *      WhereClause::gt('price', ':Price', ['Price' => 1000])
     *
     * @param $x

Missing parameter name

     * @param $y

Missing parameter name

     * @param $param

Missing parameter name

     * @return WhereClause
     */
    public static function gt($x, $y, $param)
    {
        return self::newWhereClause(self::expr()->gt($x, $y), $y, $param);
    }

    /**

Doc comment for parameter "$x" missing

Doc comment for parameter "$y" missing

Doc comment for parameter "$param" missing

     * >=演算子のファクトリメソッド。
     *
     * Example:
     *      WhereClause::gte('price', ':Price', 1000)
     *      WhereClause::gte('price', ':Price', ['Price' => 1000])
     *
     * @param $x

Missing parameter name

     * @param $y

Missing parameter name

     * @param $param

Missing parameter name

     * @return WhereClause
     */
    public static function gte($x, $y, $param)
    {
        return self::newWhereClause(self::expr()->gte($x, $y), $y, $param);
    }

    /**

Doc comment for parameter "$x" missing

Doc comment for parameter "$y" missing

Doc comment for parameter "$param" missing

     * <演算子のファクトリメソッド。
     *
     * Example:
     *      WhereClause::lt('price', ':Price', 1000)
     *      WhereClause::lt('price', ':Price', ['Price' => 1000])
     *
     * @param $x

Missing parameter name

     * @param $y

Missing parameter name

     * @param $param

Missing parameter name

     * @return WhereClause
     */
    public static function lt($x, $y, $param)
    {
        return self::newWhereClause(self::expr()->lt($x, $y), $y, $param);
    }

    /**

Doc comment for parameter "$x" missing

Doc comment for parameter "$y" missing

Doc comment for parameter "$param" missing

     * <=演算子のファクトリメソッド。
     *
     * Example:
     *      WhereClause::lte('price', ':Price', 1000)
     *      WhereClause::lte('price', ':Price', ['Price' => 1000])
     *
     * @param $x

Missing parameter name

     * @param $y

Missing parameter name

     * @param $param

Missing parameter name

     * @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) {

Declare public methods first, then protected ones and finally private ones

Missing function doc comment

        $builder->andWhere($this->expr);
        if ($this->params) {

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.

            foreach ($this->params as $key=>$param) {

Expected 1 space before "=>"; 0 found

Expected 1 space after "=>"; 0 found

                $builder->setParameter($key, $param);
            }
        }
    }
}