Examples with PhoenicisScriptEngine org.phoenicis.scripts.engine.implementation.PhoenicisScriptEngine used on opensource projects

Example 1 with PhoenicisScriptEngine

use of org.phoenicis.scripts.engine.implementation.PhoenicisScriptEngine in project POL-POM-5 by PlayOnLinux.

the class EnginesManager method getEngine.

/**
 * Fetches the required engine
 *
 * @param engineId The engine ID (e.g. "wine")
 * @param doneCallback The callback which will be executed with the fetched engine
 * @param errorCallback The callback which will be executed if an error occurs
 */
public void getEngine(String engineId, Consumer<Engine> doneCallback, Consumer<Exception> errorCallback) {
    executorService.execute(() -> {
        final PhoenicisScriptEngine phoenicisScriptEngine = phoenicisScriptEngineFactory.createEngine();
        final String include = String.format("include(\"engines.%s.engine.implementation\");", engineId);
        final Value engineClass = (Value) phoenicisScriptEngine.evalAndReturn(include, errorCallback);
        final Engine engine = engineClass.newInstance().as(Engine.class);
        doneCallback.accept(engine);
    });
}

Example 2 with PhoenicisScriptEngine

use of org.phoenicis.scripts.engine.implementation.PhoenicisScriptEngine in project POL-POM-5 by PlayOnLinux.

the class IncludeInjector method injectInto.

@Override
public void injectInto(PhoenicisScriptEngine phoenicisScriptEngine) {
    // store scripts that are currently in progress
    final Stack<String> includeStack = new Stack<>();
    // store included scripts (include path -> JS object)
    final Map<String, Object> includedScripts = new HashMap<>();
    phoenicisScriptEngine.put("include", (Function<String, Object>) argument -> {
        if (includeStack.contains(argument)) {
            throw new CircularIncludeException(argument, includeStack);
        }
        includeStack.push(argument);
        if (!includedScripts.containsKey(argument)) {
            final String script = scriptFetcher.getScript(argument);
            if (script == null) {
                throw new ScriptNotFoundException(argument);
            }
            try {
                String extendedString = String.format("(module) => { %s }", script);
                Value includeFunction = (Value) phoenicisScriptEngine.evalAndReturn(extendedString, this::throwException);
                Value module = (Value) phoenicisScriptEngine.evalAndReturn("({})", this::throwException);
                includeFunction.execute(module);
                if (module.hasMember("default")) {
                    includedScripts.put(argument, module.getMember("default"));
                } else {
                    includedScripts.put(argument, module);
                }
            } catch (ScriptException se) {
                throw new IncludeException(argument, se);
            }
        }
        includeStack.pop();
        return includedScripts.get(argument);
    }, this::throwException);
}

Example 3 with PhoenicisScriptEngine

use of org.phoenicis.scripts.engine.implementation.PhoenicisScriptEngine in project POL-POM-5 by PlayOnLinux.

the class PhoenicisScriptEngineFactory method createEngine.

public PhoenicisScriptEngine createEngine() {
    final PhoenicisScriptEngine phoenicisScriptEngine = type.createScriptEngine();
    engineInjectors.forEach(engineInjector -> engineInjector.injectInto(phoenicisScriptEngine));
    return phoenicisScriptEngine;
}

Example 4 with PhoenicisScriptEngine

use of org.phoenicis.scripts.engine.implementation.PhoenicisScriptEngine in project POL-POM-5 by PlayOnLinux.

the class EngineSettingsManager method fetchAvailableEngineSettings.

/**
 * Fetches the available engine settings
 *
 * @param repositoryDTO The repository containing the engine settings
 * @param callback The callback which recieves the found engine settings
 * @param errorCallback The callback which will be executed if an error occurs
 */
public void fetchAvailableEngineSettings(RepositoryDTO repositoryDTO, Consumer<Map<String, List<EngineSetting>>> callback, Consumer<Exception> errorCallback) {
    executorService.execute(() -> {
        final List<SettingConfig> configurations = fetchSettingConfigurations(repositoryDTO);
        // the script engine needs to be created inside the correct thread otherwise GraalJS throws an error
        final PhoenicisScriptEngine phoenicisScriptEngine = phoenicisScriptEngineFactory.createEngine();
        final Map<String, List<EngineSetting>> result = configurations.stream().collect(Collectors.groupingBy(configuration -> configuration.engineId, Collectors.mapping(configuration -> {
            final String include = String.format("include(\"engines.%s.settings.%s\");", configuration.engineId, configuration.settingId);
            final Value settingClass = (Value) phoenicisScriptEngine.evalAndReturn(include, errorCallback);
            return settingClass.newInstance().as(EngineSetting.class);
        }, Collectors.toList())));
        callback.accept(result);
    });
}

Example 5 with PhoenicisScriptEngine

use of org.phoenicis.scripts.engine.implementation.PhoenicisScriptEngine in project POL-POM-5 by PlayOnLinux.

the class EnginesManager method fetchAvailableEngines.

/**
 * Fetches the available engines
 *
 * @param repositoryDTO The repository containing the engines
 * @param callback The callback which receives the fetched engines
 * @param errorCallback The callback which is executed if an error occurs
 */
public void fetchAvailableEngines(RepositoryDTO repositoryDTO, Consumer<Map<String, Engine>> callback, Consumer<Exception> errorCallback) {
    final List<String> engineIds = repositoryDTO.getTypes().stream().filter(type -> type.getId().equals("engines")).flatMap(type -> type.getCategories().stream()).map(engine -> engine.getId().replaceAll("^.*\\.", "")).collect(Collectors.toList());
    executorService.execute(() -> {
        final PhoenicisScriptEngine phoenicisScriptEngine = phoenicisScriptEngineFactory.createEngine();
        Map<String, Engine> result = engineIds.stream().collect(Collectors.toMap(Function.identity(), engineId -> {
            final String include = String.format("include(\"engines.%s.engine.implementation\");", engineId);
            final Value engineClass = (Value) phoenicisScriptEngine.evalAndReturn(include, errorCallback);
            return engineClass.newInstance().as(Engine.class);
        }));
        callback.accept(result);
    });
}