ExpressionParser2 - Code Metrics - Inspection of "WIP: Post metadata bug stomp" - Algo-Web/POData - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#77)

by Alex

created 2017-05-19 03:33 UTC

ExpressionParser2 D

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	504
Duplicated Lines	5.36 %

Coupling/Cohesion

Components	1
Dependencies	15

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
wmc	60
c	1
b	0
f	0
lcom	1
cbo	15
dl	27
loc	504
rs	4.2857

12 Methods

Rating	Name	Duplication	Size	Complexity
A	parseExpression2()	0	21	3
A	__construct()	0	6	1
A	parseFilter()	0	17	4
C	processNodeForNullability()	0	29	8
B	processArithmeticNode()	9	23	4
C	processFunctionCallNode()	0	41	8
C	processLogicalNode()	9	59	9
A	processPropertyAccessNode()	0	22	3
B	processRelationalNode()	9	37	6
B	processUnaryNode()	0	35	5
B	mergeNullableExpressionTrees()	0	39	3
B	map()	0	25	6

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like ExpressionParser2 often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use ExpressionParser2, and based on these observations, apply Extract Interface, too.

<?php

namespace POData\UriProcessor\QueryProcessor\ExpressionParser;

use POData\Common\Messages;
use POData\Common\ODataException;
use POData\Providers\Expression\IExpressionProvider;
use POData\Providers\Expression\PHPExpressionProvider;
use POData\Providers\Metadata\ResourceType;
use POData\Providers\Metadata\Type\Boolean;
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 ExpressionParser2.
 *
 * Build the basic expression tree for a given expression using base class
 * ExpressionParser, modify the expression tree to have null checks
 */
class ExpressionParser2 extends ExpressionParser
{
    /**
     * @var array
     */
    private $mapTable;

    /**
     * Collection of navigation properties used in the expression.
     *
     * @var array(array(ResourceProperty))
     */
    private $navigationPropertiesUsedInTheExpression;

    /**
     * Indicates whether the end user has implemented IExpressionProvider or not.
     *
     * @var bool
     */
    private $isPHPExpressionProvider;

    /**
     * Create new instance of ExpressionParser2.
     *
     * @param string       $text                    The text expression to parse
     * @param ResourceType $resourceType            The resource type in which
     *                                              expression will be applied
     * @param bool         $isPHPExpressionProvider True if IExpressionProvider provider is
     *                                              implemented by user, False otherwise
     */
    public function __construct($text, ResourceType $resourceType, $isPHPExpressionProvider)
    {
        parent::__construct($text, $resourceType, $isPHPExpressionProvider);
        $this->navigationPropertiesUsedInTheExpression = [];
        $this->isPHPExpressionProvider = $isPHPExpressionProvider;
    }

    /**
     * Parse and generate expression from the the given odata expression.
     *
     *
     * @param string              $text               The text expression to parse
     * @param ResourceType        $resourceType       The resource type in which
     * @param IExpressionProvider $expressionProvider Implementation of IExpressionProvider
     *
     * @throws ODataException If any error occurs while parsing the odata expression or
     * building the php/custom expression
     *
     * @return FilterInfo
     */
    public static function parseExpression2($text, ResourceType $resourceType, IExpressionProvider $expressionProvider)
    {
        $expressionParser2 = new self($text, $resourceType, $expressionProvider instanceof PHPExpressionProvider);
        $expressionTree = $expressionParser2->parseFilter();

        $expressionAsString = null;

        $expressionProvider->setResourceType($resourceType);
        $expressionProcessor = new ExpressionProcessor($expressionProvider);

        try {
            $expressionAsString = $expressionProcessor->processExpression($expressionTree);
        } catch (\InvalidArgumentException $invalidArgumentException) {
            throw ODataException::createInternalServerError($invalidArgumentException->getMessage());
        }
        $expressionAsString = (null !== $expressionAsString) ? $expressionAsString : "";
        return new FilterInfo(
            $expressionParser2->navigationPropertiesUsedInTheExpression,
            $expressionAsString
        );
    }

    /**
     * Parse the expression.
     *
     * @see library/POData/QueryProcessor/ExpressionParser::parseFilter()
     *
     * @throws ODataException
     *
     * @return AbstractExpression
     */
    public function parseFilter()
    {
        $expression = parent::parseFilter();
        if (!$expression->typeIs(new Boolean())) {
            throw ODataException::createSyntaxError(
                Messages::expressionParser2BooleanRequired()
            );
        }
        if ($this->isPHPExpressionProvider) {
            $resultExpression = $this->processNodeForNullability($expression, null);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            if (null != $resultExpression) {
                return $resultExpression;
            }
        }

        return $expression;
    }

    /**
     * Process the expression node for nullability.
     *
     * @param AbstractExpression $expression            The expression node to process
     * @param AbstractExpression $parentExpression      The parent expression of expression node to process
     * @param bool               $checkNullForMostChild whether to include null check for current property
     *
     * @throws ODataException
     *
     * @return AbstractExpression New expression tree with nullability check
     */
    private function processNodeForNullability(
        $expression,
        $parentExpression,
        $checkNullForMostChild = true
    ) {
        if ($expression instanceof ArithmeticExpression) {
            return $this->processArithmeticNode($expression);
        } elseif ($expression instanceof ConstantExpression) {
            return;
        } elseif ($expression instanceof FunctionCallExpression) {
            return $this->processFunctionCallNode($expression, $parentExpression);
        } elseif ($expression instanceof LogicalExpression) {
            return $this->processLogicalNode($expression, $parentExpression);
        } elseif ($expression instanceof PropertyAccessExpression) {
            return $this->processPropertyAccessNode(
                $expression,
                $parentExpression,
                $checkNullForMostChild
            );
        } elseif ($expression instanceof RelationalExpression) {
            return $this->processRelationalNode($expression, $parentExpression);
        } elseif ($expression instanceof UnaryExpression) {
            return $this->processUnaryNode($expression, $parentExpression);
        }

        throw ODataException::createSyntaxError(
            Messages::expressionParser2UnexpectedExpression(get_class($expression))
        );
    }

    /**
     * Process an arithmetic expression node for nullability.
     *
     * @param ArithmeticExpression $expression The arithmetic expression node
     *                                         to process
     *
     * @return AbstractExpression|null
     */
    private function processArithmeticNode(ArithmeticExpression $expression)
    {
        $leftNullableExpTree = $this->processNodeForNullability(
            $expression->getLeft(),
            $expression
        );
        $rightNullableExpTree = $this->processNodeForNullability(
            $expression->getRight(),
            $expression
        );
        $resultExpression = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        if ($leftNullableExpTree != null && $rightNullableExpTree != null) {

            $resultExpression = $this->mergeNullableExpressionTrees(
                $leftNullableExpTree,
                $rightNullableExpTree
            );
        } else {
            $resultExpression = $leftNullableExpTree != null
                               ? $leftNullableExpTree : $rightNullableExpTree;
        }

        return $resultExpression;
    }

    /**
     * Process an arithmetic expression node for nullability.
     *
     * @param FunctionCallExpression $expression       The function call expression
     *                                                 node to process
     * @param AbstractExpression     $parentExpression The parent expression of
     *                                                 expression node to process
     *
     * @return null|AbstractExpression
     */
    private function processFunctionCallNode(
        FunctionCallExpression $expression,
        $parentExpression
    ) {
        $paramExpressions = $expression->getParamExpressions();
        $checkNullForMostChild
            = strcmp(
                $expression->getFunctionDescription()->name,
                'is_null'
            ) === 0;
        $resultExpression = null;
        foreach ($paramExpressions as $paramExpression) {
            $resultExpression1 = $this->processNodeForNullability(
                $paramExpression,
                $expression,
                !$checkNullForMostChild
            );
            if (null != $resultExpression1 && null != $resultExpression) {
                $resultExpression = $this->mergeNullableExpressionTrees(
                    $resultExpression,
                    $resultExpression1
                );
            } elseif (null != $resultExpression1 && null == $resultExpression) {
                $resultExpression = $resultExpression1;
            }
        }

        if (null == $resultExpression) {
            return null;
        }

        if (null == $parentExpression) {
            return new LogicalExpression(
                $resultExpression,
                $expression,
                ExpressionType::AND_LOGICAL
            );
        }

        return $resultExpression;
    }

    /**
     * Process an logical expression node for nullability.
     *
     * @param LogicalExpression  $expression       The logical expression node
     *                                             to process
     * @param AbstractExpression $parentExpression The parent expression of
     *                                             expression node to process
     *
     * @return null|AbstractExpression
     */
    private function processLogicalNode(
        LogicalExpression $expression,
        $parentExpression
    ) {
        $leftNullableExpTree = $this->processNodeForNullability(
            $expression->getLeft(),
            $expression
        );
        $rightNullableExpTree = $this->processNodeForNullability(
            $expression->getRight(),
            $expression
        );
        if ($expression->getNodeType() == ExpressionType::OR_LOGICAL) {
            if (null !== $leftNullableExpTree) {
                $resultExpression = new LogicalExpression(
                    $leftNullableExpTree,
                    $expression->getLeft(),
                    ExpressionType::AND_LOGICAL
                );
                $expression->setLeft($resultExpression);
            }

            if (null !== $rightNullableExpTree) {
                $resultExpression = new LogicalExpression(
                    $rightNullableExpTree,
                    $expression->getRight(),
                    ExpressionType::AND_LOGICAL
                );
                $expression->setRight($resultExpression);
            }

            return null;
        }

        $resultExpression = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        if (null != $leftNullableExpTree && null != $rightNullableExpTree) {

            $resultExpression = $this->mergeNullableExpressionTrees(
                $leftNullableExpTree,
                $rightNullableExpTree
            );
        } else {
            $resultExpression = null != $leftNullableExpTree
                               ? $leftNullableExpTree : $rightNullableExpTree;
        }

        if (null == $resultExpression) {
            return null;
        }

        if (null == $parentExpression) {
            return new LogicalExpression(
                $resultExpression,
                $expression,
                ExpressionType::AND_LOGICAL
            );
        }

        return $resultExpression;
    }

    /**
     * Process an property access expression node for nullability.
     *
     * @param PropertyAccessExpression $expression            The property access
     *                                                        expression node to process
     * @param AbstractExpression       $parentExpression      The parent expression of
     *                                                        expression node to process
     * @param bool                     $checkNullForMostChild Wheter to check null for
     *                                                        most child node or not
     *
     * @return LogicalExpression|RelationalExpression|null
     */
    private function processPropertyAccessNode(
        PropertyAccessExpression $expression,
        $parentExpression,
        $checkNullForMostChild
    ) {
        $navigationsUsed = $expression->getNavigationPropertiesInThePath();
        if (!empty($navigationsUsed)) {
            $this->navigationPropertiesUsedInTheExpression[] = $navigationsUsed;
        }

        $nullableExpTree = $expression->createNullableExpressionTree($checkNullForMostChild);

        if (null == $parentExpression) {
            return new LogicalExpression(
                $nullableExpTree,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                $expression,
                ExpressionType::AND_LOGICAL
            );
        }

        return $nullableExpTree;
    }

    /**
     * Process a releational expression node for nullability.
     *
     * @param RelationalExpression $expression       The relational expression node
     *                                               to process
     * @param AbstractExpression   $parentExpression The parent expression of
     *                                               expression node to process
     *
     * @return null|AbstractExpression
     */
    private function processRelationalNode(
        RelationalExpression $expression,
        $parentExpression
    ) {
        $leftNullableExpTree = $this->processNodeForNullability(
            $expression->getLeft(),
            $expression
        );
        $rightNullableExpTree = $this->processNodeForNullability(
            $expression->getRight(),
            $expression
        );
        $resultExpression = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        if (null != $leftNullableExpTree && null != $rightNullableExpTree) {

            $resultExpression = $this->mergeNullableExpressionTrees(
                $leftNullableExpTree,
                $rightNullableExpTree
            );
        } else {
            $resultExpression = $leftNullableExpTree != null
                               ? $leftNullableExpTree : $rightNullableExpTree;
        }

        if (null == $resultExpression) {
            return null;
        }

        if (null == $parentExpression) {
            return new LogicalExpression(
                $resultExpression,
                $expression,
                ExpressionType::AND_LOGICAL
            );
        }

        return $resultExpression;
    }

    /**
     * Process an unary expression node for nullability.
     *
     * @param UnaryExpression    $expression       The unary expression node
     *                                             to process
     * @param AbstractExpression $parentExpression The parent expression of
     *                                             expression node to process
     *
     * @return AbstractExpression|null
     */
    private function processUnaryNode(
        UnaryExpression $expression,
        $parentExpression
    ) {
        if (ExpressionType::NEGATE == $expression->getNodeType()) {
            return $this->processNodeForNullability(
                $expression->getChild(),
                $expression
            );
        }

        if (ExpressionType::NOT_LOGICAL == $expression->getNodeType()) {
            $resultExpression = $this->processNodeForNullability(
                $expression->getChild(),
                $expression
            );
            if (null == $resultExpression) {
                return null;
            }

            if (null == $parentExpression) {
                return new LogicalExpression(
                    $resultExpression,
                    $expression,
                    ExpressionType::AND_LOGICAL
                );
            }

            return $resultExpression;
        }

        throw ODataException::createSyntaxError(
            Messages::expressionParser2UnexpectedExpression(get_class($expression))
        );
    }

    /**
     * Merge two null check expression trees by removing duplicate nodes.
     *
     * @param AbstractExpression $nullCheckExpTree1 First expression
     * @param AbstractExpression $nullCheckExpTree2 Second expression
     *
     * @return AbstractExpression
     */
    private function mergeNullableExpressionTrees(
        $nullCheckExpTree1,
        $nullCheckExpTree2
    ) {
        $this->mapTable = [];
        $this->map($nullCheckExpTree1);
        $this->map($nullCheckExpTree2);
        $expression = null;
        $isNullFunctionDescription = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        foreach ($this->mapTable as $node) {
            if (null == $expression) {
                $expression = new UnaryExpression(
                    new FunctionCallExpression(
                        FunctionDescription::isNullCheckFunction($node->getType()),
                        [$node]
                    ),
                    ExpressionType::NOT_LOGICAL,
                    new Boolean()
                );
            } else {
                $expression = new LogicalExpression(
                    $expression,
                    new UnaryExpression(
                        new FunctionCallExpression(
                            FunctionDescription::isNullCheckFunction(
                                $node->getType()
                            ),
                            [$node]
                        ),
                        ExpressionType::NOT_LOGICAL,
                        new Boolean()
                    ),
                    ExpressionType::AND_LOGICAL
                );
            }
        }

        return $expression;
    }

    /**
     *  Populate map table.
     *
     * @param AbstractExpression $nullCheckExpTree The expression to verfiy
     *
     * @throws ODataException
     */
    private function map($nullCheckExpTree)
    {
        if ($nullCheckExpTree instanceof LogicalExpression) {
            $this->map($nullCheckExpTree->getLeft());
            $this->map($nullCheckExpTree->getRight());
        } elseif ($nullCheckExpTree instanceof UnaryExpression) {
            $this->map($nullCheckExpTree->getChild());
        } elseif ($nullCheckExpTree instanceof FunctionCallExpression) {
            $param = $nullCheckExpTree->getParamExpressions();
            $this->map($param[0]);
        } elseif ($nullCheckExpTree instanceof PropertyAccessExpression) {
            $parent = $nullCheckExpTree;
            $key = null;
            do {
                $key = $parent->getResourceProperty()->getName() . '_' . $key;
                $parent = $parent->getParent();
            } while (null != $parent);

            $this->mapTable[$key] = $nullCheckExpTree;
        } else {
            throw ODataException::createSyntaxError(
                Messages::expressionParser2UnexpectedExpression(get_class($nullCheckExpTree))
            );
        }
    }
}


Algo-Web / POData