QueryExpressionVisitor::walkCompositeExpression() - Code Metrics - Inspection of "Added missing type hints." - doctrine/mongodb-odm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1376)

by Bilge

created 2016-02-29 23:57 UTC

QueryExpressionVisitor::walkCompositeExpression() A

↳ Parent: QueryExpressionVisitor

Complexity

Conditions	3
Paths	3

Size

Total Lines	15
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	12

Metric	Value
dl	0
loc	15
ccs	0
cts	12
cp	0
rs	9.4285
cc	3
eloc	8
nc	3
nop	1
crap	12

<?php
/*
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the MIT license. For more information, see
 * <http://www.doctrine-project.org>.
 */

namespace Doctrine\ODM\MongoDB\Query;

use Doctrine\Common\Collections\Expr\Comparison;
use Doctrine\Common\Collections\Expr\CompositeExpression;
use Doctrine\Common\Collections\Expr\ExpressionVisitor;
use Doctrine\Common\Collections\Expr\Value;

/**
 * Converts Collection expressions to query expressions.
 *
 * @since  1.0
 */
class QueryExpressionVisitor extends ExpressionVisitor
{
    /**
     * Map Criteria API comparison operators to query builder methods
     *
     * @todo Implement support for Comparison::CONTAINS
     * @var array
     */
    private static $operatorMethods = array(
        Comparison::EQ => 'equals',
        Comparison::GT => 'gt',
        Comparison::GTE => 'gte',
        Comparison::IN => 'in',
        Comparison::IS => 'equals',
        Comparison::LT => 'lt',
        Comparison::LTE => 'lte',
        Comparison::NEQ => 'notEqual',
        Comparison::NIN => 'notIn',
    );

    /**
     * Map Criteria API composite types to query builder methods
     *
     * @var array
     */
    private static $compositeMethods = array(
        CompositeExpression::TYPE_AND => 'addAnd',
        CompositeExpression::TYPE_OR => 'addOr',
    );

    /**
     * @var Builder
     */
    protected $builder;

    /**
     * Constructor.
     *
     * @param Builder $builder
     */
    public function __construct(Builder $builder)
    {
        $this->builder = $builder;
    }

    /**
     * Converts a comparison expression into the target query language output.
     *
     * @see ExpressionVisitor::walkComparison()
     * @param Comparison $comparison
     * @return \Doctrine\ODM\MongoDB\Query\Expr
     */
    public function walkComparison(Comparison $comparison)
    {
        switch ($comparison->getOperator()) {
            case Comparison::EQ:
            case Comparison::GT:
            case Comparison::GTE:
            case Comparison::IN:
            case Comparison::IS:
            case Comparison::LT:
            case Comparison::LTE:
            case Comparison::NEQ:
            case Comparison::NIN:
                $method = self::$operatorMethods[$comparison->getOperator()];

                return $this->builder->expr()
                    ->field($comparison->getField())
                    ->{$method}($this->walkValue($comparison->getValue()));

            case Comparison::CONTAINS:
                $value = $this->walkValue($comparison->getValue());

                return $this->builder->expr()
                    ->field($comparison->getField())
                    ->equals(new \MongoRegex('/' . preg_quote($value, '/') . '/'));

            default:
                throw new \RuntimeException('Unknown comparison operator: ' . $comparison->getOperator());
        }
    }

    /**
     * Converts a composite expression into the target query language output.
     *
     * @see ExpressionVisitor::walkCompositeExpression()
     * @param CompositeExpression $expr
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @return \Doctrine\ODM\MongoDB\Query\Expr
     */
    public function walkCompositeExpression(CompositeExpression $compositeExpr)
    {
        if ( ! isset(self::$compositeMethods[$compositeExpr->getType()])) {
            throw new \RuntimeException('Unknown composite ' . $compositeExpr->getType());
        }

        $method = self::$compositeMethods[$compositeExpr->getType()];
        $expr = $this->builder->expr();

        foreach ($compositeExpr->getExpressionList() as $child) {
            $expr->{$method}($this->dispatch($child));
        }

        return $expr;
    }

    /**
     * Converts a value expression into the target query language part.
     *
     * @see ExpressionVisitor::walkValue()
     * @param Value $value
     * @return mixed
     */
    public function walkValue(Value $value)
    {
        return $value->getValue();
    }
}


1			<?php
2			/*
3			* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
4			* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
5			* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
6			* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
7			* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
8			* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
9			* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
10			* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
11			* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
12			* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
13			* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
14			*
15			* This software consists of voluntary contributions made by many individuals
16			* and is licensed under the MIT license. For more information, see
17			* <http://www.doctrine-project.org>.
18			*/
19
20			namespace Doctrine\ODM\MongoDB\Query;
21
22			use Doctrine\Common\Collections\Expr\Comparison;
23			use Doctrine\Common\Collections\Expr\CompositeExpression;
24			use Doctrine\Common\Collections\Expr\ExpressionVisitor;
25			use Doctrine\Common\Collections\Expr\Value;
26
27			/**
28			* Converts Collection expressions to query expressions.
29			*
30			* @since 1.0
31			*/
32			class QueryExpressionVisitor extends ExpressionVisitor
33			{
34			/**
35			* Map Criteria API comparison operators to query builder methods
36			*
37			* @todo Implement support for Comparison::CONTAINS
38			* @var array
39			*/
40			private static $operatorMethods = array(
41			Comparison::EQ => 'equals',
42			Comparison::GT => 'gt',
43			Comparison::GTE => 'gte',
44			Comparison::IN => 'in',
45			Comparison::IS => 'equals',
46			Comparison::LT => 'lt',
47			Comparison::LTE => 'lte',
48			Comparison::NEQ => 'notEqual',
49			Comparison::NIN => 'notIn',
50			);
51
52			/**
53			* Map Criteria API composite types to query builder methods
54			*
55			* @var array
56			*/
57			private static $compositeMethods = array(
58			CompositeExpression::TYPE_AND => 'addAnd',
59			CompositeExpression::TYPE_OR => 'addOr',
60			);
61
62			/**
63			* @var Builder
64			*/
65			protected $builder;
66
67			/**
68			* Constructor.
69			*
70			* @param Builder $builder
71			*/
72			public function __construct(Builder $builder)
73			{
74			$this->builder = $builder;
75			}
76
77			/**
78			* Converts a comparison expression into the target query language output.
79			*
80			* @see ExpressionVisitor::walkComparison()
81			* @param Comparison $comparison
82			* @return \Doctrine\ODM\MongoDB\Query\Expr
83			*/
84			public function walkComparison(Comparison $comparison)
85			{
86			switch ($comparison->getOperator()) {
87			case Comparison::EQ:
88			case Comparison::GT:
89			case Comparison::GTE:
90			case Comparison::IN:
91			case Comparison::IS:
92			case Comparison::LT:
93			case Comparison::LTE:
94			case Comparison::NEQ:
95			case Comparison::NIN:
96			$method = self::$operatorMethods[$comparison->getOperator()];
97
98			return $this->builder->expr()
99			->field($comparison->getField())
100			->{$method}($this->walkValue($comparison->getValue()));
101
102			case Comparison::CONTAINS:
103			$value = $this->walkValue($comparison->getValue());
104
105			return $this->builder->expr()
106			->field($comparison->getField())
107			->equals(new \MongoRegex('/' . preg_quote($value, '/') . '/'));
108
109			default:
110			throw new \RuntimeException('Unknown comparison operator: ' . $comparison->getOperator());
111			}
112			}
113
114			/**
115			* Converts a composite expression into the target query language output.
116			*
117			* @see ExpressionVisitor::walkCompositeExpression()
118			* @param CompositeExpression $expr
			0 ignored issues – show Bug introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report There is no parameter named `$expr`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
119			* @return \Doctrine\ODM\MongoDB\Query\Expr
120			*/
121			public function walkCompositeExpression(CompositeExpression $compositeExpr)
122			{
123			if ( ! isset(self::$compositeMethods[$compositeExpr->getType()])) {
124			throw new \RuntimeException('Unknown composite ' . $compositeExpr->getType());
125			}
126
127			$method = self::$compositeMethods[$compositeExpr->getType()];
128			$expr = $this->builder->expr();
129
130			foreach ($compositeExpr->getExpressionList() as $child) {
131			$expr->{$method}($this->dispatch($child));
132			}
133
134			return $expr;
135			}
136
137			/**
138			* Converts a value expression into the target query language part.
139			*
140			* @see ExpressionVisitor::walkValue()
141			* @param Value $value
142			* @return mixed
143			*/
144			public function walkValue(Value $value)
145			{
146			return $value->getValue();
147			}
148			}
149

doctrine / mongodb-odm

Pull Request — master (#1376)

QueryExpressionVisitor::walkCompositeExpression() A

Complexity

Size

Duplication

Code Coverage

Duplication Side-by-Side

Filter issues like