Java JavaEmbedUtils类代码示例

import org.jruby.javasupport.JavaEmbedUtils; //导入依赖的package包/类
protected Callable<Ruby> getInitRuby(final Writer out, final Writer err) {
    return new Callable<Ruby>() {
        @Override public Ruby call() throws Exception {
            RubyInstanceConfig config = new RubyInstanceConfig();
            config.setCompileMode(CompileMode.OFF);
            List<String> loadPaths = new ArrayList<String>();
            setModule(loadPaths);
            String appRubyPath = System.getProperty(PROP_APPLICATION_RUBYPATH);
            if (appRubyPath != null) {
                StringTokenizer tok = new StringTokenizer(appRubyPath, ";");
                while (tok.hasMoreTokens()) {
                    loadPaths.add(tok.nextToken().replace('/', File.separatorChar));
                }
            }
            config.setOutput(new PrintStream(new WriterOutputStream(out)));
            config.setError(new PrintStream(new WriterOutputStream(err)));
            Ruby interpreter = JavaEmbedUtils.initialize(loadPaths, config);
            interpreter.evalScriptlet("require 'selenium/webdriver'");
            interpreter.evalScriptlet("require 'marathon/results'");
            interpreter.evalScriptlet("require 'marathon/playback-" + framework + "'");
            return interpreter;
        }
    };
}
 

import org.jruby.javasupport.JavaEmbedUtils; //导入依赖的package包/类
@Test(enabled = false) public void resultsCapturesJavaError() throws Exception {
    RubyScript script = new RubyScript(out, err, converToCode(SCRIPT_CONTENTS_ERROR_FROM_JAVA),
            new File(System.getProperty(Constants.PROP_PROJECT_DIR), "dummyfile.rb").getAbsolutePath(), false, null,
            Constants.FRAMEWORK_SWING);
    script.setDriverURL("");
    Ruby interpreter = script.getInterpreter();
    assertTrue("Collector not defined", interpreter.isClassDefined("Collector"));
    RubyClass collectorClass = interpreter.getClass("Collector");
    IRubyObject presult = JavaEmbedUtils.javaToRuby(interpreter, result);
    IRubyObject collector = collectorClass.newInstance(interpreter.getCurrentContext(), new IRubyObject[0], new Block(null));
    IRubyObject rubyObject = interpreter.evalScriptlet("proc { my_function }");
    try {
        collector.callMethod(interpreter.getCurrentContext(), "callprotected", new IRubyObject[] { rubyObject, presult });
    } catch (Throwable t) {

    }
    assertEquals(1, result.failureCount());
    Failure[] failures = result.failures();
    assertTrue("Should end with TestRubyScript.java. but has " + failures[0].getTraceback()[0].fileName,
            failures[0].getTraceback()[0].fileName.endsWith("TestRubyScript.java"));
    assertEquals("throwError", failures[0].getTraceback()[0].functionName);
}
 

import org.jruby.javasupport.JavaEmbedUtils; //导入依赖的package包/类
public Object evaluate(final String expression, final Map<String, ?> values) throws ExpressionEvaluationException {
    LOG.debug("Evaluating JRuby expression: {1}", expression);
    try {
        final RubyInstanceConfig config = new RubyInstanceConfig();
        config.setCompatVersion(CompatVersion.RUBY1_9);
        final Ruby runtime = JavaEmbedUtils.initialize(new ArrayList<String>(), config);

        final StringBuilder localVars = new StringBuilder();
        for (final Entry<String, ?> entry : values.entrySet()) {
            runtime.getGlobalVariables().set("$" + entry.getKey(), JavaEmbedUtils.javaToRuby(runtime, entry.getValue()));
            localVars.append(entry.getKey()) //
                .append("=$") //
                .append(entry.getKey()) //
                .append("\n");
        }
        final IRubyObject result = runtime.evalScriptlet(localVars + expression);
        return JavaEmbedUtils.rubyToJava(runtime, result, Object.class);
    } catch (final RuntimeException ex) {
        throw new ExpressionEvaluationException("Evaluating JRuby expression failed: " + expression, ex);
    }
}
 

import org.jruby.javasupport.JavaEmbedUtils; //导入依赖的package包/类
public void modifyContext(CommandElement command, CommandContext context)
{
	IEditorPart editor = this.getActiveEditor();

	if (editor != null && command != null)
	{
		Ruby runtime = command.getRuntime();

		if (runtime != null)
		{
			IRubyObject rubyInstance = ScriptUtils.instantiateClass(runtime, ScriptUtils.RUBLE_MODULE,
					EDITOR_RUBY_CLASS, JavaEmbedUtils.javaToRuby(runtime, editor));

			context.put(EDITOR_PROPERTY_NAME, rubyInstance);
		}
		else
		{
			context.put(EDITOR_PROPERTY_NAME, null);
		}
	}
}
 

import org.jruby.javasupport.JavaEmbedUtils; //导入依赖的package包/类
@JRubyMethod(required = 1, optional = 2)
public IRubyObject convert(ThreadContext context, IRubyObject[] args) {
    AbstractNode node = NodeConverter.createASTNode(args[0]);

    Object ret = null;
    if (args.length == 1) {
        ret = delegate.convert(
                node,
                null,
                Collections.emptyMap());
    } else if (args.length == 2) {
        ret = delegate.convert(
                node,
                (String) JavaEmbedUtils.rubyToJava(getRuntime(), args[1], String.class),
                Collections.emptyMap());//RubyString.objAsString(context, args[1]).asJavaString());
    } else if (args.length == 3) {
        ret = delegate.convert(
                node,
                (String) JavaEmbedUtils.rubyToJava(getRuntime(), args[1], String.class),
                (Map) JavaEmbedUtils.rubyToJava(getRuntime(), args[2], Map.class));
    }
    return JavaEmbedUtils.javaToRuby(getRuntime(), ret);
}
 

import org.jruby.javasupport.JavaEmbedUtils; //导入依赖的package包/类
public Inline createInline(AbstractBlock parent, String context, String text, Map<String, Object> attributes, Map<String, Object> options) {
    
    options.put(Options.ATTRIBUTES, attributes);
    
    IRubyObject rubyClass = rubyRuntime.evalScriptlet("Asciidoctor::Inline");
    RubyHash convertedOptions = RubyHashUtil.convertMapToRubyHashWithSymbols(rubyRuntime, options);
    // FIXME hack to ensure we have the underlying Ruby instance
    try {
        parent = parent.delegate();
    } catch (Exception e) {}

    Object[] parameters = {
            parent,
            RubyUtils.toSymbol(rubyRuntime, context),
            text,
            convertedOptions };
    return (Inline) JavaEmbedUtils.invokeMethod(rubyRuntime, rubyClass,
            "new", parameters, Inline.class);
}
 

import org.jruby.javasupport.JavaEmbedUtils; //导入依赖的package包/类
private Block createBlock(AbstractBlock parent, String context,
        Map<Object, Object> options) {
    IRubyObject rubyClass = rubyRuntime.evalScriptlet("Asciidoctor::Block");
    RubyHash convertMapToRubyHashWithSymbols = RubyHashUtil.convertMapToRubyHashWithSymbolsIfNecessary(rubyRuntime,
            options);
    // FIXME hack to ensure we have the underlying Ruby instance
    try {
        parent = parent.delegate();
    } catch (Exception e) {}

    Object[] parameters = {
            parent,
            RubyUtils.toSymbol(rubyRuntime, context),
            convertMapToRubyHashWithSymbols };
    return (Block) JavaEmbedUtils.invokeMethod(rubyRuntime, rubyClass,
            "new", parameters, Block.class);
}
 

import org.jruby.javasupport.JavaEmbedUtils; //导入依赖的package包/类
private static IRubyObject toRubyObject(Ruby rubyRuntime, Object value) {

        if (value instanceof List) {
            return toRubyArray(rubyRuntime, (List<Object>) value);
        } else {

            if (isNotARubySymbol(value)) {
                String stringValue = ((String) value);

                if (stringValue.startsWith(":")) {
                    return RubyUtils.toSymbol(rubyRuntime, stringValue.substring(1));
                }
            }

            IRubyObject iRubyObject = JavaEmbedUtils.javaToRuby(rubyRuntime, value);
            return iRubyObject;
        }
    }
 

import org.jruby.javasupport.JavaEmbedUtils; //导入依赖的package包/类
@Override public String getProperty(String name) {
    Ruby runtime = o.getRuntime();
    o = marathon.callMethod(runtime.getCurrentContext(), "refresh_if_stale", o);
    marathon.callMethod(runtime.getCurrentContext(), "setContext", o);
    if ("tag_name".equals(name) || "tagName".equals(name)) {
        return o.callMethod(runtime.getCurrentContext(), "tag_name").toString().toUpperCase();
    }
    return o.callMethod(runtime.getCurrentContext(), "attribute", JavaEmbedUtils.javaToRuby(runtime, name)).toString();
}
 

import org.jruby.javasupport.JavaEmbedUtils; //导入依赖的package包/类
private void defineVariable(String variable, Object value) {
    try {
        GlobalVariable v = new GlobalVariable(interpreter, "$" + variable, JavaEmbedUtils.javaToRuby(interpreter, value));
        interpreter.defineVariable(v, Scope.GLOBAL);
    } catch (Throwable t) {
        throw new ScriptException("Failed to define variable " + variable + " value = " + value + ":" + t.getMessage(), t);
    }
}
 

import org.jruby.javasupport.JavaEmbedUtils; //导入依赖的package包/类
private void findAssertionProviderMethods() {
    IRubyObject ro = interpreter.evalScriptlet("Object.private_instance_methods");
    String[] methods = (String[]) JavaEmbedUtils.rubyToJava(interpreter, ro, String[].class);
    assertionProviderList = new ArrayList<String>();
    for (Object method : methods) {
        if (method.toString().startsWith("marathon_assert_")) {
            assertionProviderList.add(method.toString());
        }
    }
}
 

import org.jruby.javasupport.JavaEmbedUtils; //导入依赖的package包/类
private IRubyObject[] convertToRuby(Object[] javaArgs) {
	if (javaArgs == null || javaArgs.length == 0) {
		return new IRubyObject[0];
	}
	IRubyObject[] rubyArgs = new IRubyObject[javaArgs.length];
	for (int i = 0; i < javaArgs.length; ++i) {
		rubyArgs[i] = JavaEmbedUtils.javaToRuby(this.ruby, javaArgs[i]);
	}
	return rubyArgs;
}
 

import org.jruby.javasupport.JavaEmbedUtils; //导入依赖的package包/类
private Object convertFromRuby(IRubyObject rubyResult, Class<?> returnType) {
	Object result = JavaEmbedUtils.rubyToJava(this.ruby, rubyResult, returnType);
	if (result instanceof RubyArray && returnType.isArray()) {
		result = convertFromRubyArray(((RubyArray) result).toJavaArray(), returnType);
	}
	return result;
}
 

import org.jruby.javasupport.JavaEmbedUtils; //导入依赖的package包/类
@Override
public Object invokeMethod(Object target, String name, Object... args) {
    try {
        IRubyObject rubyObject = JavaEmbedUtils.javaToRuby(container.getProvider().getRuntime(), target);
        return container.callMethod(rubyObject, name, args);
    } catch (Throwable e) {
        throw SpongeUtils.wrapException(target + "." + name, e);
    }
}
 

import org.jruby.javasupport.JavaEmbedUtils; //导入依赖的package包/类
@Bean
public Asciidoctor asciidoctor() {
    RubyInstanceConfig rubyInstanceConfig = new RubyInstanceConfig();
    rubyInstanceConfig.setLoader(this.getClass().getClassLoader());
    JavaEmbedUtils.initialize(Arrays.asList("META-INF/jruby.home/lib/ruby/2.0", "classpath:/gems/asciidoctor-1.5.4/lib"), rubyInstanceConfig);
    return create(this.getClass().getClassLoader());
}