anonymous//src/Engine/Impl/El/JuelExpressionManager.php$0 - Code Metrics - Inspection of "fix: fix scrutinizer issues like variables usage e..." - bingo-soft/jabe - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Push — main ( 2f8de4...07b5fa )

by Bingo
created 2022-08-02 08:08 UTC
anager.php$0 A

↳ Parent: JuelExpressionManager::createFunctionMapper()
Complexity

Total Complexity
Size/Duplication

Total Lines	11
Duplicated Lines	0 %
Importance

Changes	1
Bugs	1	Features	0
Metric	Value
wmc	2
dl	0
loc	11
rs	10
c	1
b	1
f	0
<?php

namespace Jabe\Engine\Impl\El;

use Jabe\Engine\Delegate\VariableScopeInterface;
use Jabe\Engine\Impl\Core\Variable\Scope\AbstractVariableScope;
use Jabe\Engine\Impl\Util\El\{
    ArrayELResolver,
    CompositeELResolver,
    ELContext,
    ELResolver,
    ExpressionFactory,
    FunctionMapper,
    ListELResolver,
    MapELResolver,
    ValueExpression
};
use Jabe\Engine\Impl\Juel\ExpressionFactoryImpl;
use Jabe\Engine\Impl\Util\EnsureUtil;
use Jabe\Engine\Test\Mock\MockElResolver;
use Jabe\Engine\Variable\Context\VariableContextInterface;

class JuelExpressionManager implements ExpressionManagerInterface, ElProviderCompatibleInterface
{
    protected $functions = [];
    protected $expressionFactory;
    protected $beans = [];
    protected $initialized = false;
    protected $elResolver;
    protected $functionMapper;
    // Default implementation (does nothing)
    protected $parsingElContext;
    protected $elProvider;

    public function __construct(array $beans = [])
    {
        // Use the ExpressionFactoryImpl built-in version of juel, with parametrised
        // method expressions enabled
        $this->expressionFactory = new ExpressionFactoryImpl();
        $this->beans = $beans;
    }

    public function createExpression(string $expression): ExpressionInterface
    {
        $this->ensureInitialized();
        $valueExpression = $this->createValueExpression($expression);
        return new JuelExpression($valueExpression, $this, $expression);
    }

    public function addFunction(string $name, \ReflectionMethod $function): void
    {
        EnsureUtil::ensureNotEmpty("name", "name", $name);
        EnsureUtil::ensureNotEmpty("name", "name", /** @scrutinizer ignore-type */ $name);
        EnsureUtil::ensureNotNull("function", "function", $function);
        $this->functions[$name] = $function;
    }

    public function createValueExpression(string $expression): ValueExpression
    {
        $this->ensureInitialized();
        $instance = new \stdClass();
        return $this->expressionFactory->createValueExpression($parsingElContext, $expression, $instance);

    }

    public function setExpressionFactory(ExpressionFactory $expressionFactory): void
    {
        $this->expressionFactory = $expressionFactory;
    }

    public function getElContext(VariableScopeInterface $variableScope): ELContext
    {
        $this->ensureInitialized();
        $elContext = null;
        if ($variableScope instanceof AbstractVariableScopeInterface) {
            $variableScopeImpl = $variableScope;
            $elContext = $variableScopeImpl->getCachedElContext();
            $elContext = $variableScopeImpl->getCachedElContext();
        }

        if ($elContext === null) {
            $elContext = $this->createElContext($variableScope);
            if ($variableScope instanceof AbstractVariableScopeInterface) {
                $variableScope->setCachedElContext($elContext);
                                setCachedElContext($elContext);
            }
        }

        return $elContext;
    }

    protected function createElContext(/*VariableScopeInterface|VariableContextInterface*/$variableScopeOrContext): ProcessEngineElContext
    {
        if ($variableScopeOrContext instanceof VariableScopeInterface) {
            $this->ensureInitialized();
            $elContext = new ProcessEngineElContext($this->functionMapper, $this->elResolver);
            $elContext->putContext(ExpressionFactory::class, $this->expressionFactory);
            $elContext->putContext(VariableScopeInterface::class, $variableScopeOrContext);
            return $elContext;
        } elseif ($variableScopeOrContext instanceof VariableContextInterface) {
            $this->ensureInitialized();
            $elContext = new ProcessEngineElContext($this->functionMapper, $this->elResolver);
            $elContext->putContext(ExpressionFactory::class, $this->expressionFactory);
            $elContext->putContext(VariableContextInterface::class, $variableScopeOrContext);
            return $elContext;
        }
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
    }

    protected function ensureInitialized(): void
    {
        if (!$this->initialized) {
            $this->elResolver = $this->createElResolver();
            $this->functionMapper = $this->createFunctionMapper();
            $this->parsingElContext = new ProcessEngineElContext($this->functionMapper);
            $this->initialized = true;
        }
    }

    protected function createElResolver(VariableScopeInterface $scope = null): ELResolver
    protected function createElResolver(/** @scrutinizer ignore-unused */ VariableScopeInterface $scope = null): ELResolver
    {
        $elResolver = new CompositeELResolver();
        $elResolver->add(new VariableScopeElResolver());
        $elResolver->add(new VariableContextElResolver());
        $elResolver->add(new MockElResolver());

        /*if (!empty($this->beans)) {
            // ACT-1102: Also expose all beans in configuration when using standalone
            // engine, not
            // in spring-context
            elResolver.add(new ReadOnlyMapELResolver(beans));
        }*/

        //$elResolver->add(new ProcessApplicationElResolverDelegate());
        $elResolver->add(new ArrayELResolver());
        $elResolver->add(new ListELResolver());
        $elResolver->add(new MapELResolver());
        //$elResolver->add(new ProcessApplicationBeanElResolverDelegate());

        return $elResolver;
    }

    protected function createFunctionMapper(): FunctionMapper
    {
        $function = $this->functions;

        $functionMapper = new class ($functions) extends FunctionMapper {

            private $functions;

            public function __construct(array $functions)
            {
                $this->functions = $functions;
            }

            public function resolveFunction(string $prefix, string $localName): \ReflectionMethod
            {
                return $this->functions[$localName];
            }
        };
        return $functionMapper;
    }

    public function toElProvider()
    {
        if ($this->elProvider == null) {
            $this->elProvider = $this->createElProvider();
        }
        return $this->elProvider;
    }

    protected function createElProvider()
    {
        return new ProcessEngineJuelElProvider($this);
    }
}

bingo-soft / jabe

Push — main ( 2f8de4...07b5fa )

anager.php$0 A

Complexity

Size/Duplication

Importance

Duplication Side-by-Side

Filter issues like
