ruboto 0.7.0 → 0.8.0

data/assets/src/RubotoBroadcastReceiver.java

@@ -3,8 +3,10 @@ package THE_PACKAGE;
 import java.io.IOException;
 
 public class THE_RUBOTO_CLASS THE_ACTION THE_ANDROID_CLASS {
-    private String scriptName = null;
+    private String rubyClassName;
+    private String scriptName;
     private Object rubyInstance;
+    private Object[] callbackProcs = new Object[CONSTANTS_COUNT];
 
     public void setCallbackProc(int id, Object obj) {
         // Error: no callbacks
@@ -32,48 +34,82 @@ public class THE_RUBOTO_CLASS THE_ACTION THE_ANDROID_CLASS {
     }
 
     protected void loadScript() {
+        rubyInstance = this;
 
         // TODO(uwe):  Only needed for non-class-based definitions
         // Can be removed if we stop supporting non-class-based definitions
     	JRubyAdapter.put("$broadcast_receiver", this);
     	// TODO end
 
-        if (scriptName != null) {
-            try {
+        try {
+            if (scriptName != null) {
                 String rubyClassName = Script.toCamelCase(scriptName);
                 System.out.println("Looking for Ruby class: " + rubyClassName);
-                Object rubyClass = JRubyAdapter.get(rubyClassName);
+                Object rubyClass = null;
+                String script = new Script(scriptName).getContents();
+                if (script.matches("(?s).*class " + rubyClassName + ".*")) {
+                    if (!rubyClassName.equals(getClass().getSimpleName())) {
+                        System.out.println("Script defines methods on meta class");
+                        // FIXME(uwe): Simplify when we stop support for RubotoCore 0.4.7
+                        if (JRubyAdapter.isJRubyPreOneSeven() || JRubyAdapter.isRubyOneEight()) {
+                            JRubyAdapter.put("$java_instance", this);
+                            JRubyAdapter.put(rubyClassName, JRubyAdapter.runScriptlet("class << $java_instance; self; end"));
+                        } else if (JRubyAdapter.isJRubyOneSeven() && JRubyAdapter.isRubyOneNine()) {
+                            JRubyAdapter.put(rubyClassName, JRubyAdapter.runRubyMethod(this, "singleton_class"));
+                        } else {
+                            throw new RuntimeException("Unknown JRuby/Ruby version: " + JRubyAdapter.get("JRUBY_VERSION") + "/" + JRubyAdapter.get("RUBY_VERSION"));
+                        }
+                    }
+                } else {
+                    rubyClass = JRubyAdapter.get(rubyClassName);
+                }
                 if (rubyClass == null) {
                     System.out.println("Loading script: " + scriptName);
-                    JRubyAdapter.exec(new Script(scriptName).getContents());
+                    if (script.matches("(?s).*class " + rubyClassName + ".*")) {
+                        System.out.println("Script contains class definition");
+                        if (rubyClassName.equals(getClass().getSimpleName())) {
+                            System.out.println("Script has separate Java class");
+
+                            // TODO(uwe):  Why doesnt this work?
+                            // JRubyAdapter.put(rubyClassName, JRubyAdapter.runScriptlet("Java::" + getClass().getName()));
+
+                            // TODO(uwe):  Workaround...
+                            JRubyAdapter.runScriptlet(rubyClassName + " = Java::" + getClass().getName());
+                        }
+                        // System.out.println("Set class: " + JRubyAdapter.get(rubyClassName));
+                    }
+                    JRubyAdapter.setScriptFilename(scriptName);
+                    JRubyAdapter.runScriptlet(script);
                     rubyClass = JRubyAdapter.get(rubyClassName);
                 }
-                if (rubyClass != null) {
-                    System.out.println("Instanciating Ruby class: " + rubyClassName);
-                    rubyInstance = JRubyAdapter.callMethod(rubyClass, "new", this, Object.class);
-                }
-            } catch(IOException e) {
-                throw new RuntimeException("IOException loading broadcast receiver script", e);
             }
+        } catch(IOException e) {
+            throw new RuntimeException("IOException loading broadcast receiver script", e);
         }
     }
 
     public void onReceive(android.content.Context context, android.content.Intent intent) {
         try {
-            System.out.println("onReceive: " + rubyInstance);
-            if (rubyInstance != null) {
-            	JRubyAdapter.callMethod(rubyInstance, "on_receive", new Object[]{context, intent});
+            Log.d("onReceive: " + this);
+
+            // FIXME(uwe):  Only needed for older broadcast receiver using callbacks
+            // FIXME(uwe):  Remove if we stop suppporting callbacks (to avoid global variables).
+            JRubyAdapter.put("$context", context);
+            JRubyAdapter.put("$intent", intent);
+            JRubyAdapter.put("$broadcast_receiver", this);
+            // FIXME end
+
+            // FIXME(uwe): Simplify when we stop supporting JRuby 1.6.x
+            if (JRubyAdapter.isJRubyPreOneSeven()) {
+                JRubyAdapter.runScriptlet("$broadcast_receiver.on_receive($context, $intent)");
+            } else if (JRubyAdapter.isJRubyOneSeven()) {
+        	    JRubyAdapter.runRubyMethod(this, "on_receive", new Object[]{context, intent});
             } else {
-                // TODO(uwe):  Only needed for non-class-based definitions
-                // Can be removed if we stop supporting non-class-based definitions
-                JRubyAdapter.put("$context", context);
-                JRubyAdapter.put("$broadcast_receiver", this);
-                JRubyAdapter.put("$intent", intent);
-            	JRubyAdapter.execute("$broadcast_receiver.on_receive($context, $intent)");
-            	// TODO end
-            }
+                throw new RuntimeException("Unknown JRuby version: " + JRubyAdapter.get("JRUBY_VERSION"));
+        	}
         } catch(Exception e) {
             e.printStackTrace();
         }
     }
-}	
+
+}

data/assets/src/RubotoService.java

@@ -4,67 +4,121 @@ import org.ruboto.Script;
 import java.io.IOException;
 
 public class THE_RUBOTO_CLASS THE_ACTION THE_ANDROID_CLASS {
-  private String scriptName;
-  public Object[] args;
-  private Object rubyInstance;
-
 THE_CONSTANTS
 
-  private Object[] callbackProcs = new Object[CONSTANTS_COUNT];
+    private String rubyClassName;
+    private String scriptName;
+    private Object rubyInstance;
+    private Object[] callbackProcs = new Object[CONSTANTS_COUNT];
+    public Object[] args;
 
-  public void setCallbackProc(int id, Object obj) {
-    callbackProcs[id] = obj;
-  }
+    public void setCallbackProc(int id, Object obj) {
+      callbackProcs[id] = obj;
+    }
 	
-  public void setScriptName(String name){
-    scriptName = name;
-  }
+    public void setScriptName(String name){
+        scriptName = name;
+    }
 
-  /****************************************************************************************
-   * 
-   *  Activity Lifecycle: onCreate
-   */
-	
-  @Override
-  public void onCreate() {
-	System.out.println("RubotoService.onCreate()");
-    args = new Object[0];
+    /****************************************************************************************
+     *
+     *  Service Lifecycle: onCreate
+     */
+
+    @Override
+    public void onCreate() {
+        // Return if we are called from JRuby to avoid infinite recursion.
+        StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
+        for(StackTraceElement e : stackTraceElements){
+            if (e.getClassName().equals("java.lang.reflect.Method") && e.getMethodName().equals("invokeNative")) {
+                return;
+            }
+            if (e.getClassName().equals("android.app.ActivityThread") && e.getMethodName().equals("handleCreateService")) {
+                break;
+            }
+        }
 
-    super.onCreate();
+	    System.out.println("RubotoService.onCreate()");
+        args = new Object[0];
 
-    if (JRubyAdapter.setUpJRuby(this)) {
-        // TODO(uwe):  Only needed for non-class-based definitions
-        // Can be removed if we stop supporting non-class-based definitions
-    	JRubyAdapter.defineGlobalVariable("$context", this);
-    	JRubyAdapter.defineGlobalVariable("$service", this);
-    	// TODO end
+        super.onCreate();
 
-        try {
-            if (scriptName != null) {
-                String rubyClassName = Script.toCamelCase(scriptName);
-                System.out.println("Looking for Ruby class: " + rubyClassName);
-                Object rubyClass = JRubyAdapter.get(rubyClassName);
-                if (rubyClass == null) {
-                    System.out.println("Loading script: " + scriptName);
-                    JRubyAdapter.exec(new Script(scriptName).getContents());
-                    rubyClass = JRubyAdapter.get(rubyClassName);
-                }
-                if (rubyClass != null) {
-                    System.out.println("Instanciating Ruby class: " + rubyClassName);
-                    rubyInstance = JRubyAdapter.callMethod(rubyClass, "new", this, Object.class);
-                    JRubyAdapter.callMethod(rubyInstance, "on_create");
+        if (JRubyAdapter.setUpJRuby(this)) {
+            rubyInstance = this;
+
+            // TODO(uwe):  Only needed for non-class-based definitions
+            // Can be removed if we stop supporting non-class-based definitions
+    	    JRubyAdapter.defineGlobalVariable("$context", this);
+    	    JRubyAdapter.defineGlobalVariable("$service", this);
+    	    // TODO end
+
+            try {
+                if (scriptName != null) {
+                    String rubyClassName = Script.toCamelCase(scriptName);
+                    System.out.println("Looking for Ruby class: " + rubyClassName);
+                    Object rubyClass = null;
+                    String script = new Script(scriptName).getContents();
+                    if (script.matches("(?s).*class " + rubyClassName + ".*")) {
+                        if (!rubyClassName.equals(getClass().getSimpleName())) {
+                            System.out.println("Script defines methods on meta class");
+                            // FIXME(uwe): Simplify when we stop support for RubotoCore 0.4.7
+                            if (JRubyAdapter.isJRubyPreOneSeven() || JRubyAdapter.isRubyOneEight()) {
+                                JRubyAdapter.put("$java_instance", this);
+                                JRubyAdapter.put(rubyClassName, JRubyAdapter.runScriptlet("class << $java_instance; self; end"));
+                            } else if (JRubyAdapter.isJRubyOneSeven() && JRubyAdapter.isRubyOneNine()) {
+                                JRubyAdapter.put(rubyClassName, JRubyAdapter.runRubyMethod(this, "singleton_class"));
+                            } else {
+                                throw new RuntimeException("Unknown JRuby/Ruby version: " + JRubyAdapter.get("JRUBY_VERSION") + "/" + JRubyAdapter.get("RUBY_VERSION"));
+                            }
+                        }
+                    } else {
+                        rubyClass = JRubyAdapter.get(rubyClassName);
+                    }
+                    if (rubyClass == null) {
+                        System.out.println("Loading script: " + scriptName);
+                        if (script.matches("(?s).*class " + rubyClassName + ".*")) {
+                            System.out.println("Script contains class definition");
+                            if (rubyClassName.equals(getClass().getSimpleName())) {
+                                System.out.println("Script has separate Java class");
+                                JRubyAdapter.put(rubyClassName, JRubyAdapter.runScriptlet("Java::" + getClass().getName()));
+                            }
+                            // System.out.println("Set class: " + JRubyAdapter.get(rubyClassName));
+                        }
+                        JRubyAdapter.setScriptFilename(scriptName);
+                        JRubyAdapter.runScriptlet(script);
+                        rubyClass = JRubyAdapter.get(rubyClassName);
+                    }
+                    if (rubyClass != null) {
+                        System.out.println("Call on_create on: " + this);
+                        // FIXME(uwe): Simplify when we stop support for RubotoCore 0.4.7
+                        if (JRubyAdapter.isJRubyPreOneSeven()) {
+                            JRubyAdapter.put("$ruby_instance", this);
+                            JRubyAdapter.runScriptlet("$ruby_instance.on_create");
+                        } else if (JRubyAdapter.isJRubyOneSeven()) {
+                            JRubyAdapter.runRubyMethod(this, "on_create");
+                        } else {
+                            throw new RuntimeException("Unknown JRuby version: " + JRubyAdapter.get("JRUBY_VERSION"));
+                        }
+                    }
+                } else {
+                    // FIXME(uwe): Simplify when we stop support for RubotoCore 0.4.7
+                    if (JRubyAdapter.isJRubyPreOneSeven()) {
+            	        JRubyAdapter.runScriptlet("$service.initialize_ruboto");
+            	        JRubyAdapter.runScriptlet("$service.on_create");
+                    } else if (JRubyAdapter.isJRubyOneSeven()) {
+            	        JRubyAdapter.runRubyMethod(this, "initialize_ruboto");
+                        JRubyAdapter.runRubyMethod(this, "on_create", args[0]);
+                    } else {
+                        throw new RuntimeException("Unknown JRuby version: " + JRubyAdapter.get("JRUBY_VERSION"));
+            	    }
                 }
-            } else {
-            	JRubyAdapter.execute("$service.initialize_ruboto");
-            	JRubyAdapter.execute("$service.on_create");
+            } catch(IOException e) {
+                e.printStackTrace();
             }
-        } catch(IOException e) {
-            e.printStackTrace();
+        } else {
+            // FIXME(uwe):  What to do if the Ruboto Core platform cannot be found?
         }
-    } else {
-      // FIXME(uwe):  What to do if the Ruboto Core plarform cannot be found?
     }
-  }
 
   /****************************************************************************************
    * 
@@ -74,5 +128,3 @@ THE_CONSTANTS
 THE_METHODS
 
 }
-
-

data/assets/src/org/ruboto/EntryPointActivity.java

@@ -158,11 +158,12 @@ public class EntryPointActivity extends org.ruboto.RubotoActivity {
 
     private void showProgress() {
         if (loadingDialog == null) {
-            Log.i("Showing progress");
             if (splash > 0) {
+                Log.i("Showing splash");
                 requestWindowFeature(android.view.Window.FEATURE_NO_TITLE);
                 setContentView(splash);
             } else {
+                Log.i("Showing progress");
                 loadingDialog = ProgressDialog.show(this, null, "Starting...", true, true);
                 loadingDialog.setCanceledOnTouchOutside(false);
                 loadingDialog.setOnCancelListener(new OnCancelListener() {

data/assets/src/org/ruboto/JRubyAdapter.java

@@ -19,97 +19,73 @@ public class JRubyAdapter {
     private static boolean isDebugBuild = false;
     private static PrintStream output = null;
     private static boolean initialized = false;
-    private static String localContextScope = "SINGLETON";
+    private static String localContextScope = "SINGLETON"; // FIXME(uwe):  Why not CONCURRENT ?  Help needed!
     private static String localVariableBehavior = "TRANSIENT";
     private static String RUBOTO_CORE_VERSION_NAME;
 
-	public static void callMethod(Object receiver, String methodName, Object[] args) {
-        try {
-            Method callMethodMethod = ruby.getClass().getMethod("callMethod", Object.class, String.class, Object[].class);
-            callMethodMethod.invoke(ruby, receiver, methodName, args);
-        } catch (NoSuchMethodException nsme) {
-            throw new RuntimeException(nsme);
-        } catch (IllegalAccessException iae) {
-            throw new RuntimeException(iae);
-        } catch (java.lang.reflect.InvocationTargetException ite) {
-            printStackTrace(ite);
-            if (isDebugBuild) {
-                throw new RuntimeException(ite);
-            }
-        }
+    /**
+     * @deprecated  As of Ruboto 0.7.1, replaced by {@link #runRubyMethod(Object receiver, String methodName, Object... args)}
+     */
+    @Deprecated public static void callMethod(Object receiver, String methodName, Object[] args) {
+        runRubyMethod(receiver, methodName, args);
     }
 
-	public static void callMethod(Object object, String methodName, Object arg) {
-		callMethod(object, methodName, new Object[] { arg });
-	}
+    /**
+     * @deprecated  As of Ruboto 0.7.1, replaced by {@link #runRubyMethod(Object receiver, String methodName, Object... args)}
+     */
+    @Deprecated public static void callMethod(Object object, String methodName, Object arg) {
+        runRubyMethod(object, methodName, arg);
+    }
 
-	public static void callMethod(Object object, String methodName) {
-		callMethod(object, methodName, new Object[] {});
-	}
+    /**
+     * @deprecated  As of Ruboto 0.7.1, replaced by {@link #runRubyMethod(Object receiver, String methodName, Object... args)}
+     */
+    @Deprecated public static void callMethod(Object object, String methodName) {
+        runRubyMethod(object, methodName, new Object[] {});
+    }
 
-	@SuppressWarnings("unchecked")
-	public static <T> T callMethod(Object receiver, String methodName, Object[] args, Class<T> returnType) {
-        try {
-            Method callMethodMethod = ruby.getClass().getMethod("callMethod", Object.class, String.class, Object[].class, Class.class);
-            return (T) callMethodMethod.invoke(ruby, receiver, methodName, args, returnType);
-        } catch (NoSuchMethodException nsme) {
-            throw new RuntimeException(nsme);
-        } catch (IllegalAccessException iae) {
-            throw new RuntimeException(iae);
-        } catch (java.lang.reflect.InvocationTargetException ite) {
-            printStackTrace(ite);
-        }
-        return null;
-	}
-
-	@SuppressWarnings("unchecked")
-	public static <T> T callMethod(Object receiver, String methodName, Object arg, Class<T> returnType) {
-    try {
-      Method callMethodMethod = ruby.getClass().getMethod("callMethod", Object.class, String.class, Object.class, Class.class);
-      return (T) callMethodMethod.invoke(ruby, receiver, methodName, arg, returnType);
-    } catch (NoSuchMethodException nsme) {
-      throw new RuntimeException(nsme);
-    } catch (IllegalAccessException iae) {
-      throw new RuntimeException(iae);
-    } catch (java.lang.reflect.InvocationTargetException ite) {
-      printStackTrace(ite);
-    }
-    return null;
-	}
-
-	@SuppressWarnings("unchecked")
-	public static <T> T callMethod(Object receiver, String methodName, Class<T> returnType) {
-    try {
-      Method callMethodMethod = ruby.getClass().getMethod("callMethod", Object.class, String.class, Class.class);
-      return (T) callMethodMethod.invoke(ruby, receiver, methodName, returnType);
-    } catch (NoSuchMethodException nsme) {
-      throw new RuntimeException(nsme);
-    } catch (IllegalAccessException iae) {
-      throw new RuntimeException(iae);
-    } catch (java.lang.reflect.InvocationTargetException ite) {
-      printStackTrace(ite);
-    }
-    return null;
-	}
+    /**
+     * @deprecated  As of Ruboto 0.7.1, replaced by {@link #runRubyMethod(Class<T> returnType, Object receiver, String methodName, Object... args)}
+     */
+    @SuppressWarnings("unchecked")
+    @Deprecated public static <T> T callMethod(Object receiver, String methodName, Object[] args, Class<T> returnType) {
+        return runRubyMethod(returnType, receiver, methodName, args);
+    }
+
+    /**
+     * @deprecated  As of Ruboto 0.7.1, replaced by {@link #runRubyMethod(Class<T> returnType, Object receiver, String methodName, Object... args)}
+     */
+    @SuppressWarnings("unchecked")
+    @Deprecated public static <T> T callMethod(Object receiver, String methodName, Object arg, Class<T> returnType) {
+        return runRubyMethod(returnType, receiver, methodName, arg);
+    }
+
+    /**
+     * @deprecated  As of Ruboto 0.7.1, replaced by {@link #runRubyMethod(Class<T> returnType, Object receiver, String methodName, Object... args)}
+     */
+    @SuppressWarnings("unchecked")
+    @Deprecated public static <T> T callMethod(Object receiver, String methodName, Class<T> returnType) {
+        return runRubyMethod(returnType, receiver, methodName);
+    }
 
     /**
      * @deprecated  As of Ruboto 0.7.0, replaced by {@link #put(String name, Object object)}
      */
     @Deprecated public static void defineGlobalConstant(String name, Object object) {
-    	put(name, object);
+        put(name, object);
     }
 
     /**
      * @deprecated  As of Ruboto 0.7.0, replaced by {@link #put(String name, Object object)}
      */
     @Deprecated public static void defineGlobalVariable(String name, Object object) {
-    	put(name, object);
+        put(name, object);
     }
 
     /**
      * @deprecated  As of Ruboto 0.7.0, replaced by {@link #runScriptlet(String code)}
      */
-	@Deprecated public static Object exec(String code) {
+    @Deprecated public static Object exec(String code) {
         try {
             Method runScriptletMethod = ruby.getClass().getMethod("runScriptlet", String.class);
             return runScriptletMethod.invoke(ruby, code);
@@ -124,16 +100,13 @@ public class JRubyAdapter {
                 return null;
             }
         }
-	}
+    }
 
     /**
      * @deprecated  As of Ruboto 0.7.0, replaced by {@link #runScriptlet(String code)}
      */
     @Deprecated public static String execute(String code) {
-        Object result = exec(code);
-        return result != null ? result.toString() : "nil";
-        // TODO: Why is callMethod returning "main"?
-        // return result != null ? callMethod(result, "inspect", String.class) : "null";
+        return runRubyMethod(String.class, exec(code), "inspect");
     }
 
     public static Object get(String name) {
@@ -149,21 +122,71 @@ public class JRubyAdapter {
         }
     }
 
-	public static String getPlatformVersionName() {
-		return RUBOTO_CORE_VERSION_NAME;
-	}
+    public static String getPlatformVersionName() {
+        return RUBOTO_CORE_VERSION_NAME;
+    }
 
     public static String getScriptFilename() {
         return callScriptingContainerMethod(String.class, "getScriptFilename");
     }
 
-	public static boolean isDebugBuild() {
-		return isDebugBuild;
-	}
+    public static Object runRubyMethod(Object receiver, String methodName, Object... args) {
+        try {
+            // FIXME(uwe):  Simplify when we stop supporting JRuby < 1.7.0
+            if (isJRubyPreOneSeven()) {
+                if (args.length == 0) {
+                    Method m = ruby.getClass().getMethod("callMethod", Object.class, String.class, Class.class);
+                    // System.out.println("Calling callMethod(" + receiver + ", " + methodName + ", " + Object.class + ")");
+                    return m.invoke(ruby, receiver, methodName, Object.class);
+                } else {
+                    Method m = ruby.getClass().getMethod("callMethod", Object.class, String.class, Object[].class, Class.class);
+                    // System.out.println("Calling callMethod(" + receiver + ", " + methodName + ", " + args + ", " + Object.class + ")");
+                    return m.invoke(ruby, receiver, methodName, args, Object.class);
+                }
+            } else {
+                Method m = ruby.getClass().getMethod("runRubyMethod", Class.class, Object.class, String.class, Object[].class);
+                return m.invoke(ruby, Object.class, receiver, methodName, args);
+            }
+        } catch (NoSuchMethodException nsme) {
+            throw new RuntimeException(nsme);
+        } catch (IllegalAccessException iae) {
+            throw new RuntimeException(iae);
+        } catch (java.lang.reflect.InvocationTargetException ite) {
+            printStackTrace(ite);
+            if (isDebugBuild) {
+                throw new RuntimeException(ite);
+            }
+        }
+        return null;
+    }
 
-	public static synchronized boolean isInitialized() {
-		return initialized;
-	}
+    @SuppressWarnings("unchecked")
+    public static <T> T runRubyMethod(Class<T> returnType, Object receiver, String methodName, Object... args) {
+        try {
+            if (isJRubyPreOneSeven()) {
+                Method m = ruby.getClass().getMethod("callMethod", Object.class, String.class, Object[].class, Class.class);
+                return (T) m.invoke(ruby, receiver, methodName, args, returnType);
+            } else {
+                Method m = ruby.getClass().getMethod("runRubyMethod", Class.class, Object.class, String.class, Object[].class);
+                return (T) m.invoke(ruby, returnType, receiver, methodName, args);
+            }
+        } catch (NoSuchMethodException nsme) {
+            throw new RuntimeException(nsme);
+        } catch (IllegalAccessException iae) {
+            throw new RuntimeException(iae);
+        } catch (java.lang.reflect.InvocationTargetException ite) {
+            printStackTrace(ite);
+        }
+        return null;
+    }
+
+    public static boolean isDebugBuild() {
+        return isDebugBuild;
+    }
+
+    public static boolean isInitialized() {
+        return initialized;
+    }
 
     public static void put(String name, Object object) {
         try {
@@ -178,7 +201,7 @@ public class JRubyAdapter {
         }
     }
 
-	public static Object runScriptlet(String code) {
+    public static Object runScriptlet(String code) {
         try {
             Method runScriptletMethod = ruby.getClass().getMethod("runScriptlet", String.class);
             return runScriptletMethod.invoke(ruby, code);
@@ -193,7 +216,7 @@ public class JRubyAdapter {
                 return null;
             }
         }
-	}
+    }
 
     public static synchronized boolean setUpJRuby(Context appContext) {
         return setUpJRuby(appContext, output == null ? System.out : output);
@@ -204,7 +227,7 @@ public class JRubyAdapter {
         if (!initialized) {
             // BEGIN Ruboto HeapAlloc
             @SuppressWarnings("unused")
-			byte[] arrayForHeapAllocation = new byte[13 * 1024 * 1024];
+            byte[] arrayForHeapAllocation = new byte[13 * 1024 * 1024];
             arrayForHeapAllocation = null;
             // END Ruboto HeapAlloc
             setDebugBuild(appContext);
@@ -236,9 +259,9 @@ public class JRubyAdapter {
             } catch (ClassNotFoundException e1) {
                 String packageName = "org.ruboto.core";
                 try {
-                	PackageInfo pkgInfo = appContext.getPackageManager().getPackageInfo(packageName, 0);
+                    PackageInfo pkgInfo = appContext.getPackageManager().getPackageInfo(packageName, 0);
                     apkName = pkgInfo.applicationInfo.sourceDir;
-                	RUBOTO_CORE_VERSION_NAME = pkgInfo.versionName;
+                    RUBOTO_CORE_VERSION_NAME = pkgInfo.versionName;
                 } catch (PackageManager.NameNotFoundException e2) {
                     out.println("JRuby not found in local APK:");
                     e1.printStackTrace(out);
@@ -272,16 +295,16 @@ public class JRubyAdapter {
                 callScriptingContainerMethod(Void.class, "setCompileMode", Enum.valueOf(compileModeClass, "OFF"));
 
                 // Class traceTypeClass = Class.forName("org.jruby.runtime.backtrace.TraceType", true, classLoader);
-        	    // Method traceTypeForMethod = traceTypeClass.getMethod("traceTypeFor", String.class);
-        	    // Object traceTypeRaw = traceTypeForMethod.invoke(null, "raw");
+                // Method traceTypeForMethod = traceTypeClass.getMethod("traceTypeFor", String.class);
+                // Object traceTypeRaw = traceTypeForMethod.invoke(null, "raw");
                 // callScriptingContainerMethod(Void.class, "setTraceType", traceTypeRaw);
 
                 // FIXME(uwe): Write tutorial on profiling.
                 // container.getProvider().getRubyInstanceConfig().setProfilingMode(mode);
 
                 // callScriptingContainerMethod(Void.class, "setClassLoader", classLoader);
-        	    Method setClassLoaderMethod = ruby.getClass().getMethod("setClassLoader", ClassLoader.class);
-        	    setClassLoaderMethod.invoke(ruby, classLoader);
+                Method setClassLoaderMethod = ruby.getClass().getMethod("setClassLoader", ClassLoader.class);
+                setClassLoaderMethod.invoke(ruby, classLoader);
 
                 Thread.currentThread().setContextClassLoader(classLoader);
 
@@ -326,9 +349,9 @@ public class JRubyAdapter {
         callScriptingContainerMethod(Void.class, "setScriptFilename", name);
     }
 
-	public static boolean usesPlatformApk() {
-		return RUBOTO_CORE_VERSION_NAME != null;
-	}
+    public static boolean usesPlatformApk() {
+        return RUBOTO_CORE_VERSION_NAME != null;
+    }
 
     // Private methods
 
@@ -353,8 +376,8 @@ public class JRubyAdapter {
             argClasses[i] = args[i].getClass();
         }
         try {
-        	Method method = ruby.getClass().getMethod(methodName, argClasses);
-        	T result = (T) method.invoke(ruby, args);
+            Method method = ruby.getClass().getMethod(methodName, argClasses);
+            T result = (T) method.invoke(ruby, args);
             return result;
         } catch (RuntimeException re) {
             re.printStackTrace();
@@ -375,38 +398,58 @@ public class JRubyAdapter {
         ruby = null;
     }
 
-	static void printStackTrace(Throwable t) {
+    // FIXME(uwe):  Remove when we stop supporting JRuby < 1.7.0
+    @Deprecated public static boolean isJRubyPreOneSeven() {
+        return ((String)get("JRUBY_VERSION")).equals("1.7.0.dev") || ((String)get("JRUBY_VERSION")).startsWith("1.6.");
+    }
+
+    // FIXME(uwe):  Remove when we stop supporting JRuby < 1.7.0
+    @Deprecated public static boolean isJRubyOneSeven() {
+        return !isJRubyPreOneSeven() && ((String)get("JRUBY_VERSION")).startsWith("1.7.");
+    }
+
+    // FIXME(uwe):  Remove when we stop supporting Ruby 1.8
+    @Deprecated public static boolean isRubyOneEight() {
+        return ((String)get("RUBY_VERSION")).startsWith("1.8.");
+    }
+
+    // FIXME(uwe):  Remove when we stop supporting Ruby 1.8
+    @Deprecated public static boolean isRubyOneNine() {
+        return ((String)get("RUBY_VERSION")).startsWith("1.9.");
+    }
+
+    static void printStackTrace(Throwable t) {
         // TODO(uwe):  Simplify this when Issue #144 is resolved
         try {
             t.printStackTrace(output);
-    	} catch (NullPointerException npe) {
-    	    // TODO(uwe): printStackTrace should not fail
+        } catch (NullPointerException npe) {
+            // TODO(uwe): printStackTrace should not fail
             for (java.lang.StackTraceElement ste : t.getStackTrace()) {
                 output.append(ste.toString() + "\n");
             }
-    	}
-	}
+        }
+    }
 
     private static String scriptsDirName(Context context) {
         File storageDir = null;
-        if (JRubyAdapter.isDebugBuild()) {
+        if (isDebugBuild()) {
 
             // FIXME(uwe): Simplify this as soon as we drop support for android-7
             if (android.os.Build.VERSION.SDK_INT >= 8) {
                 try {
-					Method method = context.getClass().getMethod("getExternalFilesDir", String.class);
-					storageDir = (File) method.invoke(context, (Object) null);
-				} catch (SecurityException e) {
-					JRubyAdapter.printStackTrace(e);
-				} catch (NoSuchMethodException e) {
-					JRubyAdapter.printStackTrace(e);
-				} catch (IllegalArgumentException e) {
-					JRubyAdapter.printStackTrace(e);
-				} catch (IllegalAccessException e) {
-					JRubyAdapter.printStackTrace(e);
-				} catch (InvocationTargetException e) {
-					JRubyAdapter.printStackTrace(e);
-				}
+                    Method method = context.getClass().getMethod("getExternalFilesDir", String.class);
+                    storageDir = (File) method.invoke(context, (Object) null);
+                } catch (SecurityException e) {
+                    printStackTrace(e);
+                } catch (NoSuchMethodException e) {
+                    printStackTrace(e);
+                } catch (IllegalArgumentException e) {
+                    printStackTrace(e);
+                } catch (IllegalAccessException e) {
+                    printStackTrace(e);
+                } catch (InvocationTargetException e) {
+                    printStackTrace(e);
+                }
             } else {
                 storageDir = new File(Environment.getExternalStorageDirectory(), "Android/data/" + context.getPackageName() + "/files");
                 Log.e("Calculated path to sdcard the old way: " + storageDir);