LaravelFreelancerNL\FluentAQL\Expressions\ArithmeticExpression

Complexity

Total Complexity

6

Size/Duplication

Total Lines	71
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	5
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	compile()	0	16	3
A	__construct()	0	3	1
A	normalizeCalculation()	0	20	2

<?php

declare(strict_types=1);

namespace LaravelFreelancerNL\FluentAQL\Expressions;

use LaravelFreelancerNL\FluentAQL\Exceptions\ExpressionTypeException;
use LaravelFreelancerNL\FluentAQL\QueryBuilder;

class ArithmeticExpression extends PredicateExpression implements ExpressionInterface
{

    /**
     * @var array<mixed>
     */
    protected array $calculation = [];

    /**
     * Create predicate expression.
     *
     * @param mixed $leftOperand
     * @param string $operator
     * @param mixed $rightOperand
     */
    public function __construct(mixed $leftOperand, string $operator, mixed $rightOperand)
    {
        $this->calculation = [$leftOperand, $operator, $rightOperand];
    }

    /**
     * Compile calculation.
     *
     * @param  QueryBuilder|null  $queryBuilder
     * @return string
     * @throws \Exception
     */
    public function compile(QueryBuilder $queryBuilder = null): string
    {
        /** @phpstan-ignore-next-line */
        $normalizedCalculation = $this->normalizeCalculation($queryBuilder, $this->calculation);

It seems like $queryBuilder can also be of type null; however, parameter $queryBuilder of LaravelFreelancerNL\FluentAQL\Expressions\ArithmeticExpression::normalizeCalculation() does only seem to accept LaravelFreelancerNL\FluentAQL\QueryBuilder, maybe add an additional type check?

        $leftOperand = $normalizedCalculation['leftOperand']->compile($queryBuilder);

It seems like $queryBuilder can also be of type null; however, parameter $queryBuilder of LaravelFreelancerNL\FluentAQL\QueryElement::compile() does only seem to accept LaravelFreelancerNL\FluentAQL\QueryBuilder, maybe add an additional type check?

        if ($normalizedCalculation['leftOperand'] instanceof ArithmeticExpression) {
            $leftOperand = '(' . $leftOperand . ')';
        }

        $rightOperand = $normalizedCalculation['rightOperand']->compile($queryBuilder);
        if ($normalizedCalculation['rightOperand'] instanceof ArithmeticExpression) {
            $rightOperand = '(' . $rightOperand . ')';
        }

        return $leftOperand . ' ' . $normalizedCalculation['arithmeticOperator'] . ' ' . $rightOperand;
    }

    /**
     * @param  QueryBuilder  $queryBuilder
     * @param  array<mixed>  $calculation
     * @return array<mixed>
     * @throws ExpressionTypeException
     */
    public function normalizeCalculation(
        QueryBuilder $queryBuilder,
        array $calculation
    ): array {
        $normalizedCalculation = [];

        $leftOperand = $queryBuilder->normalizeArgument($calculation[0]);

        $arithmeticOperator = '+';
        if ($queryBuilder->grammar->isArithmeticOperator($calculation[1])) {
            $arithmeticOperator = $calculation[1];
        }

        $rightOperand = $queryBuilder->normalizeArgument($calculation[2]);

        $normalizedCalculation['leftOperand'] = $leftOperand;
        $normalizedCalculation['arithmeticOperator'] = $arithmeticOperator;
        $normalizedCalculation['rightOperand'] = $rightOperand;

        return $normalizedCalculation;
    }
}