Sufir\Calc\Calc

Complexity

Total Complexity

24

Size/Duplication

Total Lines	165
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

98.75%

Importance

Changes	6
Bugs	3	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
C	evaluate()	0	67	12
A	registerFunction()	0	18	2
A	defineVar()	0	17	3
B	math()	0	15	6

<?php

/**
 * Calc.php
 *
 * @date 28.03.2015 0:54:24
 * @copyright Sklyarov Alexey <sufir@mihailovka.info>
 */

namespace Sufir\Calc;

use Sufir\Calc\Token;
use SplStack;
use Closure;
use ReflectionObject;
use RuntimeException;
use Sufir\Calc\Token\NumberToken;
use Sufir\Calc\Token\FunctionToken;
use Sufir\Calc\Token\VariableToken;
use InvalidArgumentException;

/**
 * Calc
 *
 * Description of Calc
 *
 * @author Sklyarov Alexey <sufir@mihailovka.info>
 * @package Sufir\Calc
 */
final class Calc
{
    private $functions = [];

    private $variables = [];

    //protected $allowedPhpFunctions = false;

50% of this comment could be valid code. Did you maybe forget this after debugging?

    /**
     * @param integer $scale
     */
    public function __construct($scale = 5)
    {
        bcscale($scale);
    }

    /**
     *
     * @param Token $tokens
     * @param array $variables
     * @return string
     * @throws RuntimeException
     */
    public function evaluate(array $tokens, array $variables = [])

The parameter $variables is not used and could be removed.

    {
        $stack = new SplStack;

        //var_dump($tokens);

        foreach ($tokens as $token) {
            if ($token->isNumber()) {
                $stack->push($token);

            } elseif ($token->isVariable()) {
                if (!isset($this->variables[$token->getValue()])) {
                    throw new RuntimeException(
                        "Undefined variable: «{$token}»"
                    );
                }

                $stack->push(new NumberToken($this->variables[$token->getValue()]));

            } elseif ($token->isOperator()) {
                if ($stack->count() > 1) {
                    $second = $stack->pop();
                    $first = $stack->pop();

                    $result = self::math($token->getValue(), $first->getValue(), $second->getValue());

                    $stack->push(new NumberToken($result));
                } else {
                    throw new RuntimeException(
                        "Not enough operands for a binary operator: «{$token}»"
                    );
                }

            } elseif ($token->isFunction()) {
                if (!isset($this->functions[$token->getValue()])) {
                    throw new RuntimeException("Undefined function: «{$token}()»");
                }

                $countOfArguments = $this->functions[$token->getValue()]['args'];

                if ($stack->count() < $countOfArguments) {
                    throw new RuntimeException(
                        "Wrong argenents for function «{$token}()»:"
                        . "defined {$stack->count()} expected {$countOfArguments}"
                    );
                }

                $arguments = [];
                for ($idx = 0; $idx < $countOfArguments; $idx++) {
                    $arguments[] = $stack->pop()->getValue();
                }
                $arguments = array_reverse($arguments);

                $result = call_user_func_array($this->functions[$token->getValue()]['func'], $arguments);

                if (!is_numeric($result)) {
                    throw new RuntimeException(
                        "Wrong result type of «{$token->getValue()}()» function, expected integer or float"
                    );
                }

                $stack->push(new NumberToken($result));
            }
        }

        return $stack->top()->getValue();
    }

    /**
     * Register new function.
     *
     * @param string $name
     * @param Closure $callable
     * @return \Sufir\Calc\Calc
     */
    public function registerFunction($name, Closure $callable)
    {
        $name = rtrim($name, " \t\n\r\0\x0B\(\)");
        if (!FunctionToken::validate($name)) {
            throw new InvalidArgumentException("Wrong function name «{$name}»");
        }

        $objReflector = new ReflectionObject($callable);
        $reflector = $objReflector->getMethod('__invoke');
        $parameters = $reflector->getParameters();

        $this->functions[$name] = array(
            'args' => count($parameters),
            'func' => $callable,
        );

        return $this;
    }

    /**
     * Define new variable.
     *
     * @param string $name
     * @param integer $value
     * @return \Sufir\Calc\Calc
     * @throws RuntimeException
     */
    public function defineVar($name, $value)
    {
        $name = '$' . ltrim($name, " \t\n\r\0\x0B\$");
        if (!VariableToken::validate($name)) {
            throw new InvalidArgumentException("Wrong variable name «{$name}»");
        }

        if (!is_numeric($value)) {
            throw new InvalidArgumentException(
                "Wrong type of «{$name}», expected integer or float"
            );
        }

        $this->variables[$name] = $value;

        return $this;
    }

    /**
     * @param string $operator
     * @param integer|float $firstOperand
     * @param integer|float $secondOperand
     * @return int
     */
    private static function math($operator, $firstOperand, $secondOperand)
    {
        switch ($operator) {
            case '^':
                return bcpow($firstOperand, $secondOperand);
            case '*':
                return bcmul($firstOperand, $secondOperand);
            case '/':
                return bcdiv($firstOperand, $secondOperand);
            case '+':
                return bcadd($firstOperand, $secondOperand);
            case '-':
                return bcsub($firstOperand, $secondOperand);
        }
    }
}