Jabe\Engine\Impl\Util\ScriptUtil

Complexity

Total Complexity

13

Size/Duplication

Total Lines	132
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	isDynamicScriptExpression()	0	3	3
A	getScriptFromSource()	0	11	2
A	getScriptFromResource()	0	11	2
A	getScriptFromResourceExpression()	0	5	1
A	getScriptFactory()	0	7	2
A	getScript()	0	9	2
A	getScriptFromSourceExpression()	0	5	1

<?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);

$language of type string is incompatible with the type array expected by parameter $variable of Jabe\Engine\Impl\Util\EnsureUtil::ensureNotEmpty().

        EnsureUtil::ensureAtLeastOneNotNull("No script source or resource was given", $source, $resource);
        if (!empty($resource)) {
            return self::getScriptFromResource($language, $resource, $expressionManager, $scriptFactory);

The expression return self::getScriptFromResource($language, $resource, $expressionManager, $scriptFactory) returns the type Jabe\Engine\Impl\Scripting\DynamicResourceExecutableScript|Jabe\Engine\Impl\Scripting\ResourceExecutableScript which is incompatible with the documented return type Jabe\Engine\Impl\Util\the.

$language of type array is incompatible with the type string expected by parameter $language of Jabe\Engine\Impl\Util\ScriptUtil::getScriptFromResource().

        } else {
            return self::getScriptFormSource($language, $source, $expressionManager, $scriptFactory);

The method getScriptFormSource() does not exist on Jabe\Engine\Impl\Util\ScriptUtil. Did you maybe mean getScript()?

        }
    }

    /**
     * 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);

$language of type string is incompatible with the type array expected by parameter $variable of Jabe\Engine\Impl\Util\EnsureUtil::ensureNotEmpty().

        EnsureUtil::ensureNotNull(NotValidException::class, "Script source", $source);
        if (self::isDynamicScriptExpression($language, $source)) {

$language of type array is incompatible with the type null|string expected by parameter $language of Jabe\Engine\Impl\Util\ScriptUtil::isDynamicScriptExpression().

            $sourceExpression = $expressionManager->createExpression($source);

The method createExpression() does not exist on null.

            return self::getScriptFromSourceExpression($language, $sourceExpression, $scriptFactory);

The expression return self::getScriptFromSourceExpression($language, $sourceExpression, $scriptFactory) returns the type Jabe\Engine\Impl\Scripting\DynamicSourceExecutableScript which is incompatible with the documented return type Jabe\Engine\Impl\Util\the.

$language of type array is incompatible with the type string expected by parameter $language of Jabe\Engine\Impl\Util\ScriptUtil::getScriptFromSourceExpression().

        } else {
            EnsureUtil::ensureNotEmpty(NotValidException::class, "Script language", $language);
            EnsureUtil::ensureNotNull(NotValidException::class, "Script source", $source);
            return $scriptFactory->createScriptFromSource($language, $source);

The expression return $scriptFactory->createScriptFromSource($language, $source) returns the type Jabe\Engine\Impl\Scripting\SourceExecutableScript which is incompatible with the documented return type Jabe\Engine\Impl\Util\the.

$language of type array is incompatible with the type string expected by parameter $language of Jabe\Engine\Impl\Scripting\ScriptFactory::createScriptFromSource().

        }
    }

    /**
     * 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);

$language of type string is incompatible with the type array expected by parameter $variable of Jabe\Engine\Impl\Util\EnsureUtil::ensureNotEmpty().

        EnsureUtil::ensureNotNull(NotValidException::class, "Script source expression", $sourceExpression);
        return $scriptFactory->createScriptFromSource($language, $sourceExpression);

$language of type array is incompatible with the type string expected by parameter $language of Jabe\Engine\Impl\Scripting\ScriptFactory::createScriptFromSource().

The expression return $scriptFactory->createScriptFromSource($language, $sourceExpression) returns the type Jabe\Engine\Impl\Scripting\DynamicSourceExecutableScript which is incompatible with the documented return type Jabe\Engine\Impl\Util\the.

    }

    /**
     * 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);

$language of type string is incompatible with the type array expected by parameter $variable of Jabe\Engine\Impl\Util\EnsureUtil::ensureNotEmpty().

        EnsureUtil::ensureNotEmpty(NotValidException::class, "Script resource", $resource);
        if (self::isDynamicScriptExpression($language, $resource)) {

$language of type array is incompatible with the type null|string expected by parameter $language of Jabe\Engine\Impl\Util\ScriptUtil::isDynamicScriptExpression().

$resource of type array is incompatible with the type string expected by parameter $value of Jabe\Engine\Impl\Util\ScriptUtil::isDynamicScriptExpression().

            $resourceExpression = $expressionManager->createExpression($resource);

$resource of type array is incompatible with the type string expected by parameter $expression of Jabe\Engine\Impl\El\ExpressionManager::createExpression().

            return self::getScriptFromResourceExpression($language, $resourceExpression, $scriptFactory);

It seems like $scriptFactory can also be of type null; however, parameter $scriptFactory of Jabe\Engine\Impl\Util\ScriptUtil::getScriptFromResourceExpression() does only seem to accept Jabe\Engine\Impl\Scripting\ScriptFactory, maybe add an additional type check?

The expression return self::getScriptFromResourceExpression($language, $resourceExpression, $scriptFactory) returns the type Jabe\Engine\Impl\Scripting\DynamicResourceExecutableScript which is incompatible with the documented return type Jabe\Engine\Impl\Util\the.

$language of type array is incompatible with the type string expected by parameter $language of Jabe\Engine\Impl\Util\ScriptUtil::getScriptFromResourceExpression().

        } else {
            EnsureUtil::ensureNotEmpty(NotValidException::class, "Script language", $language);
            EnsureUtil::ensureNotEmpty(NotValidException::class, "Script resource", $resource);
            return $scriptFactory->createScriptFromResource($language, $resource);

$language of type array is incompatible with the type string expected by parameter $language of Jabe\Engine\Impl\Scripting\ScriptFactory::createScriptFromResource().

The method createScriptFromResource() does not exist on null.

The expression return $scriptFactory->createScriptFromResource($language, $resource) returns the type Jabe\Engine\Impl\Scripting\ResourceExecutableScript which is incompatible with the documented return type Jabe\Engine\Impl\Util\the.

        }
    }

    /**
     * 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);

$language of type string is incompatible with the type array expected by parameter $variable of Jabe\Engine\Impl\Util\EnsureUtil::ensureNotEmpty().

        EnsureUtil::ensureNotNull(NotValidException::class, "Script resource expression", $resourceExpression);
        return $scriptFactory->createScriptFromResource($language, $resourceExpression);

The expression return $scriptFactory->createScriptFromResource($language, $resourceExpression) returns the type Jabe\Engine\Impl\Scripting\DynamicResourceExecutableScript which is incompatible with the documented return type Jabe\Engine\Impl\Util\the.

$language of type array is incompatible with the type string expected by parameter $language of Jabe\Engine\Impl\Scripting\ScriptFactory::createScriptFromResource().

    }

    /**
     * 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);

It seems like you are loosely comparing $language of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

The expression return Jabe\Engine\Impl\Util\StringUtil::isExpression($value) && $language != null && ! in_array(strtolower($language), Jabe\Engine\Impl\Scripting\Engine\JuelScriptEngineFactory::names) returns the type boolean which is incompatible with the documented return type true.

    }

    /**
     * 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();

The method getScriptFactory() does not exist on Jabe\Engine\Impl\Cfg\ProcessEngineConfigurationImpl.

        } else {
            return new ScriptFactory();
        }
    }
}