Xsolve\SalesforceClient\QueryBuilder\Expr\ExpressionFactory

Complexity

Total Complexity

23

Size/Duplication

Total Lines	122
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	20

Test Coverage

Coverage

100%

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	fields()	0	4	1
A	count()	0	4	1
A	inner()	0	4	1
A	grouping()	0	8	2
A	groupings()	0	15	3
A	objectType()	0	4	1
A	equals()	0	4	1
A	greaterThan()	0	4	1
A	greaterThanOrEquals()	0	4	1
A	in()	0	4	1
A	lessThan()	0	4	1
A	lessThanOrEquals()	0	4	1
A	like()	0	4	1
A	groupBy()	0	4	1
A	orderBy()	0	4	1
A	notEquals()	0	4	1
A	notIn()	0	4	1
A	groupByRollup()	0	4	1
A	groupByCube()	0	4	1
A	typeof()	0	4	1

<?php

namespace Xsolve\SalesforceClient\QueryBuilder\Expr;

use Xsolve\SalesforceClient\Enum\AbstractSObjectType;
use Xsolve\SalesforceClient\QueryBuilder\Query;

class ExpressionFactory
{
    /**
     * @param string[] $fields
     *
     * @return Select\Fields
     */
    public function fields(array $fields): Select\Fields
    {
        return new Select\Fields($fields);
    }

    public function count(string $countedValue = null): Select\Count
    {
        return new Select\Count($countedValue);
    }

    public function inner(Query $innerQuery): Select\Inner
    {
        return new Select\Inner($innerQuery);
    }

    public function grouping(string $source, string $target = ''): Select\Grouping
    {
        if (empty($target)) {
            $target = sprintf('grp_%s', $source);
        }

        return new Select\Grouping($source, $target);
    }

    public function groupings(array $values): Select\MultipleGrouping
    {
        $array = [];

        foreach ($values as $key => $value) {
            if (is_int($key)) {
                $array[] = $this->grouping($value);
                continue;
            }

            $array[] = $this->grouping($key, $value);
        }

        return new Select\MultipleGrouping($array);
    }

    public function objectType(AbstractSObjectType $objectType): From\ObjectType
    {
        return new From\ObjectType($objectType);
    }

    public function equals(string $left, string $right): Compare\Equals
    {
        return new Compare\Equals($left, $right);
    }

    public function greaterThan(string $left, string $right): Compare\GreaterThan
    {
        return new Compare\GreaterThan($left, $right);
    }

    public function greaterThanOrEquals(string $left, string $right): Compare\GreaterThanOrEquals
    {
        return new Compare\GreaterThanOrEquals($left, $right);
    }

    public function in(string $left, array $values): Compare\In
    {
        return new Compare\In($left, $values);
    }

    public function lessThan(string $left, string $right): Compare\LessThan
    {
        return new Compare\LessThan($left, $right);
    }

    public function lessThanOrEquals(string $left, string $right): Compare\LessThanOrEquals
    {
        return new Compare\LessThanOrEquals($left, $right);
    }

    public function like(string $left, string $right): Compare\Like
    {
        return new Compare\Like($left, $right);
    }

    public function notEquals(string $left, string $right): Compare\NotEquals
    {
        return new Compare\NotEquals($left, $right);
    }

    public function notIn(string $left, array $values): Compare\NotIn
    {
        return new Compare\NotIn($left, $values);
    }

    public function groupBy(string ...$fields): GroupBy\Fields
    {
        return new GroupBy\Fields($fields);
    }

    public function groupByRollup(string ...$fields): GroupBy\Rollup
    {
        return new GroupBy\Rollup($fields);
    }

    public function groupByCube(string ...$fields): GroupBy\Cube
    {
        return new GroupBy\Cube($fields);
    }

    public function orderBy(array $values, OrderBy\Order $order = null, OrderBy\Strategy $strategy = null): OrderBy\OrderBy
    {
        return new OrderBy\OrderBy($values, $order, $strategy);
    }

    public function typeof(string $field): Select\Typeof
    {
        return new Select\Typeof($field);
    }
}