Example usage for javax.script ScriptContext ENGINE

Introduction

In this page you can find the example usage for javax.script ScriptContext ENGINE_SCOPE.

Prototype

int ENGINE_SCOPE

To view the source code for javax.script ScriptContext ENGINE_SCOPE.

Click Source Link

Document

EngineScope attributes are visible during the lifetime of a single ScriptEngine and a set of attributes is maintained for each engine.

Usage

From source file:com.qspin.qtaste.testsuite.impl.JythonTestScript.java

public static void addToGlobalJythonScope(String name, Object value) {
    Bindings globalContext = engine.getBindings(ScriptContext.ENGINE_SCOPE);
    globalContext.put(name, value);/*from  ww w. java 2 s. c om*/
}

From source file:org.apache.tinkerpop.gremlin.groovy.jsr223.GremlinGroovyScriptEngine.java

Object eval(final Class scriptClass, final ScriptContext context) throws ScriptException {
    final Binding binding = new Binding(context.getBindings(ScriptContext.ENGINE_SCOPE)) {
        @Override/*from  w w w . j  a v  a 2s.c o  m*/
        public Object getVariable(String name) {
            synchronized (context) {
                int scope = context.getAttributesScope(name);
                if (scope != -1) {
                    return context.getAttribute(name, scope);
                }
                // Redirect script output to context writer, if out var is not already provided
                if ("out".equals(name)) {
                    final Writer writer = context.getWriter();
                    if (writer != null) {
                        return (writer instanceof PrintWriter) ? (PrintWriter) writer
                                : new PrintWriter(writer, true);
                    }
                }
                // Provide access to engine context, if context var is not already provided
                if ("context".equals(name)) {
                    return context;
                }
            }
            throw new MissingPropertyException(name, getClass());
        }

        @Override
        public void setVariable(String name, Object value) {
            synchronized (context) {
                int scope = context.getAttributesScope(name);
                if (scope == -1) {
                    scope = ScriptContext.ENGINE_SCOPE;
                }
                context.setAttribute(name, value, scope);
            }
        }
    };

    try {
        // if this class is not an instance of Script, it's a full-blown class then simply return that class
        if (!Script.class.isAssignableFrom(scriptClass)) {
            return scriptClass;
        } else {
            final Script scriptObject = InvokerHelper.createScript(scriptClass, binding);
            for (Method m : scriptClass.getMethods()) {
                final String name = m.getName();
                globalClosures.put(name, new MethodClosure(scriptObject, name));
            }

            final MetaClass oldMetaClass = scriptObject.getMetaClass();
            scriptObject.setMetaClass(new DelegatingMetaClass(oldMetaClass) {
                @Override
                public Object invokeMethod(final Object object, final String name, final Object args) {
                    if (args == null) {
                        return invokeMethod(object, name, MetaClassHelper.EMPTY_ARRAY);
                    } else if (args instanceof Tuple) {
                        return invokeMethod(object, name, ((Tuple) args).toArray());
                    } else if (args instanceof Object[]) {
                        return invokeMethod(object, name, (Object[]) args);
                    } else {
                        return invokeMethod(object, name, new Object[] { args });
                    }
                }

                @Override
                public Object invokeMethod(final Object object, final String name, final Object args[]) {
                    try {
                        return super.invokeMethod(object, name, args);
                    } catch (MissingMethodException mme) {
                        return callGlobal(name, args, context);
                    }
                }

                @Override
                public Object invokeStaticMethod(final Object object, final String name, final Object args[]) {
                    try {
                        return super.invokeStaticMethod(object, name, args);
                    } catch (MissingMethodException mme) {
                        return callGlobal(name, args, context);
                    }
                }
            });

            final Object o = scriptObject.run();

            // if interpreter mode is enable then local vars of the script are promoted to engine scope bindings.
            if (interpreterModeEnabled) {
                final Map<String, Object> localVars = (Map<String, Object>) context
                        .getAttribute(COLLECTED_BOUND_VARS_MAP_VARNAME);
                if (localVars != null) {
                    localVars.entrySet().forEach(e -> {
                        // closures need to be cached for later use
                        if (e.getValue() instanceof Closure)
                            globalClosures.put(e.getKey(), (Closure) e.getValue());

                        context.setAttribute(e.getKey(), e.getValue(), ScriptContext.ENGINE_SCOPE);
                    });

                    // get rid of the temporary collected vars
                    context.removeAttribute(COLLECTED_BOUND_VARS_MAP_VARNAME, ScriptContext.ENGINE_SCOPE);
                    localVars.clear();
                }
            }

            return o;
        }
    } catch (Exception e) {
        throw new ScriptException(e);
    }
}

From source file:de.axelfaust.alfresco.nashorn.repo.processor.NashornScriptProcessor.java

protected Object executeScriptFromResource(final URL resource) throws ScriptException {
    this.initialisationStateLock.readLock().lock();
    try {/*  w w w  .  java  2  s  .c o  m*/
        LOGGER.debug("Executing script from resource {}", resource);
        try (Reader reader = new URLReader(resource)) {
            this.engine.getContext().setAttribute(ScriptEngine.FILENAME, resource.toString(),
                    ScriptContext.ENGINE_SCOPE);
            return this.engine.eval(reader);
        } catch (final IOException e) {
            throw new ScriptException(e);
        } finally {
            LOGGER.trace("Execution of script from resource {} completed", resource);
        }
    } finally {
        this.initialisationStateLock.readLock().unlock();
    }
}

From source file:com.xpn.xwiki.web.CreateActionRequestHandler.java

/**
 * Verifies if the creation inside the specified spaceReference is allowed by the current template provider. If the
 * creation is not allowed, an exception will be set on the context.
 *
 * @return {@code true} if the creation is allowed, {@code false} otherwise
 *//*from   w  ww  .  ja  va  2 s.c om*/
public boolean isTemplateProviderAllowedToCreateInCurrentSpace() {
    // Check that the chosen space is allowed with the given template, if not:
    // - Cancel the redirect
    // - Set an error on the context, to be read by the create.vm
    if (templateProvider != null) {
        // Check using the template provider's creation restrictions.
        if (!isTemplateProviderAllowedInSpace(templateProvider, spaceReference,
                TP_CREATION_RESTRICTIONS_PROPERTY)) {
            // put an exception on the context, for create.vm to know to display an error
            Object[] args = { templateProvider.getStringValue(TEMPLATE), spaceReference, name };
            XWikiException exception = new XWikiException(XWikiException.MODULE_XWIKI_STORE,
                    XWikiException.ERROR_XWIKI_APP_TEMPLATE_NOT_AVAILABLE,
                    "Template {0} cannot be used in space {1} when creating page {2}", null, args);

            ScriptContext scontext = getCurrentScriptContext();
            scontext.setAttribute(EXCEPTION, exception, ScriptContext.ENGINE_SCOPE);
            scontext.setAttribute("createAllowedSpaces",
                    getTemplateProviderRestrictions(templateProvider, TP_CREATION_RESTRICTIONS_PROPERTY),
                    ScriptContext.ENGINE_SCOPE);

            return false;
        }
    }

    // For all other cases, creation is allowed.
    return true;
}