PHPExpressionProvider::onFunctionCallExpression() - Code Metrics - Inspection of "Update changelog (#184)" - Algo-Web/POData - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Branch — master (950424)

by Christopher
created 2017-12-13 04:53 UTC
PHPExpressionProvider::onFunctionCallExpression() D

↳ Parent: PHPExpressionProvider
Complexity

Conditions	27
Paths	27
Size

Total Lines	84
Code Lines	57
Duplication

Lines	11
Ratio	13.1 %
Importance

Changes
Metric	Value
cc	27
eloc	57
nc	27
nop	2
dl	11
loc	84
rs	4.7908
c	0
b	0
f	0
How to fix Long Method Complexity

<?php

namespace POData\Providers\Expression;

use POData\Common\ODataConstants;
use POData\Providers\Metadata\ResourceType;
use POData\Providers\Metadata\Type\IType;
use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\ExpressionType;
use POData\UriProcessor\QueryProcessor\ExpressionParser\Expressions\PropertyAccessExpression;
use POData\UriProcessor\QueryProcessor\FunctionDescription;

/**
 * Class PHPExpressionProvider.
 */
class PHPExpressionProvider implements IExpressionProvider
{
    const ADD = '+';
    const CLOSE_BRACKET = ')';
    const COMMA = ',';
    const DIVIDE = '/';
    const SUBTRACT = '-';
    const EQUAL = '==';
    const GREATER_THAN = '>';
    const GREATER_THAN_OR_EQUAL = '>=';
    const LESS_THAN = '<';
    const LESS_THAN_OR_EQUAL = '<=';
    const LOGICAL_AND = '&&';
    const LOGICAL_NOT = '!';
    const LOGICAL_OR = '||';
    const MEMBER_ACCESS = '->';
    const MODULO = '%';
    const MULTIPLY = '*';
    const NEGATE = '-';
    const NOT_EQUAL = '!=';
    const OPEN_BRACKET = '(';
    const TYPE_NAMESPACE = 'POData\\Providers\\Metadata\\Type\\';

    /**
     * The name of iterator.
     *
     * @var string
     */
    private $iteratorName;

    /**
     * The type of the resource pointed by the resource path segment.
     *
     * @var ResourceType
     */
    private $resourceType;

    /**
     * @param string $iteratorName The name of the iterator
     */
    public function __construct($iteratorName)
    {
        $this->iteratorName = $iteratorName;
    }

    /**
     * Get the name of the iterator.
     *
     * @return string
     */
    public function getIteratorName()
    {
        return $this->iteratorName;
    }

    /**
     * call-back for setting the resource type.
     *
     * @param ResourceType $resourceType The resource type on which the filter is going to be applied
     *
     * @return void
     */
    public function setResourceType(ResourceType $resourceType)
    {
        $this->resourceType = $resourceType;
    }

    /**
     * Call-back for logical expression.
     *
     * @param ExpressionType $expressionType The type of logical expression
     * @param string         $left           The left expression
     * @param string         $right          The left expression
     *
     * @return string
     */
    public function onLogicalExpression($expressionType, $left, $right)
    {
        assert($expressionType instanceof ExpressionType, get_class($expressionType));
        switch ($expressionType) {
            case ExpressionType::AND_LOGICAL():
            case ExpressionType::/** @scrutinizer ignore-call */ AND_LOGICAL():
                return $this->prepareBinaryExpression(self::LOGICAL_AND, $left, $right);

            case ExpressionType::OR_LOGICAL():
            case ExpressionType::/** @scrutinizer ignore-call */ OR_LOGICAL():
                return $this->prepareBinaryExpression(self::LOGICAL_OR, $left, $right);

            default:
                throw new \InvalidArgumentException('onLogicalExpression');
        }
    }

    /**
     * Call-back for arithmetic expression.
     *
     * @param ExpressionType $expressionType The type of arithmetic expression
     * @param string         $left           The left expression
     * @param string         $right          The left expression
     *
     * @return string
     */
    public function onArithmeticExpression($expressionType, $left, $right)
    {
        switch ($expressionType) {
            case ExpressionType::MULTIPLY():
            case ExpressionType::/** @scrutinizer ignore-call */ MULTIPLY():
                return $this->prepareBinaryExpression(self::MULTIPLY, $left, $right);

            case ExpressionType::DIVIDE():
            case ExpressionType::/** @scrutinizer ignore-call */ DIVIDE():
                return $this->prepareBinaryExpression(self::DIVIDE, $left, $right);

            case ExpressionType::MODULO():
            case ExpressionType::/** @scrutinizer ignore-call */ MODULO():
                return $this->prepareBinaryExpression(self::MODULO, $left, $right);

            case ExpressionType::ADD():
            case ExpressionType::/** @scrutinizer ignore-call */ ADD():
                return $this->prepareBinaryExpression(self::ADD, $left, $right);

            case ExpressionType::SUBTRACT():
            case ExpressionType::/** @scrutinizer ignore-call */ SUBTRACT():
                return $this->prepareBinaryExpression(self::SUBTRACT, $left, $right);

            default:
                throw new \InvalidArgumentException('onArithmeticExpression');
        }
    }

    /**
     * Call-back for relational expression.
     *
     * @param ExpressionType $expressionType The type of relation expression
     * @param string         $left           The left expression
     * @param string         $right          The left expression
     *
     * @return string
     */
    public function onRelationalExpression($expressionType, $left, $right)
    {
        switch ($expressionType) {
            case ExpressionType::GREATERTHAN():
            case ExpressionType::/** @scrutinizer ignore-call */ GREATERTHAN():
                return $this->prepareBinaryExpression(self::GREATER_THAN, $left, $right);

            case ExpressionType::GREATERTHAN_OR_EQUAL():
            case ExpressionType::/** @scrutinizer ignore-call */ GREATERTHAN_OR_EQUAL():
                return $this->prepareBinaryExpression(self::GREATER_THAN_OR_EQUAL, $left, $right);

            case ExpressionType::LESSTHAN():
            case ExpressionType::/** @scrutinizer ignore-call */ LESSTHAN():
                return $this->prepareBinaryExpression(self::LESS_THAN, $left, $right);

            case ExpressionType::LESSTHAN_OR_EQUAL():
            case ExpressionType::/** @scrutinizer ignore-call */ LESSTHAN_OR_EQUAL():
                return $this->prepareBinaryExpression(self::LESS_THAN_OR_EQUAL, $left, $right);

            case ExpressionType::EQUAL():
            case ExpressionType::/** @scrutinizer ignore-call */ EQUAL():
                return $this->prepareBinaryExpression(self::EQUAL, $left, $right);

            case ExpressionType::NOTEQUAL():
            case ExpressionType::/** @scrutinizer ignore-call */ NOTEQUAL():
                return $this->prepareBinaryExpression(self::NOT_EQUAL, $left, $right);

            default:
                throw new \InvalidArgumentException('onRelationalExpression');
        }
    }

    /**
     * Call-back for unary expression.
     *
     * @param ExpressionType $expressionType The type of unary expression
     * @param string         $child          The child expression
     *
     * @return string
     */
    public function onUnaryExpression($expressionType, $child)
    {
        switch ($expressionType) {
            case ExpressionType::NEGATE():
            case ExpressionType::/** @scrutinizer ignore-call */ NEGATE():
                return $this->prepareUnaryExpression(self::NEGATE, $child);

            case ExpressionType::NOT_LOGICAL():
            case ExpressionType::/** @scrutinizer ignore-call */ NOT_LOGICAL():
                return $this->prepareUnaryExpression(self::LOGICAL_NOT, $child);

            default:
                throw new \InvalidArgumentException('onUnaryExpression');
        }
    }

    /**
     * Call-back for constant expression.
     *
     * @param IType $type  The type of constant
     * @param mixed $value The value of the constant
     *
     * @return string
     */
    public function onConstantExpression(IType $type, $value)

    {
        if (is_bool($value)) {
            return var_export($value, true);
        } elseif (null === $value) {
            return var_export(null, true);
        }

        return strval($value);
    }

    /**
     * Call-back for property access expression.
     *
     * @param PropertyAccessExpression $expression The property access expression
     *
     * @return string
     */
    public function onPropertyAccessExpression($expression)
    {
        if (null == $expression) {
            throw new \InvalidArgumentException('onPropertyAccessExpression - expression null');
        }
        if (!($expression instanceof PropertyAccessExpression)) {
            throw new \InvalidArgumentException('onPropertyAccessExpression - expression is incorrect type');
        }
        if (null == $this->resourceType) {
            throw new \InvalidArgumentException('onPropertyAccessExpression - resourceType null');
        }
        if (null == $this->resourceType->getName()) {
            throw new \InvalidArgumentException('onPropertyAccessExpression - resourceType has no name');
        }
        if (null == $expression->getResourceProperty()) {
            throw new \InvalidArgumentException('onPropertyAccessExpression - expression has no resource property');
        }
        $parent = $expression;
        $variable = null;

        do {
            $variable = $parent->getResourceProperty()->getName() . self::MEMBER_ACCESS . $variable;
            $parent = $parent->getParent();
        } while ($parent != null);

        $variable = rtrim($variable, self::MEMBER_ACCESS);
        $variable = $this->getIteratorName() . self::MEMBER_ACCESS . $variable;

        return $variable;
    }

    /**
     * Call-back for function call expression.
     *
     * @param FunctionDescription $functionDescription Description of the function
     * @param array<string>       $params              Parameters to the function
     *
     * @return string
     */
    public function onFunctionCallExpression($functionDescription, $params)
    {
        switch ($functionDescription->name) {
            case ODataConstants::STRFUN_COMPARE:
                return 'strcmp(' . $params[0] . ', ' . $params[1] . ')';

            case ODataConstants::STRFUN_ENDSWITH:
                return '(strcmp(substr(' . $params[0] . ', strlen(' . $params[0] . ') - strlen(' . $params[1] . ')), '
                        .$params[1] . ') === 0)';

            case ODataConstants::STRFUN_INDEXOF:
                return 'strpos(' . $params[0] . ', ' . $params[1] . ')';

            case ODataConstants::STRFUN_REPLACE:

                return 'str_replace(' . $params[1] . ', ' . $params[2] . ', ' . $params[0] . ')';

            case ODataConstants::STRFUN_STARTSWITH:
                return '(strpos(' . $params[0] . ', ' . $params[1] . ') === 0)';

            case ODataConstants::STRFUN_TOLOWER:
                return 'strtolower(' . $params[0] . ')';

            case ODataConstants::STRFUN_TOUPPER:
                return 'strtoupper(' . $params[0] . ')';

            case ODataConstants::STRFUN_TRIM:
                return 'trim(' . $params[0] . ')';

            case ODataConstants::STRFUN_SUBSTRING:

                return count($params) == 3 ?
                    'substr(' . $params[0] . ', ' . $params[1] .
                    ', ' . $params[2] . ')' : 'substr(' . $params[0] .
                    ', ' . $params[1] . ')';

            case ODataConstants::STRFUN_SUBSTRINGOF:
                return '(strpos(' . $params[1] . ', ' . $params[0] . ') !== false)';

            case ODataConstants::STRFUN_CONCAT:
                return $params[0] . ' . ' . $params[1];

            case ODataConstants::STRFUN_LENGTH:
                return 'strlen(' . $params[0] . ')';

            case ODataConstants::GUIDFUN_EQUAL:

                return self::TYPE_NAMESPACE . 'Guid::guidEqual(' . $params[0] . ', ' . $params[1] . ')';

            case ODataConstants::DATETIME_COMPARE:

                return self::TYPE_NAMESPACE . 'DateTime::dateTimeCmp(' . $params[0] . ', ' . $params[1] . ')';

            case ODataConstants::DATETIME_YEAR:
                return self::TYPE_NAMESPACE . 'DateTime::year(' . $params[0] . ')';

            case ODataConstants::DATETIME_MONTH:
                return self::TYPE_NAMESPACE . 'DateTime::month(' . $params[0] . ')';

            case ODataConstants::DATETIME_DAY:
                return self::TYPE_NAMESPACE . 'DateTime::day(' . $params[0] . ')';

            case ODataConstants::DATETIME_HOUR:
                return self::TYPE_NAMESPACE . 'DateTime::hour(' . $params[0] . ')';

            case ODataConstants::DATETIME_MINUTE:
                return self::TYPE_NAMESPACE . 'DateTime::minute(' . $params[0] . ')';

            case ODataConstants::DATETIME_SECOND:
                return self::TYPE_NAMESPACE . 'DateTime::second(' . $params[0] . ')';

            case ODataConstants::MATHFUN_ROUND:
                return 'round(' . $params[0] . ')';

            case ODataConstants::MATHFUN_CEILING:
                return 'ceil(' . $params[0] . ')';

            case ODataConstants::MATHFUN_FLOOR:
                return 'floor(' . $params[0] . ')';

            case ODataConstants::BINFUL_EQUAL:

                return self::TYPE_NAMESPACE . 'Binary::binaryEqual(' . $params[0] . ', ' . $params[1] . ')';

            case 'is_null':
                return 'is_null(' . $params[0] . ')';

            default:
                throw new \InvalidArgumentException('onFunctionCallExpression');
        }
    }

    /**
     * To format binary expression.
     *
     * @param string $operator The binary operator
     * @param string $left     The left operand
     * @param string $right    The right operand
     *
     * @return string
     */
    private function prepareBinaryExpression($operator, $left, $right)
    {
        return
            self::OPEN_BRACKET . $left . ' ' . $operator . ' ' . $right . self::CLOSE_BRACKET;
    }

    /**
     * To format unary expression.
     *
     * @param string $operator The unary operator
     * @param string $child    The operand
     *
     * @return string
     */
    private function prepareUnaryExpression($operator, $child)
    {
        return $operator . self::OPEN_BRACKET . $child . self::CLOSE_BRACKET;
    }
}

Algo-Web / POData

Branch — master (950424)

PHPExpressionProvider::onFunctionCallExpression() D

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
