Question

BACKGROUND:

I am using JRuby in an eclipse plugin for my product. I have a bunch of scripts that define a DSL and perform operations for me. I want to be able to dynamically reload these scripts whenever required. The scripts could change themselves on file system and moreover the location of the scripts could also change. I could even have multiple copies on file system of slightly modified/changed scripts. Each time I want scripts from a specific location to be utilized.

As I have understood so far, using “load” instead of “require” should do the job. So now if before calling any Ruby methods/functions I use “load ‘XXX.rb'”, it will reload the XXX.rb utilizing the new changes.

PROBLEM:

In my code I am using ScriptingContainer to run scriplets to access ruby functions. I set load paths on this scripting container to indicate from which locations the scripts should be loaded. However, the problem is that on subsequent calls and even with different instances of ScriptingContainer, I have noticed that the scripts that were loaded the first time are utilized every time. “load” reloads them, but after loading those scripts once, the next time I might need to load similar scripts from a different location but its not happening.

My assumption was that utilizing a different scripting container instance should have done the job but it seems that the load paths are globally set somewhere and calling “setLoadPath” on new ScriptingContainer instances either does not modify existing paths or only appends. If the latter case is true then probably when searching for scripts they are always found on oldest paths set and newer load paths get ignored.

Any ideas???

Answer 1

The solution is to specify scope for a ScriptingContainer instance when creating it. One of the ScriptingContainer constructors takes in a parameter of type LocalContextScope, use one of the constants to define the scope. See LocalContextScope.java

To test this defect and solution I have written a small snippet. You may try it out:

public class LoadPathProblem {

  public static void main(String[] args) {
    // Create the first container
    ScriptingContainer c1 = new ScriptingContainer();
    // FIX ScriptingContainer c1 = new ScriptingContainer(LocalContextScope.SINGLETHREAD);

    // Setting a load path for scripts
    String path1[] = new String[] { ".\\scripts\\one" };
    c1.getProvider().setLoadPaths(Arrays.asList(path1));

    // Run a script that requires loading scripts in the load path above
    EvalUnit unit1 = c1.parse("load 'test.rb'\n" + "testCall");
    IRubyObject ret1 = unit1.run();
    System.out.println(JavaEmbedUtils.rubyToJava(ret1));

    // Create the second container, completely independent of the first one
    ScriptingContainer c2 = new ScriptingContainer();
    // FIX ScriptingContainer c2 = new ScriptingContainer(LocalContextScope.SINGLETHREAD);

    // Setting a different load path for this container as compared to the first container
    String path2[] = new String[] { ".\\Scripts\\two" };
    c2.getProvider().setLoadPaths(Arrays.asList(path2));

    // Run a script that requires loading scripts in the different path
    EvalUnit unit2 = c2.parse("load 'test.rb'\n" + "testCall");
    IRubyObject ret2 = unit2.run();

    /*
     * PROBLEM: Expected here that the function testCall will be called from
     * the .\scripts\two\test.rb, but as you can see the output says that
     * the function was still called from .\scripts\one\test.rb.
     */
    System.out.println(JavaEmbedUtils.rubyToJava(ret2));
  }
}

Test scripts to try out the above code can be in different folders but with the same filename (“test.rb” for the above example:

./scripts/one/test.rb

def testCall
  "Called one"
end

./scripts/two/test.rb

def testCall
  "Called two"
end