Sylius\Bundle\GridBundle\Doctrine\PHPCRODM\ExpressionBuilder

Complexity

Total Complexity

20

Size/Duplication

Total Lines	161
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	2

Importance

Changes	1
Bugs	0	Features	0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	2
A	andX()	0	4	1
A	orX()	0	4	1
A	comparison()	0	4	1
A	equals()	0	4	1
A	notEquals()	0	4	1
A	lessThan()	0	4	1
A	lessThanOrEqual()	0	4	1
A	greaterThan()	0	4	1
A	greaterThanOrEqual()	0	4	1
A	in()	0	4	1
A	notIn()	0	4	1
A	isNull()	0	4	1
A	isNotNull()	0	4	1
A	like()	0	4	1
A	notLike()	0	4	1
A	orderBy()	0	4	1
A	addOrderBy()	0	4	1
A	getOrderBys()	0	4	1

<?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\Bundle\GridBundle\Doctrine\PHPCRODM;

use Sylius\Component\Grid\Data\ExpressionBuilderInterface;
use Doctrine\ODM\PHPCR\Query\Builder\QueryBuilder;
use Doctrine\Common\Collections\ExpressionBuilder as CollectionsExpressionBuilder;
use Sylius\Bundle\GridBundle\Doctrine\PHPCRODM\ExtraComparison;
use Doctrine\Common\Collections\Expr\Comparison;

/**
 * Creates an object graph (using Doctrine\Commons\Collections\Expr\*) which we
 * can then walk in order to build up the PHPCR-ODM query builder.
 */
class ExpressionBuilder implements ExpressionBuilderInterface
{
    /**
     * @var CollectionsExpressionBuilder
     */
    private $expressionBuilder;

    /**
     * @var array
     */
    private $orderBys = [];

    public function __construct(CollectionsExpressionBuilder $expressionBuilder = null)
    {
        $this->expressionBuilder = $expressionBuilder ?: new CollectionsExpressionBuilder();
    }

    /**
     * {@inheritdoc}
     */
    public function andX($expressions)
    {
        return $this->expressionBuilder->andX($expressions);
    }

    /**
     * {@inheritdoc}
     */
    public function orX($expressions)
    {
        return $this->expressionBuilder->orX($expressions);
    }

    /**
     * {@inheritdoc}
     */
    public function comparison($field, $operator, $value)
    {
        throw new \BadMethodCallException('Not supported yet.');
    }

    /**
     * {@inheritdoc}
     */
    public function equals($field, $value)
    {
        return $this->expressionBuilder->eq($field, $value);
    }

    /**
     * {@inheritdoc}
     */
    public function notEquals($field, $value)
    {
        return $this->expressionBuilder->neq($field, $value);
    }

    /**
     * {@inheritdoc}
     */
    public function lessThan($field, $value)
    {
        return $this->expressionBuilder->lt($field, $value);
    }

    /**
     * {@inheritdoc}
     */
    public function lessThanOrEqual($field, $value)
    {
        return $this->expressionBuilder->lte($field, $value);
    }

    /**
     * {@inheritdoc}
     */
    public function greaterThan($field, $value)
    {
        return $this->expressionBuilder->gt($field, $value);
    }

    /**
     * {@inheritdoc}
     */
    public function greaterThanOrEqual($field, $value)
    {
        return $this->expressionBuilder->gte($field, $value);
    }

    /**
     * {@inheritdoc}
     */
    public function in($field, array $values)
    {
        return $this->expressionBuilder->in($field, $values);
    }

    /**
     * {@inheritdoc}
     */
    public function notIn($field, array $values)
    {
        return $this->expressionBuilder->notIn($field, $values);
    }

    /**
     * {@inheritdoc}
     */
    public function isNull($field)
    {
        return new Comparison($field, ExtraComparison::IS_NULL, null);
    }

    /**
     * {@inheritdoc}
     */
    public function isNotNull($field)
    {
        return new Comparison($field, ExtraComparison::IS_NOT_NULL, null);
    }

    /**
     * {@inheritdoc}
     */
    public function like($field, $pattern)
    {
        return $this->expressionBuilder->contains($field, $pattern);
    }

    /**
     * {@inheritdoc}
     */
    public function notLike($field, $pattern)
    {
        return new Comparison($field, ExtraComparison::NOT_CONTAINS, $pattern);
    }

    /**
     * {@inheritdoc}
     */
    public function orderBy($field, $direction)
    {
        $this->orderBys = [ $field => $direction ];
    }

    /**
     * {@inheritdoc}
     */
    public function addOrderBy($field, $direction)
    {
        $this->orderBys[$field] = $direction;
    }

    /**
     * {@inheritdoc}
     */
    public function getOrderBys()
    {
        return $this->orderBys;
    }
}