ruboto 0.8.0 → 0.8.1

data/assets/src/RubotoService.java

@@ -1,23 +1,16 @@
 package THE_PACKAGE;
 
 import org.ruboto.Script;
+import org.ruboto.ScriptLoader;
 import java.io.IOException;
 
 public class THE_RUBOTO_CLASS THE_ACTION THE_ANDROID_CLASS {
 THE_CONSTANTS
 
-    private String rubyClassName;
-    private String scriptName;
-    private Object rubyInstance;
-    private Object[] callbackProcs = new Object[CONSTANTS_COUNT];
-    public Object[] args;
+    private final ScriptInfo scriptInfo = new ScriptInfo(CONSTANTS_COUNT);
 
-    public void setCallbackProc(int id, Object obj) {
-      callbackProcs[id] = obj;
-    }
-	
-    public void setScriptName(String name){
-        scriptName = name;
+    public ScriptInfo getScriptInfo() {
+        return scriptInfo;
     }
 
     /****************************************************************************************
@@ -25,96 +18,27 @@ THE_CONSTANTS
      *  Service Lifecycle: onCreate
      */
 
+    // FIXME(uwe):  Only used for block based primary activities.  Remove if we remove support for such.
+	public void onCreateSuper() {
+	    super.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;
-            }
+        if (ScriptLoader.isCalledFromJRuby()) {
+            super.onCreate();
+            return;
         }
-
 	    System.out.println("RubotoService.onCreate()");
-        args = new Object[0];
-
-        super.onCreate();
 
         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"));
-            	    }
-                }
-            } catch(IOException e) {
-                e.printStackTrace();
-            }
+            ScriptLoader.loadScript(this);
         } else {
             // FIXME(uwe):  What to do if the Ruboto Core platform cannot be found?
         }

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

@@ -150,7 +150,7 @@ public class EntryPointActivity extends org.ruboto.RubotoActivity {
         if(appStarted) return;
         appStarted = true;
         Log.i("Starting activity");
-        loadScript();
+        ScriptLoader.loadScript(this, args[0]);
         onStart();
         super.onResume();
         hideProgress();

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

@@ -49,7 +49,7 @@ public class JRubyAdapter {
      */
     @SuppressWarnings("unchecked")
     @Deprecated public static <T> T callMethod(Object receiver, String methodName, Object[] args, Class<T> returnType) {
-        return runRubyMethod(returnType, receiver, methodName, args);
+        return (T) runRubyMethod(returnType, receiver, methodName, args);
     }
 
     /**
@@ -57,7 +57,7 @@ public class JRubyAdapter {
      */
     @SuppressWarnings("unchecked")
     @Deprecated public static <T> T callMethod(Object receiver, String methodName, Object arg, Class<T> returnType) {
-        return runRubyMethod(returnType, receiver, methodName, arg);
+        return (T) runRubyMethod(returnType, receiver, methodName, arg);
     }
 
     /**
@@ -65,7 +65,7 @@ public class JRubyAdapter {
      */
     @SuppressWarnings("unchecked")
     @Deprecated public static <T> T callMethod(Object receiver, String methodName, Class<T> returnType) {
-        return runRubyMethod(returnType, receiver, methodName);
+        return (T) runRubyMethod(returnType, receiver, methodName);
     }
 
     /**
@@ -106,7 +106,7 @@ public class JRubyAdapter {
      * @deprecated  As of Ruboto 0.7.0, replaced by {@link #runScriptlet(String code)}
      */
     @Deprecated public static String execute(String code) {
-        return runRubyMethod(String.class, exec(code), "inspect");
+        return (String) runRubyMethod(String.class, exec(code), "inspect");
     }
 
     public static Object get(String name) {
@@ -127,7 +127,7 @@ public class JRubyAdapter {
     }
 
     public static String getScriptFilename() {
-        return callScriptingContainerMethod(String.class, "getScriptFilename");
+        return (String) callScriptingContainerMethod(String.class, "getScriptFilename");
     }
 
     public static Object runRubyMethod(Object receiver, String methodName, Object... args) {
@@ -163,9 +163,15 @@ public class JRubyAdapter {
     @SuppressWarnings("unchecked")
     public static <T> T runRubyMethod(Class<T> returnType, Object receiver, String methodName, Object... args) {
         try {
+            // FIXME(uwe):  Simplify when we stop supporting JRuby < 1.7.0
             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);
+                if (args.length == 0) {
+                  Method m = ruby.getClass().getMethod("callMethod", Object.class, String.class, Class.class);
+                  return (T) m.invoke(ruby, receiver, methodName, returnType);
+                } else {
+                  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);
@@ -218,7 +224,7 @@ public class JRubyAdapter {
         }
     }
 
-    public static synchronized boolean setUpJRuby(Context appContext) {
+    public static boolean setUpJRuby(Context appContext) {
         return setUpJRuby(appContext, output == null ? System.out : output);
     }
 
@@ -232,19 +238,21 @@ public class JRubyAdapter {
             // END Ruboto HeapAlloc
             setDebugBuild(appContext);
             Log.d("Setting up JRuby runtime (" + (isDebugBuild ? "DEBUG" : "RELEASE") + ")");
+            System.setProperty("jruby.compile.mode", "OFF"); // OFF OFFIR
             System.setProperty("jruby.bytecode.version", "1.6");
             System.setProperty("jruby.interfaces.useProxy", "true");
             System.setProperty("jruby.management.enabled", "false");
             System.setProperty("jruby.objectspace.enabled", "false");
             System.setProperty("jruby.thread.pooling", "true");
             System.setProperty("jruby.native.enabled", "false");
-            // System.setProperty("jruby.compat.version", "RUBY1_8"); // RUBY1_9 is the default
+            // System.setProperty("jruby.compat.version", "RUBY1_8"); // RUBY1_9 is the default in JRuby 1.7
+            System.setProperty("jruby.ir.passes", "LocalOptimizationPass,DeadCodeElimination");
+            System.setProperty("jruby.backtrace.style", "normal"); // normal raw full mri
 
-            // Uncomment these to debug Ruby source loading
+            // Uncomment these to debug/profile Ruby source loading
             // System.setProperty("jruby.debug.loadService", "true");
             // System.setProperty("jruby.debug.loadService.timing", "true");
 
-
             ClassLoader classLoader;
             Class<?> scriptingContainerClass;
             String apkName = null;
@@ -263,10 +271,10 @@ public class JRubyAdapter {
                     apkName = pkgInfo.applicationInfo.sourceDir;
                     RUBOTO_CORE_VERSION_NAME = pkgInfo.versionName;
                 } catch (PackageManager.NameNotFoundException e2) {
-                    out.println("JRuby not found in local APK:");
-                    e1.printStackTrace(out);
-                    out.println("JRuby not found in platform APK:");
-                    e2.printStackTrace(out);
+                    System.out.println("JRuby not found in local APK:");
+                    e1.printStackTrace();
+                    System.out.println("JRuby not found in platform APK:");
+                    e2.printStackTrace();
                     return false;
                 }
 
@@ -291,14 +299,6 @@ public class JRubyAdapter {
                          .newInstance(Enum.valueOf(scopeClass, localContextScope), 
                                       Enum.valueOf(behaviorClass, localVariableBehavior));
 
-                Class compileModeClass = Class.forName("org.jruby.RubyInstanceConfig$CompileMode", true, classLoader);
-                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");
-                // callScriptingContainerMethod(Void.class, "setTraceType", traceTypeRaw);
-
                 // FIXME(uwe): Write tutorial on profiling.
                 // container.getProvider().getRubyInstanceConfig().setProfilingMode(mode);
 

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

@@ -0,0 +1,8 @@
+package org.ruboto;
+
+public interface RubotoComponent {
+    ScriptInfo getScriptInfo();
+
+    // FIXME(uwe):  Only used for block based primary activities.  Remove if we remove support for such.
+    void onCreateSuper();
+}

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

@@ -31,6 +31,7 @@ public class Script {
     public static String toCamelCase(String s) {
         String[] parts = s.replace(".rb", "").split("_");
         for (int i = 0 ; i < parts.length ; i++) {
+            if (parts[i].length() == 0) continue;
             parts[i] = parts[i].substring(0,1).toUpperCase() + parts[i].substring(1);
         }
         return java.util.Arrays.toString(parts).replace(", ", "").replaceAll("[\\[\\]]", "");
@@ -44,7 +45,7 @@ public class Script {
                 "(?<=[A-Za-z])(?=[^A-Za-z])"
             ),
             "_"
-        ).toLowerCase();
+        ).replace("__", "_").toLowerCase();
     }
 
     // Private static methods
@@ -109,7 +110,7 @@ public class Script {
     boolean exists() {
         for (String dir : scriptsDir) {
             System.out.println("Checking file: " + dir + "/" + name);
-            if (new File(scriptsDir + "/" + name).exists()) {
+            if (new File(dir + "/" + name).exists()) {
                 return true;
             }
         }
@@ -132,9 +133,13 @@ public class Script {
         InputStream is = null;
         BufferedReader buffer = null;
         try {
-            if (new File(scriptsDir + "/" + name).exists()) {
-                is = new java.io.FileInputStream(scriptsDir + "/" + name);
-            } else {
+            for (String dir : scriptsDir) {
+                System.out.println("Checking file: " + dir + "/" + name);
+                if (new File(dir + "/" + name).exists()) {
+                    is = new java.io.FileInputStream(dir + "/" + name);
+                }
+            }
+            if (is == null) {
                 is = getClass().getClassLoader().getResourceAsStream(name);
             }
             buffer = new BufferedReader(new java.io.InputStreamReader(is), 8192);

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

@@ -0,0 +1,53 @@
+package org.ruboto;
+
+public class ScriptInfo {
+    private String rubyClassName;
+    private String scriptName;
+    private Object rubyInstance;
+
+    // FIXME(uwe):  Only used for legacy handle_xxx callbacks.  Remove when we stop supporting these.
+    private final Object[] callbackProcs;
+
+    public ScriptInfo(int callbackSize) {
+        callbackProcs = new Object[callbackSize];
+    }
+
+    public Object[] getCallbackProcs() {
+        return callbackProcs;
+    }
+
+    public void setCallbackProc(int id, Object obj) {
+        callbackProcs[id] = obj;
+    }
+
+    public String getRubyClassName() {
+        if (rubyClassName == null && scriptName != null) {
+            return Script.toCamelCase(scriptName);
+         }
+        return rubyClassName;
+    }
+
+    public void setRubyClassName(String name) {
+        rubyClassName = name;
+    }
+
+    public Object getRubyInstance() {
+        return rubyInstance;
+    }
+
+    public void setRubyInstance(Object instance) {
+        rubyInstance = instance;
+    }
+
+    public String getScriptName() {
+        if (scriptName == null && rubyClassName != null) {
+            return Script.toSnakeCase(rubyClassName) + ".rb";
+        }
+        return scriptName;
+    }
+
+    public void setScriptName(String name) {
+        scriptName = name;
+    }
+
+}

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

@@ -0,0 +1,143 @@
+package org.ruboto;
+
+import java.io.IOException;
+
+import android.app.ProgressDialog;
+import android.content.Context;
+
+public class ScriptLoader {
+   /**
+    Return true if we are called from JRuby.
+    */
+    public static boolean isCalledFromJRuby() {
+        StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
+        int maxLookBack = Math.min(10, stackTraceElements.length);
+        for(int i = 0; i < maxLookBack ; i++){
+            if (stackTraceElements[i].getClassName().startsWith("org.jruby.javasupport.JavaMethod")) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static void loadScript(final RubotoComponent component, Object... args) {
+        try {
+            if (component.getScriptInfo().getScriptName() != null) {
+                System.out.println("Looking for Ruby class: " + component.getScriptInfo().getRubyClassName());
+                Object rubyClass = JRubyAdapter.get(component.getScriptInfo().getRubyClassName());
+                System.out.println("Found: " + rubyClass);
+                Script rubyScript = new Script(component.getScriptInfo().getScriptName());
+                Object rubyInstance;
+                if (rubyScript.exists()) {
+                    rubyInstance = component;
+                    final String script = rubyScript.getContents();
+                    if (script.matches("(?s).*class " + component.getScriptInfo().getRubyClassName() + ".*")) {
+                        if (!component.getScriptInfo().getRubyClassName().equals(component.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", component);
+                                JRubyAdapter.put(component.getScriptInfo().getRubyClassName(), JRubyAdapter.runScriptlet("class << $java_instance; self; end"));
+                            } else if (JRubyAdapter.isJRubyOneSeven() && JRubyAdapter.isRubyOneNine()) {
+                                JRubyAdapter.runScriptlet("Java::" + component.getClass().getName() + ".__persistent__ = true");
+                                JRubyAdapter.put(component.getScriptInfo().getRubyClassName(), JRubyAdapter.runRubyMethod(component, "singleton_class"));
+                            } else {
+                                throw new RuntimeException("Unknown JRuby/Ruby version: " + JRubyAdapter.get("JRUBY_VERSION") + "/" + JRubyAdapter.get("RUBY_VERSION"));
+                            }
+                        }
+                    }
+                    if (rubyClass == null) {
+                        System.out.println("Loading script: " + component.getScriptInfo().getScriptName());
+                        if (script.matches("(?s).*class " + component.getScriptInfo().getRubyClassName() + ".*")) {
+                            System.out.println("Script contains class definition");
+                            if (component.getScriptInfo().getRubyClassName().equals(component.getClass().getSimpleName())) {
+                                System.out.println("Script has separate Java class");
+                                // FIXME(uwe): Simplify when we stop support for JRuby < 1.7.0
+                                if (!JRubyAdapter.isJRubyPreOneSeven()) {
+                                    JRubyAdapter.runScriptlet("Java::" + component.getClass().getName() + ".__persistent__ = true");
+                                }
+                                JRubyAdapter.put(component.getScriptInfo().getRubyClassName(), JRubyAdapter.runScriptlet("Java::" + component.getClass().getName()));
+                            }
+                            System.out.println("Set class: " + JRubyAdapter.get(component.getScriptInfo().getRubyClassName()));
+                            Thread t = new Thread(new Runnable(){
+                                public void run() {
+                                    JRubyAdapter.setScriptFilename(component.getScriptInfo().getScriptName());
+                                    JRubyAdapter.runScriptlet(script);
+                                }
+                            });
+                            try {
+                                t.start();
+                                t.join();
+                            } catch(InterruptedException ie) {
+                                Thread.currentThread().interrupt();
+                                throw new RuntimeException("Interrupted loading script.", ie);
+                            }
+                            rubyClass = JRubyAdapter.get(component.getScriptInfo().getRubyClassName());
+                        } else {
+                            // FIXME(uwe): Only needed for initial block-based activity definition
+                            System.out.println("Script contains block based activity definition");
+                            if (!JRubyAdapter.isJRubyPreOneSeven()) {
+                                JRubyAdapter.runScriptlet("Java::" + component.getClass().getName() + ".__persistent__ = true");
+                            }
+                            JRubyAdapter.runScriptlet("$activity.instance_variable_set '@ruboto_java_class', '" + component.getScriptInfo().getRubyClassName() + "'");
+                            JRubyAdapter.runScriptlet("puts %Q{$activity: #$activity}");
+                            JRubyAdapter.setScriptFilename(component.getScriptInfo().getScriptName());
+                            JRubyAdapter.runScriptlet(script);
+                        }
+                    }
+                } else if (rubyClass != null) {
+                    // We have a predefined Ruby class without corresponding Ruby source file.
+                    System.out.println("Create separate Ruby instance for class: " + rubyClass);
+                    rubyInstance = JRubyAdapter.runRubyMethod(rubyClass, "new");
+                    JRubyAdapter.runRubyMethod(rubyInstance, "instance_variable_set", "@ruboto_java_instance", component);
+                } else {
+                    // Neither script file nor predefined class
+                    throw new RuntimeException("Either script or predefined class must be present.");
+                }
+                if (rubyClass != null) {
+                    if (component instanceof android.content.Context) {
+                        callOnCreate(rubyInstance, args);
+                    }
+                } else {
+                    // FIXME(uwe): Remove when we stop supporting block based main activities.
+                    component.onCreateSuper();
+                }
+                component.getScriptInfo().setRubyInstance(rubyInstance);
+            } else { // if (configBundle != null) {
+                // FIXME(uwe): Simplify when we stop support for RubotoCore 0.4.7
+                if (JRubyAdapter.isJRubyPreOneSeven()) {
+            	    JRubyAdapter.runScriptlet("$activity.initialize_ruboto");
+                } else if (JRubyAdapter.isJRubyOneSeven()) {
+            	    JRubyAdapter.runRubyMethod(component, "initialize_ruboto");
+                } else {
+                    throw new RuntimeException("Unknown JRuby version: " + JRubyAdapter.get("JRUBY_VERSION"));
+            	}
+                if (component instanceof android.content.Context) {
+                    callOnCreate(component, args);
+                }
+            }
+        } catch(IOException e){
+            e.printStackTrace();
+            if (component instanceof android.content.Context) {
+                ProgressDialog.show((android.content.Context) component, "Script failed", "Something bad happened", true, true);
+            }
+        }
+    }
+
+    private static final void callOnCreate(Object rubyInstance, Object[] args) {
+        System.out.println("Call on_create on: " + rubyInstance + ", " + JRubyAdapter.get("JRUBY_VERSION"));
+        // FIXME(uwe): Simplify when we stop support for RubotoCore 0.4.7
+        if (JRubyAdapter.isJRubyPreOneSeven()) {
+            if (args.length > 0) {
+                JRubyAdapter.put("$bundle", args[0]);
+            }
+            JRubyAdapter.put("$ruby_instance", rubyInstance);
+            JRubyAdapter.runScriptlet("$ruby_instance.on_create(" + (args.length > 0 ? "$bundle" : "") + ")");
+        } else if (JRubyAdapter.isJRubyOneSeven()) {
+            JRubyAdapter.runRubyMethod(rubyInstance, "on_create", (Object[]) args);
+        } else {
+            throw new RuntimeException("Unknown JRuby version: " + JRubyAdapter.get("JRUBY_VERSION"));
+        }
+    }
+
+}