nicoSWD\Rule\anonymous//src/container.php$0

Complexity

Total Complexity

18

Size/Duplication

Total Lines	107
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	10

Test Coverage

Coverage

100%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	container.php$0 ➔ javascript()	0	7	2
A	container.php$0 ➔ expressionFactory()	0	7	2
A	container.php$0 ➔ parser()	0	6	1
A	container.php$0 ➔ tokenizer()	0	7	2
A	container.php$0 ➔ compiler()	0	7	2
A	container.php$0 ➔ tokenStreamFactory()	0	7	2
A	container.php$0 ➔ userMethodFactory()	0	7	2
A	container.php$0 ➔ ast()	0	6	1
A	container.php$0 ➔ tokenFactory()	0	7	2
A	container.php$0 ➔ evaluator()	0	7	2

<?php declare(strict_types=1);

/**
 * @license     http://opensource.org/licenses/mit-license.php MIT
 * @link        https://github.com/nicoSWD
 * @author      Nicolas Oelgart <nico@oelgart.com>
 */
namespace nicoSWD\Rule;

use nicoSWD\Rule\Grammar\JavaScript\JavaScript;
use nicoSWD\Rule\TokenStream\AST;
use nicoSWD\Rule\Compiler\CompilerFactory;
use nicoSWD\Rule\Evaluator\Evaluator;
use nicoSWD\Rule\Evaluator\EvaluatorInterface;
use nicoSWD\Rule\Expression\ExpressionFactory;
use nicoSWD\Rule\Tokenizer\Tokenizer;
use nicoSWD\Rule\TokenStream\Token\TokenFactory;
use nicoSWD\Rule\TokenStream\TokenStreamFactory;
use nicoSWD\Rule\TokenStream\CallableUserMethodFactory;

return new class {
    /** @var TokenStreamFactory */
    private static $tokenStreamFactory;
    /** @var TokenFactory */
    private static $tokenFactory;
    /** @var CompilerFactory */
    private static $compiler;
    /** @var JavaScript */
    private static $javaScript;
    /** @var ExpressionFactory */
    private static $expressionFactory;
    /** @var CallableUserMethodFactory */
    private static $userMethodFactory;
    /** @var Tokenizer */
    private static $tokenizer;
    /** @var Evaluator */
    private static $evaluator;

    public function parser(array $variables): Parser\Parser
    {
        return new Parser\Parser(
            self::ast($variables),
            self::expressionFactory(),
            self::compiler()
        );
    }

    public function evaluator(): EvaluatorInterface
    {
        if (!isset(self::$evaluator)) {
            self::$evaluator = new Evaluator();
        }

        return self::$evaluator;
    }

    private static function tokenFactory(): TokenFactory
    {
        if (!isset(self::$tokenFactory)) {
            self::$tokenFactory = new TokenFactory();
        }

        return self::$tokenFactory;
    }

    private static function compiler(): CompilerFactory
    {
        if (!isset(self::$compiler)) {
            self::$compiler = new CompilerFactory();
        }

        return self::$compiler;
    }

    private static function ast(array $variables): AST
    {
        $ast = new AST(self::tokenizer(), self::tokenFactory(), self::tokenStreamFactory(), self::userMethodFactory());
        $ast->setVariables($variables);

        return $ast;
    }

    private static function tokenizer(): Tokenizer
    {
        if (!isset(self::$tokenizer)) {
            self::$tokenizer = new Tokenizer(self::javascript(), self::tokenFactory());
        }

        return self::$tokenizer;
    }

    private static function javascript(): JavaScript
    {
        if (!isset(self::$javaScript)) {
            self::$javaScript = new JavaScript();
        }

        return self::$javaScript;
    }

    private static function tokenStreamFactory(): TokenStreamFactory
    {
        if (!isset(self::$tokenStreamFactory)) {
            self::$tokenStreamFactory = new TokenStreamFactory();
        }

        return self::$tokenStreamFactory;
    }

    private static function expressionFactory(): ExpressionFactory
    {
        if (!isset(self::$expressionFactory)) {
            self::$expressionFactory = new ExpressionFactory();
        }

        return self::$expressionFactory;
    }

    private static function userMethodFactory(): CallableUserMethodFactory
    {
        if (!isset(self::$userMethodFactory)) {
            self::$userMethodFactory = new CallableUserMethodFactory();
        }

        return self::$userMethodFactory;
    }
};