Java Examples for javax.script.ScriptEngine

@Test
public void testJavaSass() throws Exception {
    ScriptEngineManager manager = new ScriptEngineManager();
    ScriptEngine engine = manager.getEngineByName("jruby");
    engine.eval("ENV['GEM_HOME'] = 'unknown'");
    engine.eval("ENV['GEM_PATH'] = 'unknown'");
    engine.eval("require 'rubygems'; require 'sass';");
    String sass = ".test\n\tcolor: red";
    SimpleBindings bindings = new SimpleBindings();
    bindings.put("str", sass);
    String css = (String) engine.eval("Sass::Engine.new($str).render", bindings);
    assertEquals(".test {\n  color: red; }\n", css);
}

/**
	 * Retorna o total da Expressão passada.
	 * Por exemplo: ao passar, (10*10*(5/2)), ele retorna 250.
	 * 
	 * @param expressao
	 * @return Double
	 * @author renato.jesus
	 */
public static Double calculaExpressao(String expressao) {
    ScriptEngineManager manager = new ScriptEngineManager();
    ScriptEngine engine = manager.getEngineByName("JavaScript");
    Double resultado = 0.0;
    if (expressao.isEmpty() || expressao == null) {
        return resultado;
    }
    try {
        resultado = (Double) engine.eval(expressao);
    } catch (ScriptException e) {
        e.printStackTrace();
    }
    return resultado;
}

public static void main(String[] args) throws Exception {
    // create a script engine manager
    ScriptEngineManager factory = new ScriptEngineManager();
    // create a Clojure engine
    ScriptEngine engine = factory.getEngineByName("Clojure");
    // evaluate Clojure code from String
    engine.eval("(def foo \"World!\") (println \"Hello, \" foo)");
    System.out.printf("foo = %s\n", engine.get("user/foo"));
    engine.put("user/foo", "planet");
    engine.eval("(println \"Hello, \" foo)");
    engine.eval("(ns myns) (def foo \"xxx\")");
    engine.put("myns/foo", "planet");
    engine.eval("(println \"Hello, \" myns/foo)");
    System.out.println(engine.getBindings(ScriptContext.ENGINE_SCOPE).keySet());
    engine.eval("(def bar 747)");
    int bar = (Integer) engine.get("user/bar");
    System.out.printf("bar from Clojure: %d\n", bar);
}

public static void main(String[] args) throws ScriptException, NoSuchMethodException {
    ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
    engine.eval("function foo(predicate, obj) { return !!(eval(predicate)); };");
    Invocable invocable = (Invocable) engine;
    Person person = new Person();
    person.setName("Hans");
    String predicate = "obj.getLengthOfName() >= 4";
    Object result = invocable.invokeFunction("foo", predicate, person);
    System.out.println(result);
}

public static void main(String[] args) throws ScriptException, NoSuchMethodException {
    ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
    engine.eval("function foo(predicate, obj) { return !!(eval(predicate)); };");
    Invocable invocable = (Invocable) engine;
    Person person = new Person();
    person.setName("Hans");
    String predicate = "obj.getLengthOfName() >= 4";
    Object result = invocable.invokeFunction("foo", predicate, person);
    System.out.println(result);
}

public static ScriptEngine createGremlinScriptEngine(Map<String, Object> context) {
    try {
        ScriptEngine engine = new GremlinGroovyScriptEngine();
        Bindings bindings = new SimpleBindings();
        bindings.putAll(context);
        engine.setBindings(bindings, ScriptContext.ENGINE_SCOPE);
        return engine;
    } catch (Throwable e) {
        e.printStackTrace();
        return null;
    }
}

public static void main(String[] args) {
    ScriptEngineManager manager = new ScriptEngineManager();
    final ScriptEngine scriptEngine = manager.getEngineByName("jruby");
    InputStreamReader reader = new InputStreamReader(OOORConsole.class.getResourceAsStream("jirb_swing.rb"));
    try {
        scriptEngine.eval("CLOSE_OPERATION='exit'");
        scriptEngine.eval(reader);
    } catch (ScriptException ex) {
    }
}

@Test
public void testCache() {
    ScriptEngine engine = jRubyEngine();
    try {
        engine.eval(haml4jRubyScript());
        String template = "resources/simple.yaml";
        SimpleScriptContext context = new SimpleScriptContext();
        context.setAttribute("file", urlFrom(template), ScriptContext.ENGINE_SCOPE);
        String call = "render()";
        engine.eval(call, context);
        engine.eval(call, context);
        engine.eval(call, context);
    } catch (Exception e) {
        e.printStackTrace();
        fail();
    }
}

@Override
public Object eval(ScriptEngine engine, Object... args) throws ScriptException {
    super.compile(engine);
    try {
        Object result = ((Invocable) engine).invokeFunction(this.name, args);
        return result;
    } catch (NoSuchMethodException e) {
        throw new IllegalStateException("Failed to compile " + this.name + " into the ScriptEngine!", e);
    }
}

@Test
public void testScriptEngine() throws ScriptException {
    ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
    // TODO: figure out the real way to register an engine, so only a jar needs to be supplied.
    scriptEngineManager.registerEngineName("kahlua", new KahluaEngineFactory());
    ScriptEngine engine = scriptEngineManager.getEngineByName("kahlua");
    assertNotNull("Kahlua engine is not installed", engine);
    Object eval = engine.eval("return 1*2*3*4*5*6");
    assertEquals(eval, 720.0);
}

public void importDataFromReader(Long loggedUserId, Reader script) throws InvalidScriptException {
    ScriptEngineManager sem = new ScriptEngineManager();
    ScriptEngine se = sem.getEngineByName("JavaScript");
    Invocable inv = (Invocable) se;
    try {
        Object obj = se.eval(script);
        if (obj instanceof Map) {
            inv.invokeMethod(obj, "run", new Object[] { new ImportAPI(loggedUserId) });
        } else {
            throw new InvalidScriptException("Invalid top-level object");
        }
    } catch (NoSuchMethodException ex) {
        throw new InvalidScriptException(ex);
    } catch (ScriptException ex) {
        throw new InvalidScriptException(ex);
    }
}

public static void execute(InputStream is) {
    // create a script engine manager:
    ScriptEngineManager manager = new ScriptEngineManager();
    // create a Renjin engine:
    ScriptEngine engine = manager.getEngineByName("Renjin");
    // check if the engine has loaded correctly:
    if (engine == null) {
        throw new RuntimeException("Renjin Script Engine not found on the classpath.");
    }
    try {
        engine.eval(new InputStreamReader(is, Charset.forName("UTF-8")));
    } catch (ScriptException e) {
        throw new RuntimeException(e);
    }
}

@Test
public void vsgc1104Test() throws Exception {
    ScriptEngineManager manager = new ScriptEngineManager();
    manager.put("greeting", "Hello");
    ScriptEngine engine = manager.getEngineByExtension("visage");
    assertTrue(engine instanceof VisageScriptEngine);
    File script = new File("test/src/org/visage/tools/script/VSGC1131.visage");
    engine.getContext().setAttribute(ScriptEngine.FILENAME, script.getAbsolutePath(), ScriptContext.ENGINE_SCOPE);
    Bindings bindings = new SimpleBindings();
    bindings.put("who", "world");
    String ret = (String) engine.eval(new FileReader(script), bindings);
    assertEquals(ret, "Hello, world");
}

/* (non-Javadoc)
	 * @see org.eclipse.jface.action.Action#run()
	 */
@Override
public void run() {
    ScriptEngine engine = AresScriptEngineManager.getScriptEngineManager().getEngineByName(ARESCore.SCRIPT_ENGINE_NAME);
    try {
        engine.setBindings(ScriptUtils.toScriptBindings(context), ScriptContext.ENGINE_SCOPE);
        engine.eval(script);
        if (null != functionName && !"".equals(functionName)) {
            ((Invocable) engine).invokeFunction(functionName, context);
        }
    } catch (Exception e) {
        ErrorDialog.openError(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), "½Å±¾Ö´ÐдíÎó", e.getMessage(), new Status(Status.ERROR, ScriptPlugin.PLUGIN_ID, e.getMessage(), e));
    }
}

@Override
public void execute(final ExecuteCheck executeCheck) {
    try {
        // we need a script!
        if (Util.isEmpty(executeCheck.getScript()))
            throw new RuntimeException("The script must be defined!");
        // setup the script engine
        ScriptEngine script = factory.getEngineByName("nashorn");
        SimpleBindings bindings = new SimpleBindings();
        bindings.put("check", executeCheck);
        bindings.put("ssh", this.getEngine().getChecker().createContext(( t) -> {
            this.publishActiveResult(executeCheck, new ActiveResultMO().fromCheck(executeCheck).error(t));
        }));
        bindings.put("bergamot", this.createScriptContext(executeCheck));
        script.setBindings(bindings, ScriptContext.ENGINE_SCOPE);
        // execute
        script.eval(executeCheck.getScript());
    } catch (Exception e) {
        logger.error("Error executing check", e);
        this.publishActiveResult(executeCheck, new ActiveResultMO().fromCheck(executeCheck).error(e));
    }
}

public static ScriptEngine getEngine(String name) {
    for (ScriptEngineFactory factory : FACTORIES) {
        if (factory.getNames().contains(name)) {
            if (factory.getParameter("THREADING") != null) {
                return THREAD_SAFE_ENGINES.get(factory);
            } else {
                return THREAD_LOCAL_ENGINES.get(factory).get();
            }
        }
    }
    throw new IllegalArgumentException(String.format("[%s] is not a valid script engine name!", name));
}

public Object eval(ScriptEngine scriptEngine, Object... args) {
    try {
        return ((Invocable) scriptEngine).invokeFunction(functionName, args);
    } catch (ScriptExceptionNoSuchMethodException |  e) {
        StringBuilder functionCall = new StringBuilder().append(functionName).append('(');
        if (args != null) {
            functionCall.append(Arrays.asList(args));
        }
        functionCall.append(')');
        throw new RuntimeException("Error calling " + functionCall, e);
    }
}

@Override
public Object getParameter(String key) {
    if (key.equals(ScriptEngine.ENGINE)) {
        return getScriptEngine();
    } else if (key.equals(ScriptEngine.ENGINE_VERSION)) {
        return getEngineVersion();
    } else if (key.equals(ScriptEngine.NAME)) {
        return getEngineName();
    } else if (key.equals(ScriptEngine.LANGUAGE)) {
        return getLanguageName();
    } else if (key.equals(ScriptEngine.LANGUAGE_VERSION)) {
        return getLanguageVersion();
    }
    return null;
}

public static void main(String[] args) {
    ScriptEngineManager sem = new ScriptEngineManager();
    try {
        log.info("init...");
        // Integer.parseInt(args[0]);
        int K = 1;
        String cmd = "function count(sum) { for(var i = 0 ; i < 100000 ; i++) sum += i; return sum; }";
        for (int k = 0; k < K; k++) {
            ScriptEngine e = sem.getEngineByName("javascript");
            e.eval(cmd);
            final Invocable f = (Invocable) e;
            int N = 100;
            for (int j = 0; j < 100; j++) {
                long t1 = System.currentTimeMillis();
                for (int i = 0; i < N; i++) {
                    Object re = f.invokeFunction("count", 0);
                    log.info("[{}] {}", i, re);
                }
                long t2 = System.currentTimeMillis();
                log.info("average:{}", N * 1000 / (t2 - t1));
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

@Override
public Object run(Object object, List<Object> args, ScriptEngine engine) throws ScriptException {
    Invocable invocable = (Invocable) engine;
    Object results;
    Object exportsObj = engine.get("exports");
    Scriptable exports = null;
    if (exportsObj instanceof Scriptable) {
        exports = (Scriptable) exportsObj;
    } else {
        throw new ScriptException("Couldn't get exports for function.");
    }
    Scriptable scope = exports.getParentScope();
    Context.enter();
    Object geoObject;
    try {
        geoObject = GeoObject.javaToJS(object, scope);
    } catch (Exception e) {
        geoObject = object;
    }
    Object geoArgs;
    try {
        geoArgs = GeoObject.javaToJS(args, scope);
    } catch (Exception e) {
        geoArgs = args;
    }
    try {
        results = invocable.invokeMethod(exports, "run", geoObject, geoArgs);
        results = GeoObject.jsToJava(results);
    } catch (NoSuchMethodException e) {
        throw new ScriptException(e);
    } finally {
        Context.exit();
    }
    return results;
}

public static void main(String[] args) throws Exception {
    ScriptEngineManager manager = new ScriptEngineManager();
    ScriptEngine engine = manager.getEngineByName("JavaScript");
    Bindings bind = engine.createBindings();
    bind.put("factor", 2);
    engine.setBindings(bind, ScriptContext.ENGINE_SCOPE);
    Scanner input = new Scanner(System.in);
    while (input.hasNext()) {
        int first = input.nextInt();
        int sec = input.nextInt();
        System.out.println("输入的�数为:" + first + "," + sec);
        engine.eval(new FileReader("E:\\eclipse_luna\\aidefaultws\\JavaStudy\\src\\study\\java\\jdks\\version1_6\\scripts\\cal.js"));
        if (engine instanceof Invocable) {
            Invocable in = (Invocable) engine;
            Double result = (Double) in.invokeFunction("cal", first, sec);
            System.out.println("�算结果为:" + result.intValue());
        }
    }
}

public static void main(String[] args) throws Exception {
    PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
    Resource resource = resolver.getResource("myFn.js");
    ScriptEngineManager manager = new ScriptEngineManager();
    ScriptEngine engine = manager.getEngineByName("javascript");
    //engine.getContext().
    //Context context = new Context()
    //engine.setContext(context);
    InputStream in = resource.getInputStream();
    String str = StreamUtils.toStringSafe(in);
    //        
    //        Reader reader = new InputStreamReader(in, StandardCharsets.UTF_8);
    engine.eval(str);
    Invocable inv = (Invocable) engine;
    try {
        Object val = inv.invokeFunction("myFn", "test");
        System.out.println(val);
    } catch (ScriptException e) {
        System.out.println(e.getMessage() + " " + e.getLineNumber() + " " + e.getColumnNumber() + " " + e.getFileName());
    }
}

public static void main(String args[]) throws ScriptException, IOException {
    ScriptEngineManager sem = new ScriptEngineManager();
    ScriptEngine se = sem.getEngineByExtension("java");
    se.getContext().setAttribute("classpath", "C:/TestCode", 100);
    se.getContext().setAttribute("mainClass", "Test", 100);
    se.getContext().setAttribute("javax.script.filename", "Test.java", 100);
    BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("TestCode/Test.java")));
    se.eval(br);
    System.err.flush();
    System.out.flush();
    System.err.println("PRESS ANY KEY AFTER EDITING FILE");
    System.in.read();
    br = new BufferedReader(new InputStreamReader(new FileInputStream("TestCode/Test.java")));
    se.eval(br);
}

@Override
protected Object getScope() throws IOException {
    ScriptEngineManager sem = new ScriptEngineManager();
    ScriptEngine se = sem.getEngineByName("nashorn");
    InputStream json = getClass().getClassLoader().getResourceAsStream("hogan.json");
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    byte[] bytes = new byte[1024];
    int read;
    while ((read = json.read(bytes)) != -1) {
        baos.write(bytes, 0, read);
    }
    try {
        return se.eval("var tweet = " + new String(baos.toByteArray()) + "; " + "var tweets = []; for (var i = 0; i < 50; i++) { tweets.push(tweet); };" + "this;");
    } catch (ScriptException e) {
        throw new RuntimeException(e);
    }
}

@Override
public boolean evaluate(String expression, Map<String, Object> args) {
    ScriptEngine engine = manager.getEngineByName("JavaScript");
    ScriptContext newContext = new SimpleScriptContext();
    Bindings engineScope = newContext.getBindings(ScriptContext.ENGINE_SCOPE);
    for (Map.Entry<String, Object> e : args.entrySet()) {
        engineScope.put(e.getKey(), e.getValue());
    }
    Object response = null;
    try {
        response = engine.eval(expression, newContext);
        if (!(response instanceof Boolean)) {
            final String type = response != null ? response.getClass().getName() : null;
            throw new RuntimeException("Unexpected response " + response + ", type " + type + " by evaluating " + expression + " with args " + args);
        }
        return (Boolean) response;
    } catch (ScriptException e) {
        throw new RuntimeException("failed to evaluate " + expression + " with args " + args + " resulting in " + response, e);
    }
}

protected ScriptEngine getEngine(Subject subject) throws ScriptException, IOException {
    StandardBindings bindings = new StandardBindings(new PrintWriter(System.out), new LocalClient(subject));
    PermissionCollection perms = new StandardScriptPermissions();
    return ScriptEngineFactory.getSecuredScriptEngine("javascript", new PackageFinder(Collections.<File>emptyList()), bindings, perms);
}

public static void main(String[] args) throws ScriptException {
    final ScriptEngineManager manager = new ScriptEngineManager();
    final ScriptEngine engine = manager.getEngineByName("js");
    final SimpleBindings bindings = new SimpleBindings();
    bindings.put("name", "World");
    engine.setBindings(bindings, ScriptContext.ENGINE_SCOPE);
    final SimpleBindings evalBindings = new SimpleBindings();
    evalBindings.put("name", "Another world");
    // Default scope
    System.out.println(engine.eval("\"Hello \"+name"));
    System.out.println(engine.eval("\"Hello \"+name", evalBindings));
}

@Override
public BiConsumer<HttpServerRequest, A> apply(BiConsumer<HttpServerRequest, Throwable> fail, BiConsumer<HttpServerRequest, A> next) {
    ScriptEngine scriptEngine = new ScriptEngineManager().getEngineByName("nashorn");
    try {
        scriptEngine.eval(vertx.fileSystem().readFileBlocking(getClass().getClassLoader().getResource("app.js").getPath()).toString());
    } catch (ScriptException ex) {
        throw new RuntimeException(ex);
    }
    return ( req,  arg) -> {
        try {
            // just a test of how this works..
            Object result = ((Invocable) scriptEngine).invokeFunction("say");
            next.accept(req, (A) result);
        } catch (ScriptExceptionNoSuchMethodException |  exception) {
            fail.accept(req, exception);
        }
    };
}

protected Invocable getInvocable(String path, MapleClient c, boolean npc) {
    FileReader fr = null;
    try {
        path = "scripts/" + path;
        ScriptEngine engine = null;
        if (c != null) {
            engine = c.getScriptEngine(path);
        }
        if (engine == null) {
            File scriptFile = new File(path);
            if (!scriptFile.exists()) {
                return null;
            }
            engine = sem.getEngineByName("javascript");
            if (c != null) {
                c.setScriptEngine(path, engine);
            }
            fr = new FileReader(scriptFile);
            engine.eval(fr);
        } else if (c != null && npc) {
        //c.getPlayer().dropMessage(-1, "You already are talking to this NPC. Use @ea if this is not intended.");
        }
        return (Invocable) engine;
    } catch (FileNotFoundExceptionScriptException |  e) {
        System.err.println("Error executing script. Path: " + path + "\nException " + e);
        FileoutputUtil.log(FileoutputUtil.ScriptEx_Log, "Error executing script. Path: " + path + "\nException " + e);
        return null;
    } finally {
        try {
            if (fr != null) {
                fr.close();
            }
        } catch (IOException ignore) {
        }
    }
}

@Override
protected Object evaluate(String script, String language, Bindings bindings) {
    ScriptEngine scriptEngine = null;
    try {
        scriptEngine = Extender.resolveScriptEngine(language);
    } catch (InvalidSyntaxException e) {
        throw new ActivitiException("problem resolving scripting engine" + e.getMessage(), e);
    }
    if (scriptEngine == null) {
        return super.evaluate(script, language, bindings);
    }
    try {
        return scriptEngine.eval(script, bindings);
    } catch (ScriptException e) {
        throw new ActivitiException("problem evaluating script: " + e.getMessage(), e);
    }
}

public Object getParameter(String param) {
    if (param.equals(ScriptEngine.ENGINE)) {
        return getEngineName();
    }
    if (param.equals(ScriptEngine.ENGINE_VERSION)) {
        return getEngineVersion();
    }
    if (param.equals(ScriptEngine.NAME)) {
        return getEngineName();
    }
    if (param.equals(ScriptEngine.LANGUAGE)) {
        return getLanguageName();
    }
    if (param.equals(ScriptEngine.LANGUAGE_VERSION)) {
        return getLanguageVersion();
    }
    if (param.equals("THREADING")) {
        return "MULTITHREADED";
    }
    return null;
}

public Object execute(TaskScript taskScript, ExecutionContext context) {
    Option<ScriptEngine> scriptEngine = getScriptEngine(taskScript.getLanguage());
    if (scriptEngine.isPresent()) {
        return evalScript(taskScript, scriptEngine.get(), context);
    } else {
        throw new UnsupportedOperationException("could not find a script engine for " + taskScript.getLanguage());
    }
}

@SuppressWarnings("unchecked")
public static void main(String[] args) throws ScriptException {
    ScriptEngineManager manager = new ScriptEngineManager();
    List<ScriptEngineFactory> factories = manager.getEngineFactories();
    for (ScriptEngineFactory f : factories) {
        System.out.println("egine name:" + f.getEngineName());
        System.out.println("engine version:" + f.getEngineVersion());
        System.out.println("language name:" + f.getLanguageName());
        System.out.println("language version:" + f.getLanguageVersion());
        System.out.println("names:" + f.getNames());
        System.out.println("mime:" + f.getMimeTypes());
        System.out.println("extension:" + f.getExtensions());
        System.out.println("-----------------------------------------------");
    }
    ScriptEngine engine = manager.getEngineByName("js");
    engine.put("a", 4);
    engine.put("b", 6);
    Object maxNum = engine.eval("function max_num(a,b){return (a>b)?a:b;}max_num(a,b);");
    System.out.println("max_num:" + maxNum + ", (class = " + maxNum.getClass() + ")");
    @SuppressWarnings("rawtypes") Map m = new HashMap();
    m.put("c", 10);
    engine.put("m", m);
    engine.eval("var x= max_num(a,m.get('c'));");
    System.out.println("max_num:" + engine.get("x"));
}

@Override
public Plugin run(File file) throws Throwable {
    ScriptEngineManager manager = new ScriptEngineManager();
    ScriptEngine engine = manager.getEngineByName("jruby");
    if (engine == null)
        throw new Exception("Cannot find jRuby script engine! Please contact Konloch.");
    Reader reader = new FileReader(file);
    engine.eval(reader);
    return (Plugin) engine.eval(file.getName().replace(".rb", "").replace(".ruby", "") + ".new");
}

void caseOne() throws ScriptException {
    ScriptEngineManager manager = new ScriptEngineManager();
    ScriptEngine engine = manager.getEngineByName("jruby");
    ScriptEngineFactory factory = engine.getFactory();
    System.out.println("engine name: " + factory.getEngineName());
    System.out.println("version: " + factory.getEngineVersion());
    engine.eval("puts 'Case one: getEngineByName(\"jruby\").'");
}

@Test
public void testCacheScriptEngine() {
    String scriptLang = "hipster-script";
    ScriptEngineManager mockScriptEngineManager = mock(ScriptEngineManager.class);
    ScriptEngine hipsterScriptEngine = mock(ScriptEngine.class);
    DefaultScriptEngineResolver scriptEngineResolver = new DefaultScriptEngineResolver(mockScriptEngineManager);
    // given
    when(mockScriptEngineManager.getEngineByName(scriptLang)).thenReturn(hipsterScriptEngine);
    // when engine is requested twice
    ScriptEngine engine1 = scriptEngineResolver.getScriptEngineForLanguage(scriptLang);
    ScriptEngine engine2 = scriptEngineResolver.getScriptEngineForLanguage(scriptLang);
    // then it is only created once
    verify(mockScriptEngineManager, times(1)).getEngineByName(scriptLang);
    assertThat(engine1).isSameAs(hipsterScriptEngine);
    assertThat(engine2).isSameAs(engine1);
}

public static void main(String[] args) throws Exception {
    ScriptEngine engine = new ScriptEngineManager().getEngineByName("JavaScript");
    String exp = "1+2*3*4+3*(2+2)-100\n";
    System.out.println(engine.eval(exp));
    ExpressionParserRecursiveDescent parser = new ExpressionParserRecursiveDescent();
    parser.s = exp;
    parser.next();
    while (parser.token != 255) {
        if (parser.token == '\n') {
            parser.skip('\n');
            continue;
        }
        System.out.printf("%.5f", parser.expression());
    }
}

/*
     * (non-Javadoc)
     * 
     * @see org.talend.survivorship.action.ISurvivoredAction#checkCanHandle(org.talend.survivorship.model.DataSet,
     * java.lang.Object, java.lang.String, java.lang.String, int, boolean)
     */
@Override
public boolean checkCanHandle(ActionParameter actionParameter) {
    if (actionParameter.getExpression() == null) {
        return false;
    }
    ScriptEngineManager manager = new ScriptEngineManager();
    //$NON-NLS-1$
    ScriptEngine engine = manager.getEngineByName("javascript");
    try {
        if (actionParameter.getInputData() != null) {
            //$NON-NLS-1$
            engine.put("inputData", actionParameter.getInputData());
            //$NON-NLS-1$ //$NON-NLS-2$
            Object eval = engine.eval("inputData.match(\"" + actionParameter.getExpression() + "\")");
            return eval != null;
        }
    } catch (ScriptException e) {
    }
    return false;
}

@Override
public ScriptEngine getScriptEngine() {
    CompilerConfiguration conf = new CompilerConfiguration();
    Map<String, Boolean> optimizationOptions = conf.getOptimizationOptions();
    optimizationOptions.put(INVOKEDYNAMIC, useInvokeDynamic());
    conf.setOptimizationOptions(optimizationOptions);
    conf.setTargetBytecode(JDK8);
    GroovyClassLoader classLoader = new GroovyClassLoader(Thread.currentThread().getContextClassLoader(), conf);
    return new GroovyScriptEngineImpl(classLoader);
}

/**
	 * @param args
	 * @throws ScriptException
	 */
public static void main(String[] args) throws ScriptException {
    ScriptEngineManager seManager = new ScriptEngineManager();
    ScriptEngine jsEngine = seManager.getEngineByName("javascript");
    if (jsEngine == null) {
        System.out.println("No engine found for javascript");
        System.exit(1);
    }
    jsEngine.eval("println('Coooool! Let\\'s Rock \\'n Roll with JS in java now!');");
    Bindings b = jsEngine.createBindings();
    jsEngine.eval("function globalFunc(intVal,strVal){println('intvar='+intVal+', strVal=strVal')}; ", b);
    jsEngine.eval("function globalFuncArr(arr){arr[2]=arr[0]+arr[1];println(arr[2]);}; ", b);
    jsEngine.setBindings(b, ScriptContext.GLOBAL_SCOPE);
    Bindings b2 = jsEngine.createBindings();
    jsEngine.eval("var aaa = new Array(3); aaa[0]=0.2;aaa[1]=1.9;aaa[2]=9.9;", b2);
    // jsEngine.eval("globalFunc(i,s);", b2);
    jsEngine.eval("globalFuncArr(aaa);", b2);
    jsEngine.eval("println('localbinding aaa[2]='+aaa[2]);", b2);
}

@Test
public void intArrayLengthTest() throws ScriptException {
    Map<String, Object> vars = new HashMap<String, Object>();
    Integer[] l = new Integer[] { 1, 2, 3 };
    vars.put("l", l);
    String script = "l.length";
    ScriptEngineManager manager = new ScriptEngineManager();
    ScriptEngine engine = manager.getEngineByName("nashorn");
    ScriptContext context = engine.getContext();
    Bindings bindings = context.getBindings(ScriptContext.ENGINE_SCOPE);
    bindings.putAll(vars);
    Compilable compilable = (Compilable) engine;
    CompiledScript compiledScript = compilable.compile(script);
    Object o = compiledScript.eval();
    assertThat(((Number) o).intValue(), equalTo(3));
}

@Test
public void intArrayLengthTest() throws ScriptException {
    Map<String, Object> vars = new HashMap<String, Object>();
    Integer[] l = new Integer[] { 1, 2, 3 };
    vars.put("l", l);
    String script = "l.length";
    ScriptEngineManager manager = new ScriptEngineManager();
    ScriptEngine engine = manager.getEngineByName("nashorn");
    ScriptContext context = engine.getContext();
    Bindings bindings = context.getBindings(ScriptContext.ENGINE_SCOPE);
    bindings.putAll(vars);
    Compilable compilable = (Compilable) engine;
    CompiledScript compiledScript = compilable.compile(script);
    Object o = compiledScript.eval();
    assertThat(((Number) o).intValue(), equalTo(3));
}

public Object execute(final String lang, final String script, final ScriptType scriptType, final Map<String, Object> localVars) {
    final ScriptEngineManager manager = new ScriptEngineManager();
    final ScriptEngine engine = manager.getEngineByName(lang);
    for (final Map.Entry<String, Object> entry : localVars.entrySet()) {
        engine.put(entry.getKey(), entry.getValue());
    }
    try {
        return engine.eval(getScriptContent(lang, script, scriptType));
    } catch (final ScriptException e) {
        throw new ScriptExecutionException("lang: " + lang + ", script: " + script + ", type: " + scriptType, e);
    }
}

public Object getParameter(final String key) {
    if (key.equals(ScriptEngine.ENGINE)) {
        return this.getEngineName();
    } else if (key.equals(ScriptEngine.ENGINE_VERSION)) {
        return this.getEngineVersion();
    } else if (key.equals(ScriptEngine.NAME)) {
        return ENGINE_NAME;
    } else if (key.equals(ScriptEngine.LANGUAGE)) {
        return this.getLanguageName();
    } else if (key.equals(ScriptEngine.LANGUAGE_VERSION)) {
        return this.getLanguageVersion();
    } else
        return null;
}

/**
     * @param string
     */
private static void executeProcedure(String string) {
    LOG.trace("Method: executeProcedure called.");
    ScriptEngineManager engineManager = new ScriptEngineManager();
    ScriptEngine scriptEngine = engineManager.getEngineByName("JavaScript");
    try {
        scriptEngine.eval(string);
    } catch (ScriptException e) {
        LOG.error("ScriptException while performing operation in executeProcedure", e);
    }
    LOG.trace("Method: executeProcedure finished.");
}

@Nullable
public Object execute(@NotNull final String scriptText, @Nullable final NameValuePair... bindings) throws ScriptException {
    if (classLoader == null)
        return null;
    ClassLoader oldCtxClassLoader = Thread.currentThread().getContextClassLoader();
    try {
        Thread.currentThread().setContextClassLoader(classLoader);
        ScriptEngineManager sem = new ScriptEngineManager(classLoader);
        ScriptEngine se = sem.getEngineByName("groovy");
        Bindings scriptBindings = se.createBindings();
        if (bindings != null)
            for (NameValuePair binding : bindings) scriptBindings.put(binding.getName(), binding.getValue());
        return se.eval(scriptText, scriptBindings);
    } finally {
        Thread.currentThread().setContextClassLoader(oldCtxClassLoader);
    }
}

public Object getParameter(final String key) {
    if (key.equals(ScriptEngine.ENGINE)) {
        return this.getEngineName();
    } else if (key.equals(ScriptEngine.ENGINE_VERSION)) {
        return this.getEngineVersion();
    } else if (key.equals(ScriptEngine.NAME)) {
        return ENGINE_NAME;
    } else if (key.equals(ScriptEngine.LANGUAGE)) {
        return this.getLanguageName();
    } else if (key.equals(ScriptEngine.LANGUAGE_VERSION)) {
        return this.getLanguageVersion();
    } else
        return null;
}

public static void main(String[] args) throws Exception {
    ScriptEngineManager manager = new ScriptEngineManager();
    ScriptEngine engine = manager.getEngineByName("JavaScript");
    User user = new User(1, "haogrgr");
    user.setMoney(BigDecimal.TEN);
    user.setAge(10);
    engine.put("user", user);
    //注�: java7 下,通过   importClass(java.math.BigDecimal) �引用Java类
    //		String imports = "importClass(java.math.BigDecimal);";//java7;
    //java8;
    String imports = "var BigDecimal = Java.type('java.math.BigDecimal');";
    engine.eval(imports + "if(user.id == 1) {" + "user.name='xxxxx';" + "user.id = 2;" + "user.money = new BigDecimal(user.age / 4);" + "}");
    System.out.println(user);
}

public void testExecute() {
    final String script = "rawOut.println 'elk'";
    final ScriptEngineManager manager = new ScriptEngineManager();
    final ScriptEngine eng = manager.getEngineByName("groovy");
    sc.execute(eng, script);
    assertNull("exception is null", sc.getException());
    assertEquals("has the same script", sc.getScript(), script);
    assertEquals("linesExecuted", 1, sc.getLinesExecuted());
    assertEquals("rawOut", "elk\n", sc.getRawOutput());
}

public void testExecute() {
    final String script = "rawOut.println 'elk'";
    final ScriptEngineManager manager = new ScriptEngineManager();
    final ScriptEngine eng = manager.getEngineByName("groovy");
    sc.execute(eng, script);
    assertNull("exception is null", sc.getException());
    assertEquals("has the same script", sc.getScript(), script);
    assertEquals("linesExecuted", 1, sc.getLinesExecuted());
    assertEquals("rawOut", "elk\n", sc.getRawOutput());
}

@Test
public void testScript() throws Exception {
    ScriptEngineManager manager = new ScriptEngineManager();
    // 设置全局��
    manager.put("welcome", "hello");
    ScriptEngine engine = manager.getEngineByName("httl");
    // 设置引擎��
    engine.put("page", "test");
    Bindings bindings = engine.createBindings();
    // 设置执行��
    bindings.put("user", "liangfei");
    // 执行表达�
    String result = (String) engine.eval("#set(String welcome, String page, String user)${welcome}, ${user}, this is ${page} page.");
    assertEquals("hello, liangfei, this is test page.", result);
}

public static void main(String[] args) throws ScriptException {
    String extension = "jaml";
    ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
    ScriptEngine engine = scriptEngineManager.getEngineByExtension(extension);
    if (engine != null) {
        System.out.println(engine + " " + engine.getFactory());
        String input = "<JButton xmlns=\"http://java.com/namespaces/javax/swing\" Text=\"Click me\" />";
        System.out.println("Input: " + input);
        Object obj = engine.eval(input);
        System.out.println("Out: " + obj.getClass() + " (" + obj + ")");
    } else {
        System.out.println("No engine found for extension '" + extension + "'!");
    }
}

private PortalScript getPortalScript(final String scriptName) {
    if (this.scripts.containsKey(scriptName)) {
        return this.scripts.get(scriptName);
    }
    final File scriptFile = new File("scripts/portal/" + scriptName + ".js");
    if (!scriptFile.exists()) {
        this.scripts.put(scriptName, null);
        return null;
    }
    FileReader fr = null;
    final ScriptEngine portal = sef.getScriptEngine();
    try {
        fr = new FileReader(scriptFile);
        final CompiledScript compiled = ((Compilable) portal).compile(fr);
        compiled.eval();
    } catch (final ScriptExceptionIOException |  e) {
        System.err.println("THROW" + e);
    } finally {
        if (fr != null) {
            try {
                fr.close();
            } catch (final IOException e) {
                System.err.println("ERROR CLOSING" + e);
            }
        }
    }
    final PortalScript script = ((Invocable) portal).getInterface(PortalScript.class);
    this.scripts.put(scriptName, script);
    return script;
}

// JSR-223 way
static boolean evaluateGroovyExpressionToBool2(String script, ContextsStack stack) {
    ScriptEngineManager scMgr = new ScriptEngineManager();
    ScriptEngine engine = scMgr.getEngineByName("groovy");
    Object res;
    try {
        res = engine.eval(script, new StackScriptVariablesBinding(stack));
    } catch (ScriptException ex) {
        throw new IllegalArgumentException("Filter Groovy code failed to compile: " + ex.getMessage(), ex);
    }
    if (!(res instanceof Boolean)) {
        throw new IllegalArgumentException("Filter Groovy doesn't evaluate to boolean.");
    }
    return (Boolean) res;
}

public static ScriptEngine findScriptEngine(final String engine) {
    final ScriptEngineManager engineManager = new ScriptEngineManager();
    final List<ScriptEngineFactory> engineFactories = engineManager.getEngineFactories();
    for (final ScriptEngineFactory engineFactory : engineFactories) {
        if (isSameEngine(engineFactory, engine)) {
            return engineFactory.getScriptEngine();
        }
    }
    return null;
}

public static void main(String[] args) throws FileNotFoundException {
    ScriptEngineManager sem = new ScriptEngineManager();
    ScriptEngine ruby = sem.getEngineByExtension("rb");
    try {
        FileReader reader = new FileReader(new File("src/main/jruby", "hello_jena.rb"));
        ruby.eval(reader);
    } catch (ScriptException ex) {
        ex.printStackTrace();
    }
}

public Object evaluate(String script, String language, VariableScope variableScope) {
    Bindings bindings = createBindings(variableScope);
    ScriptEngine scriptEngine = null;
    try {
        scriptEngine = Extender.resolveScriptEngine(language);
    } catch (InvalidSyntaxException e) {
        throw new ActivitiException("problem resolving scripting engine" + e.getMessage(), e);
    }
    if (scriptEngine == null) {
        throw new ActivitiException("Can't find scripting engine for '" + language + "'");
    }
    try {
        return scriptEngine.eval(script, bindings);
    } catch (ScriptException e) {
        throw new ActivitiException("problem evaluating script: " + e.getMessage(), e);
    }
}

/** {@inheritDoc} */
@Override
public long delay() {
    long delay = 0;
    try {
        ScriptEngine scriptEngine = getScriptEngine();
        Object o = processFileOrScript(scriptEngine, null);
        if (o == null) {
            log.warn("Script did not return a value");
            return 0;
        }
        delay = Long.parseLong(o.toString());
    } catch (NumberFormatExceptionIOException | ScriptException |  e) {
        log.error("Problem in JSR223 script, {}", getName(), e);
    }
    return delay;
}

@Test
public void testScriptableMBean() throws Exception {
    ScriptEngineManager factory = new ScriptEngineManager();
    ScriptEngine engine = factory.getEngineByName("js");
    ScriptableMBeanServerConnection mbsc = new ScriptableMBeanServerConnection(ManagementFactory.getPlatformMBeanServer());
    engine.put("mbsc", mbsc);
    String script = "var logging = mbsc.getMBean('java.util.logging:type=Logging');" + "print(logging);" + "var loggers = logging.loggerNames;" + "for (var i = 0 ; i < loggers.length; i++) {" + "  print(loggers[i] + ' ' + logging.getLoggerLevel(loggers[i]));" + "  logging.setLoggerLevel(loggers[i], \"FINEST\");" + "  print(loggers[i] + ' ' + logging.getLoggerLevel(loggers[i]));" + "}";
    engine.eval(script);
// engine.eval("runtime.foo()");
}

/**
   * {@inheritDoc}
   */
@Override
public Object evaluate(IScript scriptable, Map<String, Object> context) {
    ScriptEngineManager enginesManager = new ScriptEngineManager();
    ScriptEngine engine = enginesManager.getEngineByName(scriptable.getLanguage());
    if (context != null) {
        engine.put(IScript.CONTEXT, context);
        engine.put(IScript.SCRIPTED_OBJECT, scriptable.getScriptedObject());
    }
    try {
        return engine.eval(scriptable.getScript());
    } catch (javax.script.ScriptException ex) {
        throw new ScriptException(ex);
    }
}

@Override
public void evaluate(Evaluation evaluation) {
    ScriptEngine engine = engineProvider.get();
    engine.put("$evaluation", evaluation);
    Policy policy = evaluation.getPolicy();
    try {
        engine.eval(policy.getConfig().get("code"));
    } catch (ScriptException e) {
        throw new RuntimeException("Error evaluating JS Policy [" + policy.getName() + "].", e);
    }
}

@Override
public NashornParserScript newScript(String scriptName) {
    // TODO: need to cache script file
    ScriptEngine nashornEngine = factory.getEngineByName("nashorn");
    File file = new File(scriptDir, scriptName + ".js");
    try {
        nashornEngine.eval(new FileReader(file));
    } catch (FileNotFoundException e) {
        throw new IllegalStateException("javascript parser script not found: " + file.getAbsolutePath(), e);
    } catch (ScriptException e) {
        throw new IllegalStateException("cannot eval parser script: " + file.getAbsolutePath(), e);
    }
    return new NashornParserScript(scriptName, nashornEngine);
}

public static void main(final String args[]) throws Exception {
    String lang = "CFML";
    String code = null;
    String arg;
    final String pw = null, key = null;
    for (int i = 0; i < args.length; i++) {
        arg = args[i];
        if ("-l".equals(arg)) {
            if (args.length > i + 1)
                lang = args[++i].trim();
        } else if ("-e".equals(arg))
            if (args.length > i + 1)
                code = args[++i].trim();
    }
    final int dialect = CFMLEngine.DIALECT_CFML;
    if (code == null)
        printUsage("-e is missing", System.err);
    final LuceeScriptEngineFactory factory = new LuceeScriptEngineFactory();
    System.out.println(factory.getScriptEngine().eval(code));
    final ScriptEngine engine = new ScriptEngineManager().getEngineByName(lang);
    if (engine == null)
        System.out.println("could not load a engine with the name:" + lang);
    else
        System.out.println(engine.eval(code));
}

public void init() {
    for (EventEntry entry : this.events.values()) {
        try {
            ((ScriptEngine) entry.iv).put("em", entry.em);
            entry.iv.invokeFunction("init", new Object[] { (Object) null });
        } catch (ScriptExceptionNoSuchMethodException |  ex) {
            FileoutputUtil.log("Error initiating event: " + entry.script + ":" + ex);
            FileoutputUtil.log(FileoutputUtil.Event_ScriptEx_Log, "Error initiating event: " + entry.script + ":" + ex);
        }
    }
}

/**
     * Do the work.
     */
public Evaluatable compileScript(Reader reader) {
    try {
        ScriptEngineManager manager = new ScriptEngineManager(classLoader);
        ScriptEngine engine = manager.getEngineByName(language);
        if (engine instanceof Invocable) {
            invocable = (Invocable) engine;
        }
        if (engine instanceof Compilable) {
            CompiledScript compiled = ((Compilable) engine).compile(reader);
            return new PreCompiled(engine, compiled);
        } else {
            return new NotPreCompiled(engine, reader);
        }
    } catch (ScriptException be) {
        throw new RuntimeException(be);
    }
}

static void eval(String script) {
    try {
        String fullScript = prependTypeDeclarations(script);
        Bindings bindings = createBindings();
        ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
        engine.setBindings(bindings, ScriptContext.GLOBAL_SCOPE);
        engine.eval(fullScript);
    } catch (Exception e) {
        Logger log = LoggerFactory.getLogger(JavaScript.class);
        log.error("failed to evaluate JavaScript", e);
    }
}

public static void main(String[] args) throws Exception {
    System.out.println("\nTest1\n");
    ScriptEngineManager manager = new ScriptEngineManager();
    ScriptEngine jsengine = Helper.getJsEngine(manager);
    if (jsengine == null) {
        System.out.println("Warning: No js engine found; test vacuously passes.");
        return;
    }
    jsengine.eval(new FileReader(new File(System.getProperty("test.src", "."), "Test1.js")));
}

public final void init() {
    for (EventEntry entry : this.events.values()) {
        try {
            ((ScriptEngine) entry.iv).put("em", entry.em);
            entry.iv.invokeFunction("init", new Object[] { (Object) null });
        } catch (Exception ex) {
            System.out.println("Error initiating event: " + entry.script + ":" + ex);
            FileoutputUtil.log("Log_Script_Except.txt", "Error initiating event: " + entry.script + ":" + ex);
        }
    }
}

@Override
public void run() {
    Database database = Factory.getSession(SessionType.CURRENT).getDatabase(databasePath_);
    ScriptEngineManager manager = new ScriptEngineManager();
    ScriptEngine engine = manager.getEngineByExtension(scriptExt_);
    engine.put("database", database);
    engine.put("session", database.getAncestorSession());
    ScriptContext context = engine.getContext();
    context.setWriter(new PrintWriter(System.out));
    context.setErrorWriter(new PrintWriter(System.err));
    try {
        engine.eval(script_);
    } catch (ScriptException e) {
        throw new RuntimeException(e);
    }
}

public ScriptEngine get(final OrientBaseGraph iGraph) {
    ScriptEngine engine = super.get();
    if (engine != null) {
        final OrientBaseGraph currGraph = (OrientBaseGraph) engine.getBindings(ScriptContext.ENGINE_SCOPE).get("g");
        if (currGraph == iGraph || (currGraph != null && currGraph.getRawGraph().getURL().equals(iGraph.getRawGraph().getURL()))) {
            // REUSE IT
            engine.getBindings(ScriptContext.ENGINE_SCOPE).put("g", iGraph);
            return engine;
        }
    }
    // CREATE A NEW ONE
    engine = new GremlinGroovyScriptEngine();
    engine.getBindings(ScriptContext.ENGINE_SCOPE).put("g", iGraph);
    set(engine);
    return engine;
}

public final void init() {
    for (EventEntry entry : this.events.values()) {
        try {
            ((ScriptEngine) entry.iv).put("em", entry.em);
            entry.iv.invokeFunction("init", new Object[] { (Object) null });
        } catch (Exception ex) {
            System.out.println("Error initiating event: " + entry.script + ":" + ex);
            FileoutputUtil.log("Log_Script_Except.txt", "Error initiating event: " + entry.script + ":" + ex);
        }
    }
}

@Override
public String getValue(String orginData) {
    String value = null;
    ScriptEngine engine = new ScriptEngineManager().getEngineByName("javascript");
    try {
        Object resObj = engine.eval(orginData);
        if (resObj != null) {
            value = resObj.toString();
        } else {
            value = "js not return!";
        }
    } catch (ScriptException e) {
        value = e.getMessage();
        e.printStackTrace();
    }
    return value;
}

@Override
protected ScriptEngine getScriptingEngine() {
    PythonScriptEngine pythonScriptEngine = EasyMock.createNiceMock(PythonScriptEngine.class);
    EasyMock.expect(pythonScriptEngine.getCloseOutputChannelsList()).andReturn(new LinkedList<String>());
    LocalApacheCommandLineExecutor executor = EasyMock.createNiceMock(LocalApacheCommandLineExecutor.class);
    EasyMock.expect(executor.getWorkDir()).andReturn(new File("")).anyTimes();
    EasyMock.replay(executor);
    EasyMock.expect(pythonScriptEngine.getExecutor()).andReturn(executor).anyTimes();
    return pythonScriptEngine;
}

@Override
public void actionPerformed(JTextComponent target, SyntaxDocument sDoc, int dot, ActionEvent e) {
    try {
        ScriptEngine eng = getEngine(target);
        if (eng != null) {
            getEngine(target).eval(target.getText());
        }
    } catch (ScriptException ex) {
        JOptionPane.showMessageDialog(SwingUtilities.getWindowAncestor(target), "Error executing script:\n" + ex.getMessage(), "Script Error", JOptionPane.ERROR_MESSAGE);
        ActionUtils.setCaretPosition(target, ex.getLineNumber(), ex.getColumnNumber());
    }
}

/**
     * Add rollup rule.
     *
     * @param rule rollup rule.
     */
public void addRollupRule(Object rule) {
    ScriptEngine engine = currentRollupRules.engine;
    Map<?, ?> ruleMap = JSMap.toMap(engine, rule);
    currentRollupRules.addRule(ruleMap);
    log.info("Added rollup rule: {}", ruleMap.get("name"));
    log.info("- Description: {}", ruleMap.get("description"));
    List<Object> args = JSList.toList(engine, ruleMap.get("args"));
    if (args != null && args.size() > 0) {
        log.info("- Arguments:");
        for (Object arg : args) {
            Map<?, ?> argMap = JSMap.toMap(engine, arg);
            log.info("  + {}: {}", argMap.get("name"), argMap.get("description"));
        }
    }
    // TODO commandMatchers
    if (ruleMap.containsKey("expandedCommands")) {
        log.info("- Expanded commands: array");
    } else if (ruleMap.containsKey("getExpandedCommands")) {
        log.info("- Expanded commands: function");
    } else {
        throw new SeleneseRunnerRuntimeException("Missing expandedCommands nor getExpandedCommands in rollup rule definition.");
    }
}

@Override
public ObservableList<String> execute(final CodeSnippet codeSnippet) {
    final ObservableList<String> consoleOutput = FXCollections.observableArrayList();
    final Thread snippetThread = new Thread(() -> {
        final StringWriter writer = new StringWriter();
        final ScriptEngineManager manager = new ScriptEngineManager();
        final ScriptEngine engine = manager.getEngineByName("nashorn");
        engine.getContext().setWriter(writer);
        try {
            engine.eval(codeSnippet.getCode());
            consoleOutput.add(writer.toString());
        } catch (ScriptException ex) {
            consoleOutput.add(ex.getMessage());
        }
    });
    snippetThread.start();
    return consoleOutput;
}

public static Object parse(String script, String func, Map<String, Object> params) {
    ScriptEngineManager mgr = new ScriptEngineManager();
    ScriptEngine se = mgr.getEngineByName("JavaScript");
    try {
        for (String param : params.keySet()) {
            se.put(param, params.get(param));
        }
        se.eval(script);
        return se.eval(func);
    } catch (ScriptException e) {
        SlimevoidCore.console(CoreLib.MOD_ID, e.getLocalizedMessage());
    }
    return null;
}

@Override
public void scopeValues(ScriptEngine engine, Map<String, Object> scopeValues) {
    Set<String> expressions = new HashSet<String>();
    for (Entry<String, Object> entry : scopeValues.entrySet()) {
        engine.put(entry.getKey(), entry.getValue());
        if (entry.getValue() instanceof Class) {
            expressions.add(String.format("%s = %s.static;", entry.getKey(), entry.getKey()));
        }
    }
    String scriptToEval = String.join("\n", expressions);
    try {
        engine.eval(scriptToEval);
    } catch (ScriptException e) {
        logger.error("ScriptException while importing scope: {}", e.getMessage());
    }
}

@Bean
public ScriptTemplateConfigurer scriptTemplateConfigurer() throws IOException {
    final ScriptTemplateConfigurer configurer = new ScriptTemplateConfigurer();
    configurer.setRenderFunction("render");
    configurer.setSharedEngine(true);
    ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
    configurer.setEngine(engine);
    addScripts(configurer);
    return configurer;
}

public void testHappyPath() throws Exception {
    final ScriptEngine engine = EasyMock.createMock(ScriptEngine.class);
    ScriptedView scriptedView = new ScriptedView() {

        @Override
        protected ScriptEngine createScriptEngine() {
            return engine;
        }
    };
    EasyMock.expect(engine.createBindings()).andReturn(new SimpleBindings());
    engine.setContext((ScriptContext) EasyMock.anyObject());
    EasyMock.expect(engine.eval((Reader) EasyMock.anyObject())).andReturn(null);
    EasyMock.replay(engine);
    scriptedView.setEngineName("test-engine");
    scriptedView.setScript(new ByteArrayResource("test".getBytes(), "test script"));
    JComponent control = scriptedView.createControl();
    System.out.println(control);
    EasyMock.verify(engine);
}

public void testHappyPath() throws Exception {
    final ScriptEngine engine = EasyMock.createMock(ScriptEngine.class);
    ScriptedView scriptedView = new ScriptedView() {

        @Override
        protected ScriptEngine createScriptEngine() {
            return engine;
        }
    };
    EasyMock.expect(engine.createBindings()).andReturn(new SimpleBindings());
    engine.setContext((ScriptContext) EasyMock.anyObject());
    EasyMock.expect(engine.eval((Reader) EasyMock.anyObject())).andReturn(null);
    EasyMock.replay(engine);
    scriptedView.setEngineName("test-engine");
    scriptedView.setScript(new ByteArrayResource("test".getBytes(), "test script"));
    JComponent control = scriptedView.createControl();
    System.out.println(control);
    EasyMock.verify(engine);
}

@Test
public void shouldReturnSpelScriptEngine() {
    SpelScriptEngineFactory spelScriptEngineFactory = new SpelScriptEngineFactory();
    ScriptEngine scriptEngine = spelScriptEngineFactory.getScriptEngine();
    assertTrue(scriptEngine instanceof SpelScriptEngine);
    assertEquals("SpringExpression", (String) spelScriptEngineFactory.getParameter(ScriptEngine.NAME));
}

/**
     * 
     * @param scriptName
     * @param script
     * @param engine
     * @param inputs
     * @param output
     * @return
     * @throws ScriptException
     */
public ScriptIOBean runScript(@Nullable String scriptName, @Nonnull String script, @Nonnull ScriptEngine engine, @Nonnull Map<String, Object> inputs, OutputLogger output) throws ScriptException {
    Reader reader = null;
    ScriptIOBean ioBean = null;
    try {
        reader = new StringReader(script);
        ioBean = new ScriptIOBean(inputs, output);
        engine.put("ioBean", ioBean);
        ioBean.println("Starting test...");
        engine.eval(reader, engine.getContext());
        ioBean.println("Finished test...");
    } catch (ScriptException e) {
        throw new ScriptException(e.getMessage(), scriptName, e.getLineNumber(), e.getColumnNumber());
    } finally {
        IOUtils.closeQuietly(reader);
    }
    return ioBean;
}

public static ScriptEngine setup(final ScriptEngine groovyScriptEngine) {
    try {
        for (Class<?> c : CoreImports.getClassImports()) {
            groovyScriptEngine.eval("import " + c.getName());
        }
        final Set<Class<?>> staticImports = new HashSet<>();
        for (Enum e : CoreImports.getEnumImports()) {
            staticImports.add(e.getDeclaringClass());
        }
        for (Method m : CoreImports.getMethodImports()) {
            staticImports.add(m.getDeclaringClass());
        }
        for (Class<?> c : staticImports) {
            groovyScriptEngine.eval("import static " + c.getName() + ".*");
        }
        return groovyScriptEngine;
    } catch (final ScriptException ex) {
        throw new IllegalStateException(ex.getMessage(), ex);
    }
}

@Override
public Object eval(Bindings bindings) throws ScriptException {
    // wait at most 10s to try to get a valid script engine
    ScriptEngine eng = _mgr.getScriptEngine(_type);
    if (eng == null) {
        throw new RuntimeException("Can not execute " + this + " because engine pool is exhausted or the application type is not supported.");
    }
    try {
        return eng.eval(_source, bindings);
    } finally {
        // make sure to return the engine when done
        _mgr.putScriptEngine(_type, eng);
    }
}

@Override
protected void execute(CommandEvent event) {
    ScriptEngine se = new ScriptEngineManager().getEngineByName("Nashorn");
    se.put("event", event);
    se.put("jda", event.getJDA());
    se.put("guild", event.getGuild());
    se.put("channel", event.getChannel());
    try {
        event.reply(event.getClient().getSuccess() + " Evaluated Successfully:\n```\n" + se.eval(event.getArgs()) + " ```");
    } catch (Exception e) {
        event.reply(event.getClient().getError() + " An exception was thrown:\n```\n" + e + " ```");
    }
}

public static void main(String[] args) throws IOException, ScriptException {
    // set up simple logging
    Log.wireUp();
    ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
    ScriptEngine engine = scriptEngineManager.getEngineByName("JavaScript");
    engine.eval("var event = {\"created_at\":\"2014-01-08T12:35:01-08:00\",\"alert_policy_name\":\"Key Transactions\",\"account_name\":\"NewRelic Administration\",\"severity\":\"critical\",\"message\":\"'BeaconServiceServlet/getAccountInformation' Apdex score < 0.7\",\"short_description\":\"Ended alert for Key Transactions: 'BeaconServiceServlet/getAccountInformation' Apdex score < 0.7\",\"long_description\":\"Alert ended for Key Transactions -- Triggered by: 'BeaconServiceServlet/getAccountInformation' Apdex score < 0.7 -- Key transactions currently involved: BeaconServiceServlet/getAccountInformation, Plugin Components Index, APIv2: Applications Index, KT test Transaction\",\"alert_url\":\"https://dev.newrelic.com/accounts/1/incidents/13861\"}\n");
    engine.put("log", new Log("script.js"));
    engine.put("utils", new Utils());
    engine.put("http", new HttpClient(HttpClientBuilder.create().build(), engine));
    engine.eval("var console = {log: function(msg) { log.info(msg); }}");
    engine.eval("log.info('foo', 'bar', 'baz')");
}

/**
	 * <a href="http://code.google.com/p/beanshell2/issues/detail?id=60">issue#60</a>
	 */
@Test
public void issue_60() throws Exception {
    final String script = "String foo = null;" + "if (foo != null && foo.length() > 0) return \"not empty\";" + "return \"empty\";";
    final ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
    scriptEngineManager.registerEngineName("beanshell", new BshScriptEngineFactory());
    final ScriptEngine engine = scriptEngineManager.getEngineByName("beanshell");
    assertNotNull(engine);
    Object result;
    result = engine.eval(script);
    assertEquals("empty", result);
    result = eval(script);
    assertEquals("empty", result);
}

public final void init() {
    for (final EventEntry entry : events.values()) {
        try {
            ((ScriptEngine) entry.iv).put("em", entry.em);
            entry.iv.invokeFunction("init", (Object) null);
        } catch (final ScriptExceptionNoSuchMethodException |  ex) {
            System.out.println("Error initiating event: " + entry.script + ":" + ex);
            FileoutputUtil.log(FileoutputUtil.ScriptEx_Log, "Error initiating event: " + entry.script + ":" + ex);
        }
    }
}

@Test
public void test_java_script_engine() {
    File projectFolder = getProjectFolder();
    File inputFolderFile = new File(projectFolder, RESOURCES_FOLDER);
    // File classFolderFile = new File(projectFolder,"tmp/java_shell_test_classes");
    String inputPath = inputFolderFile.getAbsolutePath();
    // Optional
    String classFolder = null;
    Iterable<String> compilationOptions = Arrays.asList(new String[] { "-source", "1.6", "-target", "1.6" });
    long scanPeriod = 300;
    RelProxyOnReloadListener proxyListener = new RelProxyOnReloadListener() {

        @Override
        public void onReload(Object objOld, Object objNew, Object proxy, Method method, Object[] args) {
            System.out.println("Reloaded " + objNew + " Calling method: " + method);
        }
    };
    JProxyCompilerListener compilerListener = new JProxyCompilerListener() {

        @Override
        public void beforeCompile(File file) {
            System.out.println("Before compile: " + file);
        }

        @Override
        public void afterCompile(File file) {
            System.out.println("After compile: " + file);
        }
    };
    JProxyDiagnosticsListener diagnosticsListener = new JProxyDiagnosticsListener() {

        @Override
        public void onDiagnostics(DiagnosticCollector<JavaFileObject> diagnostics) {
            List<Diagnostic<? extends JavaFileObject>> diagList = diagnostics.getDiagnostics();
            int i = 1;
            for (Diagnostic diagnostic : diagList) {
                System.err.println("Diagnostic " + i);
                System.err.println("  code: " + diagnostic.getCode());
                System.err.println("  kind: " + diagnostic.getKind());
                System.err.println("  line number: " + diagnostic.getLineNumber());
                System.err.println("  column number: " + diagnostic.getColumnNumber());
                System.err.println("  start position: " + diagnostic.getStartPosition());
                System.err.println("  position: " + diagnostic.getPosition());
                System.err.println("  end position: " + diagnostic.getEndPosition());
                System.err.println("  source: " + diagnostic.getSource());
                System.err.println("  message: " + diagnostic.getMessage(null));
                i++;
            }
        }
    };
    JProxyConfig jpConfig = JProxy.createJProxyConfig();
    jpConfig.setEnabled(true).setRelProxyOnReloadListener(proxyListener).setInputPath(inputPath).setJProxyInputSourceFileExcludedListener(null).setJProxyCompilerListener(compilerListener).setScanPeriod(scanPeriod).setClassFolder(classFolder).setCompilationOptions(compilationOptions).setJProxyDiagnosticsListener(diagnosticsListener);
    JProxyScriptEngineFactory factory = JProxyScriptEngineFactory.create();
    ScriptEngineManager manager = new ScriptEngineManager();
    manager.registerEngineName("Java", factory);
    manager.getBindings().put("msg", "HELLO GLOBAL WORLD!");
    ScriptEngine engine = manager.getEngineByName("Java");
    ((JProxyScriptEngine) engine).init(jpConfig);
    assertNotNull(engine);
    try {
        Bindings bindings = engine.createBindings();
        bindings.put("msg", "HELLO ENGINE SCOPE WORLD!");
        StringBuilder code = new StringBuilder();
        code.append(" javax.script.Bindings bindings = context.getBindings(javax.script.ScriptContext.ENGINE_SCOPE); \n");
        code.append(" String msg = (String)bindings.get(\"msg\"); \n");
        code.append(" System.out.println(msg); \n");
        code.append(" bindings = context.getBindings(javax.script.ScriptContext.GLOBAL_SCOPE); \n");
        code.append(" msg = (String)bindings.get(\"msg\"); \n");
        code.append(" System.out.println(msg); \n");
        code.append(" example.javashellex.JProxyShellExample.exec(engine); \n");
        code.append(" return \"SUCCESS\";");
        String result = (String) engine.eval(code.toString(), bindings);
        assertEquals("SUCCESS", result);
        bindings = engine.createBindings();
        bindings.put("msg", "HELLO ENGINE SCOPE WORLD 2!");
        code = new StringBuilder();
        code.append("public class _jproxyMainClass_ { \n");
        code.append("  public static Object main(javax.script.ScriptEngine engine,javax.script.ScriptContext context) {  \n");
        code.append("   javax.script.Bindings bindings = context.getBindings(javax.script.ScriptContext.ENGINE_SCOPE); \n");
        code.append("   String msg = (String)bindings.get(\"msg\"); \n");
        code.append("   System.out.println(msg); \n");
        code.append("   bindings = context.getBindings(javax.script.ScriptContext.GLOBAL_SCOPE); \n");
        code.append("   msg = (String)bindings.get(\"msg\"); \n");
        code.append("   System.out.println(msg); \n");
        code.append("   example.javashellex.JProxyShellExample.exec(engine); \n");
        code.append("   return \"SUCCESS 2\";");
        code.append("  }");
        code.append("}");
        result = (String) engine.eval(code.toString(), bindings);
        assertEquals("SUCCESS 2", result);
    } catch (ScriptException ex) {
        ex.printStackTrace();
        assertTrue(false);
    } finally {
        // Necessary if scanPeriod > 0 was defined                     
        boolean res = ((JProxyScriptEngine) engine).stop();
        assertTrue(res);
    }
}

protected Object evaluate(String script, String language, Bindings bindings) {
    ScriptEngine scriptEngine = scriptEngineManager.getEngineByName(language);
    if (scriptEngine == null) {
        throw new ActivitiException("Can't find scripting engine for '" + language + "'");
    }
    try {
        return scriptEngine.eval(script, bindings);
    } catch (ScriptException e) {
        throw new ActivitiException("problem evaluating script: " + e.getMessage(), e);
    }
}

@Override
public ScriptEngine getScriptEngine() {
    System.setProperty(PropertyName.CLASSLOADER.toString(), "context");
    ClassLoader originalContextClassLoader = Thread.currentThread().getContextClassLoader();
    Thread.currentThread().setContextClassLoader(getClassLoader());
    try {
        return super.getScriptEngine();
    } finally {
        Thread.currentThread().setContextClassLoader(originalContextClassLoader);
    }
}

@SuppressWarnings("unchecked")
private T getImplementation(String code, Class<?> type) {
    try {
        ScriptEngineManager engineManager = new ScriptEngineManager();
        ScriptEngine engine = engineManager.getEngineByName("nashorn");
        if (engine == null) {
            throw new Error("A javascript engine could not be found!");
        }
        Invocable invocable = (Invocable) engine;
        engine.eval(code);
        return (T) invocable.getInterface(type);
    } catch (ScriptException e) {
        throw new IllegalArgumentException("Could not compile Javascript code!", e);
    }
}

public static void calcular(TextField campo) throws Erro {
    Validar.textField(campo);
    if (campo.getText().contains(",")) {
        Janela.showTooltip(Status.ADVERTENCIA, Linguagem.getInstance().getMensagem("use_ponto_decimais"), campo, Duracao.NORMAL);
    } else {
        ScriptEngineManager sem = new ScriptEngineManager();
        ScriptEngine engine = sem.getEngineByName("JavaScript");
        String texto = campo.getText();
        try {
            campo.setText(engine.eval(texto).toString());
        } catch (ScriptException ex) {
            Janela.showTooltip(Status.ADVERTENCIA, Linguagem.getInstance().getMensagem("operacao_matematica_invalida"), campo, Duracao.NORMAL);
        }
    }
    throw new Erro();
}

@Override
public void actionPerformed(JTextComponent target, SyntaxDocument sDoc, int dot, ActionEvent e) {
    try {
        ScriptEngine eng = getEngine(target);
        if (eng != null) {
            getEngine(target).eval(target.getText());
        }
    } catch (ScriptException ex) {
        JOptionPane.showMessageDialog(SwingUtilities.getWindowAncestor(target), "Error executing script:\n" + ex.getMessage(), "Script Error", JOptionPane.ERROR_MESSAGE);
        ActionUtils.setCaretPosition(target, ex.getLineNumber(), ex.getColumnNumber());
    }
}

@Override
public ScriptEngine getScriptEngineForLanguage(String language) {
    ScriptEngine scriptEngine = null;
    try {
        scriptEngine = resolveScriptEngine(language);
    } catch (InvalidSyntaxException e) {
        throw new ProcessEngineException("problem resolving scripting engine" + e.getMessage(), e);
    }
    if (scriptEngine == null) {
        throw new ProcessEngineException("Can't find scripting engine for '" + language + "'");
    }
    return scriptEngine;
}

private void evaluateJavascript(String file) {
    // JavaScript
    ScriptEngineManager engineMgr = new ScriptEngineManager();
    ScriptEngine engine = engineMgr.getEngineByName("JavaScript");
    try {
        InputStream is = new FileInputStream(file);
        Reader reader = new InputStreamReader(is);
        engine.eval(reader);
    } catch (ScriptException ex) {
        environment.writer().print(ex);
        throw new RuntimeException(ex);
    } catch (FileNotFoundException e) {
        throw new RuntimeException(e);
    }
}

public void execute() throws MojoExecutionException, MojoFailureException {
    loadUserInfoFromSettings();
    if (files.length == 0) {
        this.getLog().warn("No script to run");
        return;
    }
    Reader reader = null;
    StreamConnection stream = null;
    try {
        stream = this.getStreamConnection();
        ScriptEngine engine = this.getScriptEngine();
        engine.put("conn", stream);
        engine.put("host", this.host);
        engine.put("username", this.username);
        engine.put("password", this.password);
        for (File script : files) {
            reader = new FileReader(script);
            engine.eval(reader);
            IOUtil.close(reader);
            reader = null;
        }
    } catch (Exception e) {
        throw new MojoExecutionException("Error in script execution.", e);
    } finally {
        IOUtil.close(reader);
        if (stream != null) {
            try {
                stream.disconnect();
            } catch (Exception e) {
            }
        }
    }
}

public void testScriptEngine() throws ScriptException, NoSuchMethodException {
    ScriptEngineManager manager = new ScriptEngineManager();
    ScriptEngine engine = manager.getEngineByName("JavaScript");
    String script = "function nvlTest(value) {\n" + "        return func.nvl(value, 'F');\n" + "    }";
    String script2 = "function test(value) { return value; }";
    engine.put("func", new DBFunction());
    engine.eval(script);
    engine.eval(script2);
    Object result = ((Invocable) engine).invokeFunction("nvlTest", null);
    Object result2 = ((Invocable) engine).invokeFunction("test", null);
    Debug.line(result);
    Debug.line(result2);
}

private void initRhino() throws Exception {
    ScriptEngineManager manager = new ScriptEngineManager();
    ScriptEngine engine = manager.getEngineByName(JAVA_SCRIPT);
    Bindings bindings = getBindings(engine);
    engine.setBindings(bindings, ENGINE_SCOPE);
    String jsFiles = ziggyFileLoader.getJSFiles();
    engine.eval(jsFiles);
    engine.eval(JS_INIT_SCRIPT);
    ziggyFormController = engine.get("controller");
    invocable = (Invocable) engine;
}

@Override
public Object getParameter(String key) {
    switch(key) {
        case ScriptEngine.ENGINE:
            return getEngineName();
        case ScriptEngine.ENGINE_VERSION:
            return getEngineVersion();
        case ScriptEngine.NAME:
            return getNames().get(0);
        case ScriptEngine.LANGUAGE:
            return getLanguageName();
        case ScriptEngine.LANGUAGE_VERSION:
            return getLanguageVersion();
        case "THREADING":
            return null;
        default:
            return null;
    }
}