ScriptUtil::isDynamicScriptExpression() - Code Metrics - Inspection of "feat: port util implementations" - bingo-soft/jabe - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Push — main ( ea931b...8f4107 )

by Bingo
created 2022-07-29 08:45 UTC
ScriptUtil::isDynamicScriptExpression() A

↳ Parent: ScriptUtil
Complexity

Conditions	3
Paths	3
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	1
c	1
b	0
f	0
dl	0
loc	3
rs	10
cc	3
nc	3
nop	2
<?php

namespace Jabe\Engine\Impl\Util;

use Jabe\Engine\Delegate\ExpressionInterface;
use Jabe\Engine\Exception\NotValidException;
use Jabe\Engine\Impl\Cfg\ProcessEngineConfigurationImpl;
use Jabe\Engine\Impl\Context\Context;
use Jabe\Engine\Impl\El\ExpressionManager;
use Jabe\Engine\Impl\Scripting\{
    ExecutableScript,
    ScriptFactory
};
use Jabe\Engine\Impl\Scripting\Engine\JuelScriptEngineFactory;
use Jabe\Engine\Impl\Util\EnsureUtil;

class ScriptUtil
{
    /**
     * Creates a new {@link ExecutableScript} from a source or resource. It excepts static and
     * dynamic sources and resources. Dynamic means that the source or resource is an expression
     * which will be evaluated during execution.
     *
     * @param language the language of the script
     * @param source the source code of the script or an expression which evaluates to the source code
     * @param resource the resource path of the script code or an expression which evaluates to the resource path
     * @param expressionManager the expression manager to use to generate the expressions of dynamic scripts
     * @return the newly created script
     * @throws NotValidException if language is null or empty or both of source and resource are null or empty
     */
    public static function getScript(string $language, string $source, ?string $resource, ?ExpressionManager $expressionManager): ExecutableScript
    {
        $scriptFactory = self::getScriptFactory();
        EnsureUtil::ensureNotEmpty(NotValidException::class, "Script language", $language);
        EnsureUtil::ensureNotEmpty(NotValidException::class, "Script language", /** @scrutinizer ignore-type */ $language);
        EnsureUtil::ensureAtLeastOneNotNull("No script source or resource was given", $source, $resource);
        if (!empty($resource)) {
            return self::getScriptFromResource($language, $resource, $expressionManager, $scriptFactory);
            return self::getScriptFromResource(/** @scrutinizer ignore-type */ $language, $resource, $expressionManager, $scriptFactory);
        } else {
            return self::getScriptFormSource($language, $source, $expressionManager, $scriptFactory);
            return self::/** @scrutinizer ignore-call */ getScriptFormSource($language, $source, $expressionManager, $scriptFactory);
        }
    }

    /**
     * Creates a new {@link ExecutableScript} from a source. It excepts static and dynamic sources.
     * Dynamic means that the source is an expression which will be evaluated during execution.
     *
     * @param language the language of the script
     * @param source the source code of the script or an expression which evaluates to the source code
     * @param expressionManager the expression manager to use to generate the expressions of dynamic scripts
     * @param scriptFactory the script factory used to create the script
     * @return the newly created script
     * @throws NotValidException if language is null or empty or source is null
     */
    public static function getScriptFromSource(string $language, string $source, ?ExpressionManager $expressionManager, ScriptFactory $scriptFactory): ExecutableScript
    {
        EnsureUtil::ensureNotEmpty(NotValidException::class, "Script language", $language);
        EnsureUtil::ensureNotEmpty(NotValidException::class, "Script language", /** @scrutinizer ignore-type */ $language);
        EnsureUtil::ensureNotNull(NotValidException::class, "Script source", $source);
        if (self::isDynamicScriptExpression($language, $source)) {
        if (self::isDynamicScriptExpression(/** @scrutinizer ignore-type */ $language, $source)) {
            $sourceExpression = $expressionManager->createExpression($source);
            $sourceExpression = $expressionManager->createExpression($source);
            return self::getScriptFromSourceExpression($language, $sourceExpression, $scriptFactory);
            return self::getScriptFromSourceExpression(/** @scrutinizer ignore-type */ $language, $sourceExpression, $scriptFactory);
        } else {
            EnsureUtil::ensureNotEmpty(NotValidException::class, "Script language", $language);
            EnsureUtil::ensureNotNull(NotValidException::class, "Script source", $source);
            return $scriptFactory->createScriptFromSource($language, $source);
            return $scriptFactory->createScriptFromSource(/** @scrutinizer ignore-type */ $language, $source);
        }
    }

    /**
     * Creates a new {@link ExecutableScript} from a dynamic source. Dynamic means that the source
     * is an expression which will be evaluated during execution.
     *
     * @param language the language of the script
     * @param sourceExpression the expression which evaluates to the source code
     * @param scriptFactory the script factory used to create the script
     * @return the newly created script
     * @throws NotValidException if language is null or empty or sourceExpression is null
     */
    public static function getScriptFromSourceExpression(string $language, ExpressionInterface $sourceExpression, ScriptFactory $scriptFactory): ExecutableScript
    {
        EnsureUtil::ensureNotEmpty(NotValidException::class, "Script language", $language);
        EnsureUtil::ensureNotEmpty(NotValidException::class, "Script language", /** @scrutinizer ignore-type */ $language);
        EnsureUtil::ensureNotNull(NotValidException::class, "Script source expression", $sourceExpression);
        return $scriptFactory->createScriptFromSource($language, $sourceExpression);
        return $scriptFactory->createScriptFromSource(/** @scrutinizer ignore-type */ $language, $sourceExpression);
    }

    /**
     * Creates a new {@link ExecutableScript} from a resource. It excepts static and dynamic resources.
     * Dynamic means that the resource is an expression which will be evaluated during execution.
     *
     * @param language the language of the script
     * @param resource the resource path of the script code or an expression which evaluates to the resource path
     * @param expressionManager the expression manager to use to generate the expressions of dynamic scripts
     * @param scriptFactory the script factory used to create the script
     * @return the newly created script
     * @throws NotValidException if language or resource are null or empty
     */
    public static function getScriptFromResource(string $language, string $resource, ?ExpressionManager $expressionManager, ?ScriptFactory $scriptFactory): ExecutableScript
    {
        EnsureUtil::ensureNotEmpty(NotValidException::class, "Script language", $language);
        EnsureUtil::ensureNotEmpty(NotValidException::class, "Script language", /** @scrutinizer ignore-type */ $language);
        EnsureUtil::ensureNotEmpty(NotValidException::class, "Script resource", $resource);
        if (self::isDynamicScriptExpression($language, $resource)) {
        if (self::isDynamicScriptExpression($language, /** @scrutinizer ignore-type */ $resource)) {
            $resourceExpression = $expressionManager->createExpression($resource);
            $resourceExpression = $expressionManager->createExpression(/** @scrutinizer ignore-type */ $resource);
            return self::getScriptFromResourceExpression($language, $resourceExpression, $scriptFactory);
            return self::getScriptFromResourceExpression(/** @scrutinizer ignore-type */ $language, $resourceExpression, $scriptFactory);
        } else {
            EnsureUtil::ensureNotEmpty(NotValidException::class, "Script language", $language);
            EnsureUtil::ensureNotEmpty(NotValidException::class, "Script resource", $resource);
            return $scriptFactory->createScriptFromResource($language, $resource);
            return $scriptFactory->/** @scrutinizer ignore-call */ createScriptFromResource($language, $resource);
        }
    }

    /**
     * Creates a new {@link ExecutableScript} from a dynamic resource. Dynamic means that the source
     * is an expression which will be evaluated during execution.
     *
     * @param language the language of the script
     * @param resourceExpression the expression which evaluates to the resource path
     * @param scriptFactory the script factory used to create the script
     * @return the newly created script
     * @throws NotValidException if language is null or empty or resourceExpression is null
     */
    public static function getScriptFromResourceExpression(string $language, ExpressionInterface $resourceExpression, ScriptFactory $scriptFactory): ExecutableScript
    {
        EnsureUtil::ensureNotEmpty(NotValidException::class, "Script language", $language);
        EnsureUtil::ensureNotEmpty(NotValidException::class, "Script language", /** @scrutinizer ignore-type */ $language);
        EnsureUtil::ensureNotNull(NotValidException::class, "Script resource expression", $resourceExpression);
        return $scriptFactory->createScriptFromResource($language, $resourceExpression);
        return $scriptFactory->createScriptFromResource(/** @scrutinizer ignore-type */ $language, $resourceExpression);
    }

    /**
     * Checks if the value is an expression for a dynamic script source or resource.
     *
     * @param language the language of the script
     * @param value the value to check
     * @return true if the value is an expression for a dynamic script source/resource, otherwise false
     */
    public static function isDynamicScriptExpression(?string $language, string $value): bool
    {
        return StringUtil::isExpression($value) && $language != null && !in_array(strtolower($language), JuelScriptEngineFactory::$names);

    }

    /**
     * Returns the configured script factory in the context or a new one.
     */
    public static function getScriptFactory(): ScriptFactory
    {
        $processEngineConfiguration = Context::getProcessEngineConfiguration();
        if ($processEngineConfiguration !== null) {
            return $processEngineConfiguration->getScriptFactory();
            return $processEngineConfiguration->/** @scrutinizer ignore-call */ getScriptFactory();
        } else {
            return new ScriptFactory();
        }
    }
}

bingo-soft / jabe

Push — main ( ea931b...8f4107 )

ScriptUtil::isDynamicScriptExpression() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
