ExpressionParser2 - Code Metrics - Qeti/POData - Measure and Improve Code Quality continuously with Scrutinizer

ExpressionParser2 D
last analyzed 2017-02-19 06:57 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	502
Duplicated Lines	5.38 %

Coupling/Cohesion

Components	1
Dependencies	15

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
wmc	59
lcom	1
cbo	15
dl	27
loc	502
rs	4.5454
c	1
b	0
f	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	parseExpression2()	0	23	2
A	parseFilter()	0	16	4
C	_processNodeForNullability()	0	27	8
B	_processArithmeticNode()	9	23	4
C	_processFunctionCallNode()	0	40	8
C	_processLogicalNode()	9	58	9
A	_processPropertyAccessNode()	0	21	3
B	_processRelationalNode()	9	36	6
B	_processUnaryNode()	0	34	5
B	_mergeNullableExpressionTrees()	0	38	3
B	_map()	0	26	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\PHPExpressionProvider;
use POData\Providers\Metadata\Type\Boolean;
use POData\Providers\Metadata\ResourceType;
use POData\Providers\Metadata\ResourceTypeKind;
use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\AbstractExpression;
use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\ArithmeticExpression;
use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\LogicalExpression;
use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\RelationalExpression;
use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\ConstantExpression;
use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\PropertyAccessExpression;
use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\FunctionCallExpression;
use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\UnaryExpression;
use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\ExpressionType;
use POData\UriProcessor\QueryProcessor\FunctionDescription;
use POData\Providers\Expression\IExpressionProvider;

/**
 * Class ExpressionParser2
 *
 * Build the basic expression tree for a given expression using base class
 * ExpressionParser, modify the expression tree to have null checks
 *
 * @package POData\UriProcessor\QueryProcessor\ExpressionParser
 */
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 = array();
        $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
     * 
     * @return FilterInfo
     * 
     * @throws ODataException If any error occurs while parsing the odata expression or building the php/custom expression.
     *
     */
    public static function parseExpression2($text, ResourceType $resourceType, \POData\Providers\Expression\IExpressionProvider $expressionProvider) {

        $expressionParser2 = new ExpressionParser2($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() );
        }

        
        return new FilterInfo(
            $expressionParser2->_navigationPropertiesUsedInTheExpression,
            $expressionAsString
        );
    }

    /**
     * Parse the expression
     * 
     * @see library/POData/QueryProcessor/ExpressionParser::parseFilter()
     * 
     * @return AbstractExpression
     * 
     * @throws ODataException
     */
    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 ($resultExpression != null) {
                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 boolean            $checkNullForMostChild whether to include null check for current property.
     * 
     * @return AbstractExpression New expression tree with nullability check
     * 
     * @throws ODataException
     */
    private function _processNodeForNullability($expression, $parentExpression, 
        $checkNullForMostChild = true
    ) {
        if ($expression instanceof ArithmeticExpression) {
            return $this->_processArithmeticNode($expression);
        } else if ($expression instanceof ConstantExpression) {
            return null;
        } else if ($expression instanceof FunctionCallExpression) {
            return $this->_processFunctionCallNode($expression, $parentExpression);
        } else if ($expression instanceof LogicalExpression) {
            return $this->_processLogicalNode($expression, $parentExpression);
        } else if ($expression instanceof PropertyAccessExpression) {
            return $this->_processPropertyAccessNode(
                $expression, 
                $parentExpression, 
                $checkNullForMostChild
            );
        } else if ($expression instanceof RelationalExpression) {
            return $this->_processRelationalNode($expression, $parentExpression);
        } else if ($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 LogicalExpression|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 LogicalExpression|null
     */
    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 ($resultExpression1 != null && $resultExpression != null) {
                $resultExpression = $this->_mergeNullableExpressionTrees(
                    $resultExpression, 
                    $resultExpression1
                );
            } else if ($resultExpression1 != null && $resultExpression == null) {
                $resultExpression = $resultExpression1;
            }
        }
        
        if ($resultExpression == null) {
            return null;
        }
           
        if ($parentExpression == null) {
            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 LogicalExpression|null
     */
    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 ($leftNullableExpTree !== null) {
                $resultExpression = new LogicalExpression(
                    $leftNullableExpTree, 
                    $expression->getLeft(), 
                    ExpressionType::AND_LOGICAL
                );
                $expression->setLeft($resultExpression);
            }
             
            if ($rightNullableExpTree !== null) {
                $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 ($leftNullableExpTree != null && $rightNullableExpTree != null) {

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

        if ($resultExpression == null) {
               return null;
        }
           
        if ($parentExpression == null) {
            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 boolean                  $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 ($parentExpression == null) {
            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 LogicalExpression|null
     */
    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 ($leftNullableExpTree != null && $rightNullableExpTree != null) {

            $resultExpression = $this->_mergeNullableExpressionTrees(
                $leftNullableExpTree, 
                $rightNullableExpTree
            );
        } else {
            $resultExpression = $leftNullableExpTree != null 
                               ? $leftNullableExpTree : $rightNullableExpTree; 
        }
        
        if ($resultExpression == null) {
               return null;
        }
           
        if ($parentExpression == null) {
            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 LogicalExpression|null
     */
    private function _processUnaryNode(UnaryExpression $expression, 
        $parentExpression
    ) {       
        if ($expression->getNodeType() == ExpressionType::NEGATE) {
            return $this->_processNodeForNullability(
                $expression->getChild(), 
                $expression
            );
        }

        if ($expression->getNodeType() == ExpressionType::NOT_LOGICAL) {
            $resultExpression = $this->_processNodeForNullability(
                $expression->getChild(), 
                $expression
            );
            if ($resultExpression == null) {
                return null;
            }
           
            if ($parentExpression == null) {
                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 UnaryExpression|LogicalExpression
     */
    private function _mergeNullableExpressionTrees($nullCheckExpTree1, 
        $nullCheckExpTree2
    ) {
        $this->_mapTable = array();
        $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 ($expression == null) {
                $expression = new UnaryExpression(
                    new FunctionCallExpression(
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                        FunctionDescription::isNullCheckFunction($node->getType()), 
                        array($node)
                    ), 
                    ExpressionType::NOT_LOGICAL, 
                    new Boolean()
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                );
            } else {
                $expression = new LogicalExpression(
                    $expression, 
                    new UnaryExpression(
                        new FunctionCallExpression(
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                            FunctionDescription::isNullCheckFunction(
                                $node->getType()
                            ), 
                            array($node)
                        ), 
                        ExpressionType::NOT_LOGICAL, 
                        new Boolean()
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                    ), 
                    ExpressionType::AND_LOGICAL
                ); 
            }
        }
        
        return $expression;
    }

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

Qeti / POData

ExpressionParser2 D last analyzed 2017-02-19 06:57 UTC