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

Complexity

Total Complexity

16

Size/Duplication

Total Lines	90
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	9

Test Coverage

Coverage

100%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	container.php$0 ➔ parser()	0	8	1
A	container.php$0 ➔ evaluator()	0	8	2
A	container.php$0 ➔ tokenFactory()	0	8	2
A	container.php$0 ➔ compiler()	0	8	2
A	container.php$0 ➔ ast()	0	7	1
A	container.php$0 ➔ tokenizer()	0	8	2
A	container.php$0 ➔ javascript()	0	8	2
A	container.php$0 ➔ tokenStream()	0	8	2
A	container.php$0 ➔ expressionFactory()	0	8	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\Rules;

use nicoSWD\Rules\TokenStream\AST;
use nicoSWD\Rules\Compiler\CompilerFactory;
use nicoSWD\Rules\Evaluator\Evaluator;
use nicoSWD\Rules\Evaluator\EvaluatorInterface;
use nicoSWD\Rules\Expressions\ExpressionFactory;
use nicoSWD\Rules\Grammar\JavaScript\JavaScript;
use nicoSWD\Rules\Tokenizer\Tokenizer;
use nicoSWD\Rules\Tokens\TokenFactory;
use nicoSWD\Rules\TokenStream\TokenStream;

return new class
{
    private static $tokenStream;
    private static $tokenFactory;
    private static $compiler;
    private static $javaScript;
    private static $expressionFactory;
    private static $tokenizer;
    private static $evaluator;

    public function parser(array $variables): Parser
    {
        return new 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::tokenStream());
        $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 tokenStream(): TokenStream
    {
        if (!isset(self::$tokenStream)) {
            self::$tokenStream = new TokenStream();
        }

        return self::$tokenStream;
    }

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

        return self::$expressionFactory;
    }
};