ScriptingContainer

Overview

Package

Class

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.jruby.embed
Class ScriptingContainer

java.lang.Object
  org.jruby.embed.ScriptingContainer

All Implemented Interfaces:: EmbedRubyInstanceConfigAdapter

public class ScriptingContainer
extends java.lang.Object
implements EmbedRubyInstanceConfigAdapter
extends java.lang.Object
implements EmbedRubyInstanceConfigAdapter

ScipritngContainer provides various methods and resources that are useful for embedding Ruby in Java. Using this class, users can run Ruby scripts from Java programs easily. Also, users can use methods defined or implemented by Ruby. ScriptingContainer has a couple of configuration parameters per container base. Those are a local context scope, local variable behavior, and property file. These parameters should be given when the container is instantiated; otherwise, default values are applied to. Below are examples. The first Example is a very simple Hello World. After initializing a ScriptingContainer, a Ruby script, puts "Hello World!", runs and produces "Hello World!."

Example 1:

         ScriptingContainer container = new ScriptingContainer();
         container.runScriptlet("puts \"Hello World!\"");

 Produces:
 Hello World!

The second example shows how to share variables between Java and Ruby. In this example, a local variable "x" is shared. Unlike JSR223 JRuby engine, Ruby's local, instance, global variables and constants are available to share on ScrriptingContainer. (A class variable sharing does not work on current version) Thus, "x" in Java is also "x" in Ruby.

Example 2:

         ScriptingContainer container = new ScriptingContainer();
         container.put("x", 12345);
         container.runScriptlet("puts x.to_s(2)");

 Produces:
 11000000111001

The third examples shows how to keep local variables across multiple evaluations. This feature simulates BSF engine for JRuby. In terms of Ruby semantics, local variables should not survive after the evaluation has completed. Thus, this behavior is optional, and users need to specify LocalVariableBehvior.PERSISTENT when the container is instantiated.

Example 3:
 
         ScriptingContainer container = new ScriptingContainer(LocalVariableBehavior.PERSISTENT);
         container.runScriptlet("p=9.0");
         container.runScriptlet("q = Math.sqrt p");
         container.runScriptlet("puts \"square root of #{p} is #{q}\"");
         System.out.println("Ruby used values: p = " + container.get("p") +
               ", q = " + container.get("q"));

 Produces:
 square root of 9.0 is 3.0
 Ruby used values: p = 9.0, q = 3.0

Also, ScriptingContainer provides better i18n support. For example, Unicode Escape Sequence can be included in Ruby scripts.

In addition, ScriptingContainer supports a parse-once-eval-many-times feature, invoking methods defined by Ruby, and getting an instance of a specified interface that has been implemented by Ruby.

Example 4:
         ScriptingContainer container = new ScriptingContainer();
         script =
          "def message\n" +
              "\"message: #\"\n" +
          "end\n" +
          "message";
         container.put("@message", "What's up?");
         EvalUnit unit = container.parse(script);
         IRubyObject ret = unit.run();
         System.out.println(JavaEmbedUtils.rubyToJava(ret));
         container.put("@message", "Fabulous!");
         ret = unit.run();
         System.out.println(JavaEmbedUtils.rubyToJava(ret));
         container.put("@message", "That's the way you are.");
         ret = unit.run();
         System.out.println(JavaEmbedUtils.rubyToJava(ret));
 
 Produces:
     message: What's up?
     message: Fabulous!
     message: That's the way you are.

See more details at project's Wiki

Constructor Summary
`ScriptingContainer()` Constructs a ScriptingContainer with a default values.
`ScriptingContainer(LocalContextScope scope)`
`ScriptingContainer(LocalContextScope scope, LocalVariableBehavior behavior)`
`ScriptingContainer(LocalContextScope scope, LocalVariableBehavior behavior, java.lang.String propertyname)` Constructs a ScriptingContainer with a specified local context scope, local variable behavior and property file.
`ScriptingContainer(LocalVariableBehavior behavior)`

Method Summary

java.lang.Object callMethod(java.lang.Object receiver, java.lang.String methodName, org.jruby.runtime.Block block, java.lang.Object... args)
Executes a method defined in Ruby script.





<T> T

callMethod(java.lang.Object receiver,
           java.lang.String methodName,
           java.lang.Class<T> returnType)