ExpressionParser::parsePrimaryStart() - Code Metrics - Inspection of "Fix private method naming" - Algo-Web/POData - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#120)

by Alex
created 2017-07-15 07:01 UTC
ExpressionParser::parsePrimaryStart() C

↳ Parent: ExpressionParser
Complexity

Conditions	14
Paths	14
Size

Total Lines	36
Code Lines	31
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
dl	0
loc	36
rs	5.0864
c	0
b	0
f	0
cc	14
eloc	31
nc	14
nop	0
How to fix Complexity

<?php

namespace POData\UriProcessor\QueryProcessor\ExpressionParser;

use POData\Common\Messages;
use POData\Common\NotImplementedException;
use POData\Common\ODataConstants;
use POData\Common\ODataException;
use POData\Providers\Metadata\ResourcePropertyKind;
use POData\Providers\Metadata\ResourceType;
use POData\Providers\Metadata\Type\Binary;
use POData\Providers\Metadata\Type\Boolean;
use POData\Providers\Metadata\Type\DateTime;
use POData\Providers\Metadata\Type\Decimal;
use POData\Providers\Metadata\Type\Double;
use POData\Providers\Metadata\Type\Guid;
use POData\Providers\Metadata\Type\Int32;
use POData\Providers\Metadata\Type\Int64;
use POData\Providers\Metadata\Type\IType;
use POData\Providers\Metadata\Type\Null1;
use POData\Providers\Metadata\Type\Single;
use POData\Providers\Metadata\Type\StringType;
use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\AbstractExpression;
use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\ArithmeticExpression;
use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\ConstantExpression;
use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\ExpressionType;
use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\FunctionCallExpression;
use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\LogicalExpression;
use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\PropertyAccessExpression;
use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\RelationalExpression;
use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\UnaryExpression;
use POData\UriProcessor\QueryProcessor\FunctionDescription;

/**
 * Class ExpressionParser.
 */
class ExpressionParser
{
    const RECURSION_LIMIT = 200;

    /**
     * The Lexical analyzer.
     *
     * @var ExpressionLexer
     */
    private $lexer;

    /**
     * The current recursion depth.
     *
     * @var int
     */
    private $recursionDepth;

    /**
     * The ResourceType on which $filter condition needs to be applied.
     *
     * @var ResourceType
     */
    private $resourceType;

    /**
     * @var bool
     */
    private $isPHPExpressionProvider;

    /**
     * True if the filter expression contains level 2 property access, for example
     * Customers?$filter=Address/LineNumber eq 12
     * Customer?$filter=Order/OrderID gt 1234
     * False otherwise.
     *
     * @var bool
     */
    private $hasLevel2PropertyInTheExpression;

    /**
     * Construct a new instance of ExpressionParser.
     *
     * @param string       $text                    The expression to parse
     * @param ResourceType $resourceType            The resource type of the resource targeted by the resource path
     * @param bool         $isPHPExpressionProvider
     *
     * TODO Expression parser should not depend on the fact that end user is implementing IExpressionProvider or not

     */
    public function __construct($text, ResourceType $resourceType, $isPHPExpressionProvider)

    {
        $this->lexer = new ExpressionLexer($text);
        $this->resourceType = $resourceType;
        $this->isPHPExpressionProvider = $isPHPExpressionProvider;
        $this->hasLevel2PropertyInTheExpression = false;
    }

    /**
     * Checks whether the expression contains level 2 property access.
     *
     * @return bool
     */
    public function hasLevel2Property()
    {
        return $this->hasLevel2PropertyInTheExpression;
    }

    /**
     * Get the current token from lexer.
     *
     * @return ExpressionToken
     */
    private function getCurrentToken()
    {
        return $this->lexer->getCurrentToken();
    }

    /**
     * Set the current token in lexer.
     *
     * @param ExpressionToken $token The token to set as current token
     */
    private function setCurrentToken($token)
    {
        $this->lexer->setCurrentToken($token);
    }

    /**
     * Resets parser with new expression string.
     *
     * @param string $text Reset the expression to parse
     */
    public function resetParser($text)
    {
        $this->lexer = new ExpressionLexer($text);
        $this->recursionDepth = 0;
    }

    /**
     * Parse the expression in filter option.
     *
     * @return AbstractExpression
     */
    public function parseFilter()
    {
        return $this->parseExpression();
    }

    /**
     * Start parsing the expression.
     *
     * @return AbstractExpression
     */
    private function parseExpression()
    {
        $this->recurseEnter();
        $expr = $this->parseLogicalOr();
        $this->recurseLeave();

        return $expr;
    }

    /**
     * Parse logical or (or).
     *
     * @return AbstractExpression
     */
    private function parseLogicalOr()

    {
        $this->recurseEnter();
        $left = $this->parseLogicalAnd();
        while ($this->tokenIdentifierIs(ODataConstants::KEYWORD_OR)) {
            $logicalOpToken = clone $this->getCurrentToken();
            $this->lexer->nextToken();
            $right = $this->parseLogicalAnd();
            FunctionDescription::verifyLogicalOpArguments($logicalOpToken, $left, $right);
            $left = new LogicalExpression(
                $left,
                $right,
                ExpressionType::OR_LOGICAL
            );
        }

        $this->recurseLeave();

        return $left;
    }

    /**
     * Parse logical and (and).
     *
     * @return AbstractExpression
     */
    private function parseLogicalAnd()

    {
        $this->recurseEnter();
        $left = $this->parseComparison();
        while ($this->tokenIdentifierIs(ODataConstants::KEYWORD_AND)) {
            $logicalOpToken = clone $this->getCurrentToken();
            $this->lexer->nextToken();
            $right = $this->parseComparison();
            FunctionDescription::verifyLogicalOpArguments($logicalOpToken, $left, $right);
            $left = new LogicalExpression($left, $right, ExpressionType::AND_LOGICAL);
        }

        $this->recurseLeave();

        return $left;
    }

    /**
     * Parse comparison operation (eq, ne, gt, ge, lt, le).
     *
     * @return AbstractExpression
     */
    private function parseComparison()
    {
        $this->recurseEnter();
        $left = $this->parseAdditive();
        while ($this->getCurrentToken()->isComparisonOperator()) {
            $comparisonToken = clone $this->getCurrentToken();
            $this->lexer->nextToken();
            $right = $this->parseAdditive();
            $left = self::generateComparisonExpression(
                $left,
                $right,
                $comparisonToken,
                $this->isPHPExpressionProvider
            );
        }

        $this->recurseLeave();

        return $left;
    }

    /**
     * Parse additive operation (add, sub).
     *
     * @return AbstractExpression
     */
    private function parseAdditive()
    {
        $this->recurseEnter();
        $left = $this->parseMultiplicative();
        while ($this->getCurrentToken()->identifierIs(ODataConstants::KEYWORD_ADD)
            || $this->getCurrentToken()->identifierIs(ODataConstants::KEYWORD_SUB)) {
            $additiveToken = clone $this->getCurrentToken();
            $this->lexer->nextToken();
            $right = $this->parseMultiplicative();
            $opReturnType = FunctionDescription::verifyAndPromoteArithmeticOpArguments($additiveToken, $left, $right);
            if ($additiveToken->identifierIs(ODataConstants::KEYWORD_ADD)) {
                $left = new ArithmeticExpression($left, $right, ExpressionType::ADD, $opReturnType);
            } else {
                $left = new ArithmeticExpression($left, $right, ExpressionType::SUBTRACT, $opReturnType);
            }
        }

        $this->recurseLeave();

        return $left;
    }

    /**
     * Parse multipicative operators (mul, div, mod).
     *
     * @return AbstractExpression
     */
    private function parseMultiplicative()
    {
        $this->recurseEnter();
        $left = $this->parseUnary();
        while ($this->getCurrentToken()->identifierIs(ODataConstants::KEYWORD_MULTIPLY)
            || $this->getCurrentToken()->identifierIs(ODataConstants::KEYWORD_DIVIDE)
            || $this->getCurrentToken()->identifierIs(ODataConstants::KEYWORD_MODULO)
        ) {
            $multiplicativeToken = clone $this->getCurrentToken();
            $this->lexer->nextToken();
            $right = $this->parseUnary();
            $opReturnType = FunctionDescription::verifyAndPromoteArithmeticOpArguments(
                $multiplicativeToken,
                $left,
                $right
            );
            if ($multiplicativeToken->identifierIs(ODataConstants::KEYWORD_MULTIPLY)) {
                $left = new ArithmeticExpression($left, $right, ExpressionType::MULTIPLY, $opReturnType);
            } elseif ($multiplicativeToken->identifierIs(ODataConstants::KEYWORD_DIVIDE)) {
                $left = new ArithmeticExpression($left, $right, ExpressionType::DIVIDE, $opReturnType);
            } else {
                $left = new ArithmeticExpression($left, $right, ExpressionType::MODULO, $opReturnType);
            }
        }

        $this->recurseLeave();

        return $left;
    }

    /**
     * Parse unary operator (- ,not).
     *
     * @return AbstractExpression
     */
    private function parseUnary()
    {
        $this->recurseEnter();

        if ($this->getCurrentToken()->Id == ExpressionTokenId::MINUS
            || $this->getCurrentToken()->identifierIs(ODataConstants::KEYWORD_NOT)
        ) {
            $op = clone $this->getCurrentToken();

            $this->lexer->nextToken();
            if ($op->Id == ExpressionTokenId::MINUS
                && (ExpressionLexer::isNumeric($this->getCurrentToken()->Id))
            ) {
                $numberLiteral = $this->getCurrentToken();
                $numberLiteral->Text = '-' . $numberLiteral->Text;
                $numberLiteral->Position = $op->Position;
                $v = $this->getCurrentToken();
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
                $this->setCurrentToken($numberLiteral);
                $this->recurseLeave();

                return $this->parsePrimary();
            }

            $expr = $this->parsePrimary();
            FunctionDescription::validateUnaryOpArguments($op, $expr);
            if ($op->Id == ExpressionTokenId::MINUS) {
                $expr = new UnaryExpression($expr, ExpressionType::NEGATE, $expr->getType());
            } else {
                $expr = new UnaryExpression($expr, ExpressionType::NOT_LOGICAL, new Boolean());
            }

            $this->recurseLeave();

            return $expr;
        }

        $this->recurseLeave();

        return $this->parsePrimary();
    }

    /**
     * Start parsing the primary.
     *
     * @return AbstractExpression
     */
    private function parsePrimary()
    {
        $this->recurseEnter();
        $expr = $this->parsePrimaryStart();
        while (true) {

            if ($this->getCurrentToken()->Id == ExpressionTokenId::SLASH) {
                $this->lexer->nextToken();
                $expr = $this->parsePropertyAccess($expr);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            } else {
                break;
            }
        }

        $this->recurseLeave();

        return $expr;
    }

    /**
     * Parse primary tokens [literals, identifiers (e.g. function call), open param for sub expressions].
     *
     *
     * @return AbstractExpression
     */
    private function parsePrimaryStart()
    {
        switch ($this->lexer->getCurrentToken()->Id) {
            case ExpressionTokenId::BOOLEAN_LITERAL:
                return $this->parseTypedLiteral(new Boolean());
            case ExpressionTokenId::DATETIME_LITERAL:
                return $this->parseTypedLiteral(new DateTime());
            case ExpressionTokenId::DECIMAL_LITERAL:
                return $this->parseTypedLiteral(new Decimal());
            case ExpressionTokenId::NULL_LITERAL:
                return $this->parseNullLiteral();
            case ExpressionTokenId::IDENTIFIER:
                return $this->parseIdentifier();
            case ExpressionTokenId::STRING_LITERAL:
                return $this->parseTypedLiteral(new StringType());
            case ExpressionTokenId::INT64_LITERAL:
                return $this->parseTypedLiteral(new Int64());
            case ExpressionTokenId::INTEGER_LITERAL:
                return $this->parseTypedLiteral(new Int32());
            case ExpressionTokenId::DOUBLE_LITERAL:
                return $this->parseTypedLiteral(new Double());
            case ExpressionTokenId::SINGLE_LITERAL:
                return $this->parseTypedLiteral(new Single());
            case ExpressionTokenId::GUID_LITERAL:
                return $this->parseTypedLiteral(new Guid());
            case ExpressionTokenId::BINARY_LITERAL:
                throw new NotImplementedException(
                    'Support for binary is not implemented'
                );
                //return $this->parseTypedLiteral(new Binary());

            case ExpressionTokenId::OPENPARAM:
                return $this->parseParenExpression();
            default:
                throw ODataException::createSyntaxError('Expression expected.');
        }
    }

    /**
     * Parse Sub expression.
     *
     * @return AbstractExpression
     */
    private function parseParenExpression()

    {
        if ($this->getCurrentToken()->Id != ExpressionTokenId::OPENPARAM) {
            throw ODataException::createSyntaxError('Open parenthesis expected.');
        }

        $this->lexer->nextToken();
        $expr = $this->parseExpression();
        if ($this->getCurrentToken()->Id != ExpressionTokenId::CLOSEPARAM) {
            throw ODataException::createSyntaxError('Close parenthesis expected.');
        }

        $this->lexer->nextToken();

        return $expr;
    }

    /**
     * Parse an identifier.
     *
     * @return AbstractExpression

     */
    private function parseIdentifier()
    {
        $this->validateToken(ExpressionTokenId::IDENTIFIER);

        // An open paren here would indicate calling a method
        $identifierIsFunction = $this->lexer->peekNextToken()->Id == ExpressionTokenId::OPENPARAM;
        if ($identifierIsFunction) {
            return $this->parseIdentifierAsFunction();
        } else {
            return $this->parsePropertyAccess(null);
        }
    }

    /**
     * Parse a property access.
     *
     * @param PropertyAccessExpression $parentExpression Parent expression

     *
     * @throws ODataException
     *
     * @return PropertyAccessExpression
     */
    private function parsePropertyAccess(PropertyAccessExpression $parentExpression = null)
    {
        $identifier = $this->getCurrentToken()->getIdentifier();
        if (is_null($parentExpression)) {
            $parentResourceType = $this->resourceType;
        } else {
            $parentResourceType = $parentExpression->getResourceType();
            $this->hasLevel2PropertyInTheExpression = true;
        }

        $resourceProperty = $parentResourceType->resolveProperty($identifier);
        if (is_null($resourceProperty)) {
            throw ODataException::createSyntaxError(
                Messages::expressionLexerNoPropertyInType(
                    $identifier,
                    $parentResourceType->getFullName(),
                    $this->getCurrentToken()->Position
                )
            );
        }

        if ($resourceProperty->getKind() == ResourcePropertyKind::RESOURCESET_REFERENCE) {
            throw ODataException::createSyntaxError(
                Messages::expressionParserEntityCollectionNotAllowedInFilter(
                    $resourceProperty->getName(),
                    $parentResourceType->getFullName(),
                    $this->getCurrentToken()->Position
                )
            );
        }

        $exp = new PropertyAccessExpression($parentExpression, $resourceProperty);
function notNullable(stdClass $x) { }

// Unsafe
function withoutCheck(stdClass $x = null) {
    notNullable($x);
}

// Safe - Alternative 1: Adding Additional Type-Check
function withCheck(stdClass $x = null) {
    if ($x instanceof stdClass) {
        notNullable($x);
    }
}

// Safe - Alternative 2: Changing Parameter
function withNonNullableParam(stdClass $x) {
    notNullable($x);
}
        $this->lexer->nextToken();

        return $exp;
    }

    /**
     * Try to parse an identifier which is followed by an opern bracket as
     * astoria URI function call.
     *
     * @throws ODataException
     *
     * @return AbstractExpression

     */
    private function parseIdentifierAsFunction()
    {
        $functionToken = clone $this->getCurrentToken();
        $functions = FunctionDescription::verifyFunctionExists($functionToken);
        $this->lexer->nextToken();
        $paramExpressions = $this->parseArgumentList();
        $function = FunctionDescription::verifyFunctionCallOpArguments(
            $functions,
            $paramExpressions,
            $functionToken
        );

        return new FunctionCallExpression($function, $paramExpressions);
    }

    /**
     * Start parsing argument list of a function-call.
     *
     * @return array<AbstractExpression>
     */
    private function parseArgumentList()

    {
        if ($this->getCurrentToken()->Id != ExpressionTokenId::OPENPARAM) {
            throw ODataException::createSyntaxError('Open parenthesis expected.');
        }

        $this->lexer->nextToken();
        $args = $this->getCurrentToken()->Id != ExpressionTokenId::CLOSEPARAM
             ? $this->parseArguments() : [];
        if ($this->getCurrentToken()->Id != ExpressionTokenId::CLOSEPARAM) {
            throw ODataException::createSyntaxError('Close parenthesis expected.');
        }

        $this->lexer->nextToken();

        return $args;
    }

    /**
     * Parse arguments of  a function-call.
     *
     * @return array<AbstractExpression>
     */
    private function parseArguments()
    {
        $argList = [];
        while (true) {

            $argList[] = $this->parseExpression();
            if ($this->getCurrentToken()->Id != ExpressionTokenId::COMMA) {
                break;
            }

            $this->lexer->nextToken();
        }

        return $argList;
    }

    /**
     * Parse primitive type literal.
     *
     * @param IType $targetType Expected type of the current literal
     *
     * @throws ODataException
     *
     * @return AbstractExpression

     */
    private function parseTypedLiteral(IType $targetType)
    {
        $literal = $this->lexer->getCurrentToken()->Text;
        $outVal = null;
        if (!$targetType->validate($literal, $outVal)) {
            throw ODataException::createSyntaxError(
                Messages::expressionParserUnrecognizedLiteral(
                    $targetType->getFullTypeName(),
                    $literal,
                    $this->lexer->getCurrentToken()->Position
                )
            );
        }

        $result = new ConstantExpression($outVal, $targetType);
        $this->lexer->nextToken();

        return $result;
    }

    /**
     * Parse null literal.
     *
     * @return ConstantExpression
     */
    private function parseNullLiteral()
    {
        $this->lexer->nextToken();

        return new ConstantExpression(null, new Null1());
    }

    /**
     * Check the current token is of a specific kind.
     *
     * @param ExpressionTokenId $expressionTokenId Token to check
     *                                             with current token
     *
     * @return bool
     */
    private function tokenIdentifierIs($expressionTokenId)

    {
        return $this->getCurrentToken()->identifierIs($expressionTokenId);
    }

    /**
     * Validate the current token.
     *
     * @param ExpressionTokenId $expressionTokenId Token to check
     *                                             with current token
     *
     * @throws ODataException
     */
    private function validateToken($expressionTokenId)
    {
        if ($this->getCurrentToken()->Id != $expressionTokenId) {
            throw ODataException::createSyntaxError('Syntax error.');
        }
    }

    /**
     * Increment recursion count and throw error if beyond limit.
     *
     *
     * @throws ODataException If max recursion limit hits
     */
    private function recurseEnter()
    {
        ++$this->recursionDepth;
        if ($this->recursionDepth == self::RECURSION_LIMIT) {
            throw ODataException::createSyntaxError('Recursion limit reached.');
        }
    }

    /**
     * Decrement recursion count.
     */
    private function recurseLeave()
    {
        --$this->recursionDepth;
    }

    /**
     * Generates Comparison Expression.
     *
     * @param AbstractExpression $left                    The LHS expression
     * @param AbstractExpression $right                   The RHS expression
     * @param ExpressionToken    $expressionToken         The comparison expression token
     * @param bool               $isPHPExpressionProvider
     *
     * @return AbstractExpression

     */
    private static function generateComparisonExpression($left, $right, $expressionToken, $isPHPExpressionProvider)

    {
        FunctionDescription::verifyRelationalOpArguments($expressionToken, $left, $right);

        //We need special handling for comparison of following types:
        //1. EdmString
        //2. DateTime
        //3. Guid
        //4. Binary
        //Will make these comparison as function calls, which will
        // be converted to language specific function call by expression
        // provider
        $string = new StringType();
        if ($left->typeIs($string) && $right->typeIs($string)) {

            $strcmpFunctions = FunctionDescription::stringComparisonFunctions();
            $left = new FunctionCallExpression($strcmpFunctions[0], [$left, $right]);

            $right = new ConstantExpression(0, new Int32());

        }

        $dateTime = new DateTime();
        if ($left->typeIs($dateTime) && $right->typeIs($dateTime)) {

            $dateTimeCmpFunctions = FunctionDescription::dateTimeComparisonFunctions();
            $left = new FunctionCallExpression($dateTimeCmpFunctions[0], [$left, $right]);

            $right = new ConstantExpression(0, new Int32());

        }

        $guid = new Guid();
        if ($left->typeIs($guid) && $right->typeIs($guid)) {

            $guidEqualityFunctions = FunctionDescription::guidEqualityFunctions();

            $left = new FunctionCallExpression($guidEqualityFunctions[0], [$left, $right]);

            $right = new ConstantExpression(true, new Boolean());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }

        $binary = new Binary();
        if ($left->typeIs($binary) && $right->typeIs($binary)) {

            $binaryEqualityFunctions = FunctionDescription::binaryEqualityFunctions();

            $left = new FunctionCallExpression($binaryEqualityFunctions[0], [$left, $right]);

            $right = new ConstantExpression(true, new Boolean());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }

        $null = new Null1();
        if ($left->typeIs($null) || $right->typeIs($null)) {
            // If the end user is responsible for implementing IExpressionProvider
            // then the sub-tree for a nullability check would be:

            //          RelationalExpression(EQ/NE)
            //                    |
            //               ------------
            //               |           |
            //               |           |
            //            CustomerID    NULL

            // Otherwise (In case of default PHPExpressionProvider):

            //  CustomerID eq null
            //  ==================

            //              FunctionCallExpression(is_null)
            //                       |
            //                       |- Signature => bool (typeof(CustomerID))

            //                       |- args => {CustomerID}


            //  CustomerID ne null
            //  ==================

            //              UnaryExpression (not)
            //                       |
            //              FunctionCallExpression(is_null)
            //                       |
            //                       |- Signature => bool (typeof(CustomerID))

            //                       |- args => {CustomerID}


            if ($isPHPExpressionProvider) {
                $arg = $left->typeIs($null) ? $right : $left;
                $isNullFunctionDescription = new FunctionDescription('is_null', new Boolean(), [$arg->getType()]);

                switch ($expressionToken->Text) {
                    case ODataConstants::KEYWORD_EQUAL:
                        return new FunctionCallExpression($isNullFunctionDescription, [$arg]);
                        break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

                    case ODataConstants::KEYWORD_NOT_EQUAL:
                        return new UnaryExpression(
                            new FunctionCallExpression($isNullFunctionDescription, [$arg]),
                            ExpressionType::NOT_LOGICAL,
                            new Boolean()
                        );
                        break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
                }
            }
        }

        switch ($expressionToken->Text) {
            case ODataConstants::KEYWORD_EQUAL:
                return new RelationalExpression(
                    $left,
                    $right,
                    ExpressionType::EQUAL
                );
            case ODataConstants::KEYWORD_NOT_EQUAL:
                return new RelationalExpression(
                    $left,
                    $right,
                    ExpressionType::NOTEQUAL
                );
            case ODataConstants::KEYWORD_GREATERTHAN:
                return new RelationalExpression(
                    $left,
                    $right,
                    ExpressionType::GREATERTHAN
                );
            case ODataConstants::KEYWORD_GREATERTHAN_OR_EQUAL:
                return new RelationalExpression(
                    $left,
                    $right,
                    ExpressionType::GREATERTHAN_OR_EQUAL
                );
            case ODataConstants::KEYWORD_LESSTHAN:
                return new RelationalExpression(
                    $left,
                    $right,
                    ExpressionType::LESSTHAN
                );
            default:
                return new RelationalExpression(
                    $left,
                    $right,
                    ExpressionType::LESSTHAN_OR_EQUAL
                );
        }
    }
}

1			<?php
2
3			namespace POData\UriProcessor\QueryProcessor\ExpressionParser;
4
5			use POData\Common\Messages;
6			use POData\Common\NotImplementedException;
7			use POData\Common\ODataConstants;
8			use POData\Common\ODataException;
9			use POData\Providers\Metadata\ResourcePropertyKind;
10			use POData\Providers\Metadata\ResourceType;
11			use POData\Providers\Metadata\Type\Binary;
12			use POData\Providers\Metadata\Type\Boolean;
13			use POData\Providers\Metadata\Type\DateTime;
14			use POData\Providers\Metadata\Type\Decimal;
15			use POData\Providers\Metadata\Type\Double;
16			use POData\Providers\Metadata\Type\Guid;
17			use POData\Providers\Metadata\Type\Int32;
18			use POData\Providers\Metadata\Type\Int64;
19			use POData\Providers\Metadata\Type\IType;
20			use POData\Providers\Metadata\Type\Null1;
21			use POData\Providers\Metadata\Type\Single;
22			use POData\Providers\Metadata\Type\StringType;
23			use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\AbstractExpression;
24			use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\ArithmeticExpression;
25			use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\ConstantExpression;
26			use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\ExpressionType;
27			use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\FunctionCallExpression;
28			use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\LogicalExpression;
29			use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\PropertyAccessExpression;
30			use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\RelationalExpression;
31			use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\UnaryExpression;
32			use POData\UriProcessor\QueryProcessor\FunctionDescription;
33
34			/**
35			* Class ExpressionParser.
36			*/
37			class ExpressionParser
38			{
39			const RECURSION_LIMIT = 200;
40
Algo-Web / POData

Pull Request — master (#120)

ExpressionParser::parsePrimaryStart() C

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like
