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

FunctionDescription F
last analyzed 2017-02-19 06:57 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	751
Duplicated Lines	11.45 %

Coupling/Cohesion

Components	1
Dependencies	16

Importance

Changes

Metric	Value
wmc	61
lcom	1
cbo	16
dl	86
loc	751
rs	1.0434
c	0
b	0
f	0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	getPrototypeAsString()	0	10	2
B	filterFunctionDescriptions()	0	166	1
A	stringComparisonFunctions()	0	9	1
A	dateTimeComparisonFunctions()	0	9	1
A	guidEqualityFunctions()	0	9	1
A	binaryEqualityFunctions()	0	9	1
B	arithmeticOperationFunctions()	0	29	1
A	addOperationFunctions()	0	4	1
A	subtractOperationFunctions()	0	4	1
A	logicalOperationFunctions()	0	9	1
B	relationalOperationFunctions()	0	24	1
A	notOperationFunctions()	0	9	1
A	isNullCheckFunction()	0	4	1
A	negateOperationFunctions()	0	11	1
A	incompatibleError()	0	20	3
A	verifyAndPromoteArithmeticOpArguments()	16	16	2
A	verifyLogicalOpArguments()	14	14	2
C	verifyRelationalOpArguments()	40	69	14
B	validateUnaryOpArguments()	16	22	5
A	verifyFunctionExists()	0	15	2
A	verifyFunctionCallOpArguments()	0	22	3
C	findFunctionWithPromotion()	0	60	14

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 FunctionDescription 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 FunctionDescription, and based on these observations, apply Extract Interface, too.

<?php

namespace POData\UriProcessor\QueryProcessor;

use POData\Common\ODataException;
use POData\Common\Messages;
use POData\Common\ODataConstants;
use POData\Providers\Metadata\Type\Null1;
use POData\Providers\Metadata\Type\INavigationType;
use POData\Providers\Metadata\Type\Int64;
use POData\Providers\Metadata\Type\Int16;
use POData\Providers\Metadata\Type\Guid;
use POData\Providers\Metadata\Type\Single;
use POData\Providers\Metadata\Type\Double;
use POData\Providers\Metadata\Type\Decimal;
use POData\Providers\Metadata\Type\DateTime;
use POData\Providers\Metadata\Type\Int32;
use POData\Providers\Metadata\Type\StringType;
use POData\Providers\Metadata\Type\Boolean;
use POData\Providers\Metadata\Type\VoidType;
use POData\Providers\Metadata\Type\Binary;
use POData\Providers\Metadata\Type\IType;
use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\ExpressionType;
use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\AbstractExpression;
use POData\UriProcessor\QueryProcessor\ExpressionParser\ExpressionToken;

/**
 * Class FunctionDescription
 *
 * Class to represent function signature including function-name
 *
 * @package POData\UriProcessor\QueryProcessor\FunctionDescription
 */
class FunctionDescription
{
    /**
     * @var string
     */
    public $name;

    /**
     * @var IType
     */
    public $returnType;

    /**
     * @var IType[]
     */
    public $argumentTypes;

    /**
     * Create new instance of FunctionDescription
     * 
     * @param string  $name  Name of the function
     * @param IType   $returnType    Return type
     * @param IType[] $argumentTypes Parameter type
     */
    public function __construct($name, $returnType, $argumentTypes)
    {
        $this->name = $name;
        $this->returnType = $returnType;
        $this->argumentTypes = $argumentTypes;
    }

    /**      
     * Get the function prototype as string
     * 
     * @return string
     */
    public function getPrototypeAsString()
    {
        $str = $this->returnType->getFullTypeName() . ' ' . $this->name . '(';

	    foreach ($this->argumentTypes as $argumentType) {
            $str .= $argumentType->getFullTypeName() . ', ';
        }

        return rtrim($str, ', ') . ')';
    }

    /**      
     * Create function descriptions for supported function-calls in $filter option
     *
     * TODO: FIGURE OUT WHAT THE HECK THIS IS RETURNING!?!?
     *
     * @return array indexed by function name
     */
    public static function filterFunctionDescriptions()
    {
        $functions = array(
            //String Functions
            'endswith'      =>
                array(
                    new FunctionDescription(
                        'endswith', new Boolean(),
                        array(new StringType(), new StringType())
                    )
                ),
            'indexof'       =>
                array(
                    new FunctionDescription(
                        'indexof', new Int32(),
                        array(new StringType(), new StringType())
                    )
                ),
            'replace'       =>
                array(
                    new FunctionDescription(
                        'replace', new StringType(),
                        array(new StringType(), new StringType(), new StringType())
                    )
                ),
            'startswith'    =>
                array(
                    new FunctionDescription(
                        'startswith', new Boolean(),
                        array(new StringType(), new StringType())
                    )
                ),
            'tolower'       =>
                array(
                    new FunctionDescription(
                        'tolower', new StringType(),
                        array(new StringType())
                    )
                ),
            'toupper'       =>
                array(
                    new FunctionDescription(
                        'toupper', new StringType(),
                        array(new StringType())
                    )
                ),
            'trim'          =>
                array(
                    new FunctionDescription(
                        'trim', new StringType(),
                        array(new StringType())
                    )
                ),
            'substring'     =>
                array(
                    new FunctionDescription(
                        'substring', new StringType(),
                        array(new StringType(), new Int32())
                    ),
                    new FunctionDescription(
                        'substring', new StringType(),
                        array(new StringType(), new Int32(), new Int32())
                    )
                ),
            'substringof'   =>
                array(
                    new FunctionDescription(
                        'substringof', new Boolean(),
                        array(new StringType(), new StringType())
                    )
                ),
            'concat'        =>
                array(
                    new FunctionDescription(
                        'concat', new StringType(),
                        array(new StringType(), new StringType())
                    )
                ),
            'length'        =>
                array(
                    new FunctionDescription(
                        'length', new Int32(),
                        array(new StringType())
                    )
                ),
            //DateTime functions
            'year'          =>
                array(
                    new FunctionDescription(
                        'year', new Int32(),
                        array(new DateTime())
                    )
                ),
            'month'         =>
                array(
                    new FunctionDescription(
                        'month', new Int32(),
                        array(new DateTime())
                    )
                ),
            'day'           =>
                array(
                    new FunctionDescription(
                        'day', new Int32(),
                        array(new DateTime())
                    )
                ),
            'hour'          =>
                array(
                    new FunctionDescription(
                        'hour', new Int32(),
                        array(new DateTime())
                    )
                ),
            'minute'        =>
                array(
                    new FunctionDescription(
                        'minute', new Int32(),
                        array(new DateTime())
                    )
                ),
            'second'        =>
                array(
                    new FunctionDescription(
                        'second', new Int32(),
                        array(new DateTime())
                    )
                ),
            //Math Functions
            'round'         =>
                array(
                    new FunctionDescription(
                        'round', new Decimal(),
                        array(new Decimal())
                    ),
                    new FunctionDescription(
                        'round', new Double(),
                        array(new Double())
                    )
                ),
            'ceiling'       =>
                array(
                    new FunctionDescription(
                        'ceiling', new Decimal(),
                        array(new Decimal())
                    ),
                    new FunctionDescription(
                        'ceiling', new Double(),
                        array(new Double())
                    )
                ),
            'floor'         =>
                array(
                    new FunctionDescription(
                        'floor', new Decimal(),
                        array(new Decimal())
                    ),
                    new FunctionDescription(
                        'floor', new Double(),
                        array(new Double())
                    )
                )
          );

        return $functions;
    }

    /** 
     * Get function description for string comparison
     * 
     * @return \POData\UriProcessor\QueryProcessor\FunctionDescription[]
     */
    public static function stringComparisonFunctions()
    {
        return array(
            new FunctionDescription(
                'strcmp', new Int32(), 
                array(new StringType(), new StringType())
            )
        );
    }

    /**
     * Get function description for datetime comparison
     * 
     * @return \POData\UriProcessor\QueryProcessor\FunctionDescription[]
     */
    public static function dateTimeComparisonFunctions()
    {
        return array(
            new FunctionDescription(
                'dateTimeCmp', new Int32(), 
                array(new DateTime(), new DateTime())
            )
        );
    }

    /**
     * Get function description for guid equality check
     * 
     * @return \POData\UriProcessor\QueryProcessor\FunctionDescription[]
     */
    public static function guidEqualityFunctions()
    {
        return array(
            new FunctionDescription(
                'guidEqual', new Boolean(), 
                array(new Guid(), new Guid())
            )
        );
    }
    
    /**
     * Get function description for binary equality check
     * 
     * @return \POData\UriProcessor\QueryProcessor\FunctionDescription[]
     */
    public static function binaryEqualityFunctions()
    {
        return array(
            new FunctionDescription(
                'binaryEqual', new Boolean(), 
                array(new Binary(), new Binary())
            )
        );
    }

    /**
     * Get function descriptions for arithmetic operations
     * 
     * @return \POData\UriProcessor\QueryProcessor\FunctionDescription[]
     */
    public static function arithmeticOperationFunctions()
    {      
        return array(
            new FunctionDescription(
                'F', new int16(), 
                array(new int16(), new int16())
            ),
            new FunctionDescription(
                'F', new int32(), 
                array(new int32(), new int32())
            ),
            new FunctionDescription(
                'F', new int64(), 
                array(new int64(), new int64())
            ),
            new FunctionDescription(
                'F', new Single(), 
                array(new Single(), new Single())
            ),
            new FunctionDescription(
                'F', new Double(), 
                array(new Double(), new Double())
            ),
            new FunctionDescription(
                'F', new Decimal(), 
                array(new Decimal(), new Decimal())
            )
        );
    }

    /**      
     * Get function descriptions for arithmetic add operations
     * 
     * @return \POData\UriProcessor\QueryProcessor\FunctionDescription[] indexed by function name
     */
    public static function addOperationFunctions()
    {
        return self::arithmeticOperationFunctions();
    }

    /**
     * Get function descriptions for arithmetic subtract operations
     * 
     * @return \POData\UriProcessor\QueryProcessor\FunctionDescription[] indexed by function name
     */
    public static function subtractOperationFunctions()
    {
        return self::arithmeticOperationFunctions();
    }

    /**      
     * Get function descriptions for logical operations
     * 
     * @return \POData\UriProcessor\QueryProcessor\FunctionDescription[]
     */
    public static function logicalOperationFunctions()
    {
        return array(
            new FunctionDescription(
                'F', new Boolean(), 
                array(new Boolean(), new Boolean())
            )
        );
    }

    /**
     * Get function descriptions for relational operations
     * 
     * @return \POData\UriProcessor\QueryProcessor\FunctionDescription[]
     */
    public static function relationalOperationFunctions()
    {
        return array_merge(
            self::arithmeticOperationFunctions(),
            array(
                new FunctionDescription(
                    'F', new Boolean(), 
                    array(new Boolean(), new Boolean())
                ),
                new FunctionDescription(
                    'F', new DateTime(), 
                    array(new DateTime(), new DateTime())
                ),
                new FunctionDescription(
                    'F', new Guid(), 
                    array(new Guid(), new Guid())
                ),
                new FunctionDescription(
                    'F', new Boolean(), 
                    array(new Binary(), new Binary())
                )
            )
        );
    }

    /**
     * Get function descriptions for unary not operation
     * 
     * @return \POData\UriProcessor\QueryProcessor\FunctionDescription[]
     */
    public static function notOperationFunctions()
    {
        return array(
            new FunctionDescription(
                'F', new Boolean(), 
                array(new Boolean())
            )
        );
    }

    /**
     * Get function description for checking an operand is null or not
     * 
     * @param IType $type Type of the argument to null check function.
     * 
     * @return \POData\UriProcessor\QueryProcessor\FunctionDescription
     */
    public static function isNullCheckFunction(IType $type)
    {
        return new FunctionDescription('is_null', new Boolean(), array($type));
    }
    
    /**      
     * Get function description for unary negate operator
     * 
     * @return \POData\UriProcessor\QueryProcessor\FunctionDescription[]
     */
    public static function negateOperationFunctions()
    {
        return array(
            new FunctionDescription('F', new Int16(), array(new Int16())),
            new FunctionDescription('F', new Int32(), array(new Int32())),
            new FunctionDescription('F', new Int64(), array(new Int64())),
            new FunctionDescription('F', new Single(), array(new Single())),
            new FunctionDescription('F', new Double(), array(new Double())),
            new FunctionDescription('F', new Decimal(), array(new Decimal()))
        );
    }

    /**
     * To throw ODataException for incompatible types
     * 
     * @param ExpressionToken           $expressionToken Expression token
     * @param AbstractExpression[] $argExpressions  Array of argument expression
     * 
     * @throws ODataException
     * @return void
     */
    public static function incompatibleError($expressionToken, $argExpressions)
    {
        $string = null;
        foreach ($argExpressions as $argExpression) {
            $string .= $argExpression->getType()->getFullTypeName() . ', ';
        }

        $string = rtrim($string, ', ');
        $pos = strrpos($string, ', ');
        if ($pos !== false) {
            $string = substr_replace($string, ' and ', strrpos($string, ', '), 2);
        }

        throw ODataException::createSyntaxError(
            Messages::expressionParserInCompatibleTypes(
                $expressionToken->Text, 
                $string, $expressionToken->Position
            )
        );
    }

    /**      
     * Validate operands of an arithmetic operation and promote if required
     * 
     * @param ExpressionToken    $expressionToken The expression token
     * @param AbstractExpression $leftArgument    The left expression
     * @param AbstractExpression $rightArgument   The right expression
     * 
     * @return IType
     */
    public static function verifyAndPromoteArithmeticOpArguments($expressionToken, 

        $leftArgument, $rightArgument
    ) {
        $function  
            = self::findFunctionWithPromotion(
                self::arithmeticOperationFunctions(),
                array($leftArgument, $rightArgument)
            );
        if ($function == null) {
            self::incompatibleError(
                $expressionToken, array($leftArgument, $rightArgument)
            );
        }

        return $function->returnType;
    }
    
    /**      
     * Validate operands of an logical operation
     * 
     * @param ExpressionToken    $expressionToken The expression token
     * @param AbstractExpression $leftArgument    The left expression
     * @param AbstractExpression $rightArgument   The right expression
     * 
     * @return void
     * 
     * @throws ODataException
     */
    public static function verifyLogicalOpArguments($expressionToken, 

        $leftArgument, $rightArgument
    ) {
        $function = self::findFunctionWithPromotion(
            self::logicalOperationFunctions(), 
            array($leftArgument, $rightArgument), false
        );
        if ($function == null) {
            self::incompatibleError(
                $expressionToken, 
                array($leftArgument, $rightArgument)
            );
        }
    }

    /**
     * Validate operands of an relational operation
     * 
     * @param ExpressionToken    $expressionToken The expression token
     * @param AbstractExpression $leftArgument    The left argument expression
     * @param AbstractExpression $rightArgument   The right argument expression
     * 
     * @return void
     */
    public static function verifyRelationalOpArguments($expressionToken, 
        $leftArgument, $rightArgument
    ) {
        //for null operands only equality operators are allowed
        $null = new Null1();
        if ($leftArgument->typeIs($null) || $rightArgument->typeIs($null)) {

            if ((strcmp($expressionToken->Text, ODataConstants::KEYWORD_EQUAL) != 0) 
                && (strcmp($expressionToken->Text, ODataConstants::KEYWORD_NOT_EQUAL) != 0)
            ) {                
                throw ODataException::createSyntaxError(
                    Messages::expressionParserOperatorNotSupportNull(
                        $expressionToken->Text, 
                        $expressionToken->Position
                    )
                );
            }

            return;
        }

        //for guid operands only equality operators are allowed
        $guid = new Guid();
        if ($leftArgument->typeIs($guid) && $rightArgument->typeIs($guid)) {

            if ((strcmp($expressionToken->Text, ODataConstants::KEYWORD_EQUAL) != 0) 
                && (strcmp($expressionToken->Text, ODataConstants::KEYWORD_NOT_EQUAL) != 0)
            ) {                
                throw ODataException::createSyntaxError(
                    Messages::expressionParserOperatorNotSupportGuid(
                        $expressionToken->Text, $expressionToken->Position
                    )
                );
            }

            return;
        }       
        
        //for binary operands only equality operators are allowed
        $binary = new Binary();
        if ($leftArgument->typeIs($binary) && $rightArgument->typeIs($binary)) {

            if ((strcmp($expressionToken->Text, ODataConstants::KEYWORD_EQUAL) != 0) 
                && (strcmp($expressionToken->Text, ODataConstants::KEYWORD_NOT_EQUAL) != 0)
            ) {                
                throw ODataException::createSyntaxError(
                    Messages::expressionParserOperatorNotSupportBinary(
                        $expressionToken->Text, $expressionToken->Position
                    )
                );
            }

            return;
        }
        
        //TODO: eq and ne is valid for 'resource reference' 
        //navigation also verify here

        $functions = array_merge(
            self::relationalOperationFunctions(), 
            self::stringComparisonFunctions()
        );
        $function = self::findFunctionWithPromotion(
            $functions, array($leftArgument, $rightArgument), false
        );
        if ($function == null) {
            self::incompatibleError(
                $expressionToken, 
                array($leftArgument, $rightArgument)
            );
        }
    }

    /**
     * Validate operands of a unary  operation
     * 
     * @param ExpressionToken    $expressionToken The expression token
     * @param AbstractExpression $argExpression   Argument expression
     * 
     * @throws ODataException
     * 
     * @return void
     */
    public static function validateUnaryOpArguments($expressionToken, $argExpression)
    {
        //Unary not
        if (strcmp($expressionToken->Text, ODataConstants::KEYWORD_NOT) == 0 ) {

            $function = self::findFunctionWithPromotion(
                self::notOperationFunctions(), 
                array($argExpression)
            );
            if ($function == null) {
                self::incompatibleError($expressionToken, array($argExpression));
            }

            return;
        }

        //Unary minus (negation)
        if (strcmp($expressionToken->Text, '-') == 0) {

            if (self::findFunctionWithPromotion(self::negateOperationFunctions(), array($argExpression)) == null) {
                self::incompatibleError($expressionToken, array($argExpression));
            }
        }
    }
    
    /**
     * Check am identifier is a valid filter function
     * 
     * @param ExpressionToken $expressionToken The expression token      
     * 
     * @throws ODataException
     * 
     * @return \POData\UriProcessor\QueryProcessor\FunctionDescription[] Array of matching functions
     */
    public static function verifyFunctionExists($expressionToken)
    {
        if (!array_key_exists($expressionToken->Text, self::filterFunctionDescriptions())) {
            throw ODataException::createSyntaxError(
                Messages::expressionParserUnknownFunction(
                    $expressionToken->Text, 
                    $expressionToken->Position
                )
            );
            
        }

        $filterFunctions =  self::filterFunctionDescriptions();
        return $filterFunctions[$expressionToken->Text];
    }

    /**
     * Validate operands (arguments) of a function call operation and return 
     * matching function
     * 
     * @param \POData\UriProcessor\QueryProcessor\FunctionDescription[] $functions       List of functions to be checked
     * @param AbstractExpression[]  $argExpressions  Function argument expressions
     * @param ExpressionToken            $expressionToken Expression token
     * 
     * @throws ODataException
     * 
     * @return \POData\UriProcessor\QueryProcessor\FunctionDescription
     */
    public static function verifyFunctionCallOpArguments($functions, 
        $argExpressions, $expressionToken
    ) {
        $function 
            = self::findFunctionWithPromotion($functions, $argExpressions, false);
        if ($function == null) {
            $protoTypes = null;
            foreach ($functions as $function) {
                $protoTypes .=  $function->getPrototypeAsString() . '; ';
            }

            throw ODataException::createSyntaxError(
                Messages::expressionLexerNoApplicableFunctionsFound(
                    $expressionToken->Text, 
                    $protoTypes, 
                    $expressionToken->Position
                )
            );
        }

        return $function;
    }

    /**
     * Finds a function from the list of functions whose argument types matches 
     * with types of expressions
     * 
     * @param \POData\UriProcessor\QueryProcessor\FunctionDescription[] $functionDescriptions List of functions
     * @param AbstractExpression[]  $argExpressions       Function argument expressions
     * @param Boolean                    $promoteArguments     Function argument
     * 
     * @return \POData\UriProcessor\QueryProcessor\FunctionDescription|null Reference to the matching function if
     *                                  found else NULL
     */
    public static function findFunctionWithPromotion($functionDescriptions, 
        $argExpressions, $promoteArguments = true
    ) {
        $argCount = count($argExpressions);
        $applicableFunctions = array();
        foreach ($functionDescriptions as $functionDescription) {
            if (count($functionDescription->argumentTypes) == $argCount) {
                $applicableFunctions[] = $functionDescription;
            }
        }

        if (empty($applicableFunctions)) {
            return null;
        }

        //Check for exact match
        foreach ($applicableFunctions as $function) {
            $i = 0;
            foreach ($function->argumentTypes as $argumentType) {
                if (!$argExpressions[$i]->typeIs($argumentType)) {
                    break;
                }

                $i++;
            }

            if ($i == $argCount) {
                return $function;
            }
        }

        //Check match with promotion
        $promotedTypes = array();
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        foreach ($applicableFunctions as $function) {
            $i = 0;
            $promotedTypes = array();
            foreach ($function->argumentTypes as $argumentType) {
                if (!$argumentType->isCompatibleWith($argExpressions[$i]->getType())) {
                    break;
                }

                $promotedTypes[] = $argumentType;
                $i++;
            }

            if ($i == $argCount) {
                $i = 0;
                if ($promoteArguments) {
                    //Promote Argument Expressions
                    foreach ($argExpressions as $expression) {
                        $expression->setType($promotedTypes[$i++]);
                    }
                }

                return $function;
            }
        }

        return null;
    }
}

Qeti / POData

FunctionDescription F last analyzed 2017-02-19 06:57 UTC