ruboto 0.5.4 → 0.6.0

data/assets/src/RubotoActivity.java

@@ -17,7 +17,7 @@ public class THE_RUBOTO_CLASS THE_ACTION THE_ANDROID_CLASS {
     private String scriptName;
     private String remoteVariable = null;
     private Object[] args;
-    private Bundle configBundle;
+    private Bundle configBundle = null;
 
 THE_CONSTANTS
 
@@ -85,7 +85,7 @@ THE_CONSTANTS
             if (scriptName != null) {
     	        Script.setScriptFilename(getClass().getClassLoader().getResource(scriptName).getPath());
                 Script.execute(new Script(scriptName).getContents());
-            } else {
+            } else if (configBundle != null) {
                 // TODO: Why doesn't this work? 
                 // Script.callMethod(this, "initialize_ruboto");
                 Script.execute("$activity.initialize_ruboto");
@@ -99,6 +99,10 @@ THE_CONSTANTS
         }
     }
 
+    public boolean rubotoAttachable() {
+      return true;
+    }
+
   /****************************************************************************************
    * 
    *  Generated Methods

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

@@ -25,7 +25,7 @@ public class EntryPointActivity extends org.ruboto.RubotoActivity {
     private ProgressDialog loadingDialog;
     private boolean dialogCancelled = false;
     private BroadcastReceiver receiver;
-    private boolean appStarted = false;
+    protected boolean appStarted = false;
 
 	public void onCreate(Bundle bundle) {
         Log.d("RUBOTO", "onCreate: ");
@@ -154,7 +154,7 @@ public class EntryPointActivity extends org.ruboto.RubotoActivity {
         }
     }
 
-    private void fireRubotoActivity() {
+    protected void fireRubotoActivity() {
         if(appStarted) return;
         appStarted = true;
         Log.i("RUBOTO", "Starting activity");

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

@@ -33,6 +33,8 @@ public class Script {
 
     private String name = null;
     private static Object ruby;
+    private static boolean isDebugBuild = false;
+    private static PrintStream output = null;
     private static boolean initialized = false;
 
     private static String localContextScope = "SINGLETON";
@@ -40,6 +42,7 @@ public class Script {
 
     public static final String TAG = "RUBOTO"; // for logging
     private static String JRUBY_VERSION;
+    private static String RUBOTO_CORE_VERSION_NAME;
 
     /*************************************************************************************************
      * 
@@ -69,19 +72,29 @@ public class Script {
 		return initialized;
 	}
 
+	public static boolean usesPlatformApk() {
+		return RUBOTO_CORE_VERSION_NAME != null;
+	}
+	
+	public static String getPlatformVersionName() {
+		return RUBOTO_CORE_VERSION_NAME;
+	}
+	
     public static synchronized boolean setUpJRuby(Context appContext) {
-        return setUpJRuby(appContext, System.out);
+        return setUpJRuby(appContext, output == null ? System.out : output);
     }
 
     public static synchronized boolean setUpJRuby(Context appContext, PrintStream out) {
         if (!initialized) {
-            Log.d(TAG, "Setting up JRuby runtime");
-            System.setProperty("jruby.bytecode.version", "1.5");
+            setDebugBuild(appContext);
+            Log.d(TAG, "Setting up JRuby runtime (" + (isDebugBuild ? "DEBUG" : "RELEASE") + ")");
+            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
 
             // Uncomment these to debug Ruby source loading
             // System.setProperty("jruby.debug.loadService", "true");
@@ -102,9 +115,14 @@ public class Script {
             } catch (ClassNotFoundException e1) {
                 String packageName = "org.ruboto.core";
                 try {
-                    apkName = appContext.getPackageManager().getApplicationInfo(packageName, 0).sourceDir;
-                } catch (PackageManager.NameNotFoundException e) {
-                    System.out.println("JRuby not found");
+                	PackageInfo pkgInfo = appContext.getPackageManager().getPackageInfo(packageName, 0);
+                    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);
                     return false;
                 }
 
@@ -169,10 +187,10 @@ public class Script {
                 callScriptingContainerMethod(Void.class, "setCurrentDirectory", defaultCurrentDir);
 
                 if (out != null) {
-        	        Method setOutputMethod = ruby.getClass().getMethod("setOutput", PrintStream.class);
-        	        setOutputMethod.invoke(ruby, out);
-        	        Method setErrorMethod = ruby.getClass().getMethod("setError", PrintStream.class);
-        	        setErrorMethod.invoke(ruby, out);
+                  output = out;
+                  setOutputStream(out);
+                } else if (output != null) {
+                  setOutputStream(output);
                 }
 
                 String jrubyHome = "file:" + apkName + "!";
@@ -204,6 +222,29 @@ public class Script {
         return initialized;
     }
 
+    public static void setOutputStream(PrintStream out) {
+      if (ruby == null) {
+        output = out;
+      } else {
+        try {
+          Method setOutputMethod = ruby.getClass().getMethod("setOutput", PrintStream.class);
+          setOutputMethod.invoke(ruby, out);
+          Method setErrorMethod = ruby.getClass().getMethod("setError", PrintStream.class);
+          setErrorMethod.invoke(ruby, out);
+        } catch (IllegalArgumentException e) {
+            handleInitException(e);
+        } catch (SecurityException e) {
+            handleInitException(e);
+        } catch (IllegalAccessException e) {
+            handleInitException(e);
+        } catch (InvocationTargetException e) {
+            handleInitException(e);
+        } catch (NoSuchMethodException e) {
+            handleInitException(e);
+        }
+      }
+    }
+
     private static void handleInitException(Exception e) {
         Log.e(TAG, "Exception starting JRuby");
         Log.e(TAG, e.getMessage() != null ? e.getMessage() : e.getClass().getName());
@@ -252,7 +293,11 @@ public class Script {
         } catch (IllegalAccessException iae) {
             throw new RuntimeException(iae);
         } catch (java.lang.reflect.InvocationTargetException ite) {
-            throw ((RuntimeException) ite.getCause());
+            if (isDebugBuild) {
+                throw ((RuntimeException) ite.getCause());
+            } else {
+                return null;
+            }
         }
 	}
 
@@ -315,7 +360,7 @@ public class Script {
     }
 
     private static List<String> getLoadPath() {
-        return callScriptingContainerMethod(List.class, "getLoadPaths");
+        return (List<String>)callScriptingContainerMethod(List.class, "getLoadPaths");
     }
 
     public static Boolean configDir(String scriptsDir) {
@@ -371,21 +416,20 @@ public class Script {
 		}
     }
     
-    private static boolean isDebugBuild(Context context) {
+    private static void setDebugBuild(Context context) {
         PackageManager pm = context.getPackageManager();
         PackageInfo pi;
         try {
             pi = pm.getPackageInfo(context.getPackageName(), 0);
-            return ((pi.applicationInfo.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0);
+            isDebugBuild = ((pi.applicationInfo.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0);
         } catch (NameNotFoundException e) {
-            return false;
+            isDebugBuild = false;
         }
-
     }
 
     private static String scriptsDirName(Context context) {
         File storageDir = null;
-        if (isDebugBuild(context)) {
+        if (isDebugBuild) {
 
             // FIXME(uwe): Simplify this as soon as we drop support for android-7 or JRuby 1.5.6 or JRuby 1.6.2
             Log.i(TAG, "JRuby VERSION: " + JRUBY_VERSION);
@@ -474,7 +518,7 @@ public class Script {
      */
 
     public static String getScriptFilename() {
-        return callScriptingContainerMethod(String.class, "getScriptFilename");
+        return (String)callScriptingContainerMethod(String.class, "getScriptFilename");
     }
 
     public static void setScriptFilename(String name) {
@@ -496,6 +540,9 @@ public class Script {
             throw new RuntimeException(iae);
         } catch (java.lang.reflect.InvocationTargetException ite) {
             printStackTrace(ite);
+            if (isDebugBuild) {
+                throw new RuntimeException(ite);
+            }
         }
     }
 
@@ -522,14 +569,34 @@ public class Script {
         return null;
 	}
 
-	public static <T> T callMethod(Object receiver, String methodName,
-			Object arg, Class<T> returnType) {
-		return callMethod(receiver, methodName, new Object[]{arg}, returnType);
+	@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;
 	}
 
-	public static <T> T callMethod(Object receiver, String methodName,
-			Class<T> returnType) {
-		return callMethod(receiver, methodName, new Object[]{}, returnType);
+	@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;
 	}
 
 	private static void printStackTrace(Throwable t) {

data/assets/src/org/ruboto/test/ActivityTest.java

@@ -19,44 +19,47 @@ public class ActivityTest extends ActivityInstrumentationTestCase2 {
     private final Object setup;
     private final Object block;
     private final String filename;
+    private final boolean onUiThread;
 
-    public ActivityTest(Class activityClass, String filename, Object setup, String name, Object block) {
+    public ActivityTest(Class activityClass, String filename, Object setup, String name, boolean onUiThread, Object block) {
         super(activityClass.getPackage().getName(), activityClass);
         this.filename = filename;
         this.setup = setup;
         setName(filename + "#" + name);
+        this.onUiThread = onUiThread;
         this.block = block;
         Log.i(getClass().getName(), "Instance: " + getName());
     }
 
     public void runTest() throws Exception {
-        Log.i(getClass().getName(), "runTest");
-        Log.i(getClass().getName(), "runTest: " + getName());
-        if (Script.setUpJRuby(getActivity())) {
-            Log.i(getClass().getName(), "ruby ok");
-            try {
-                final Activity activity = getActivity();
-                Log.i(getClass().getName(), "activity ok");
-                runTestOnUiThread(new Runnable() {
-                    public void run() {
-                        String oldFile = Script.getScriptFilename();
+        try {
+            Log.i(getClass().getName(), "runTest: " + getName());
+            final Activity activity = getActivity();
+            Log.i(getClass().getName(), "Activity OK");
+            Runnable testRunnable = new Runnable() {
+                public void run() {
+                    String oldFile = Script.getScriptFilename();
 
-                        Log.i(getClass().getName(), "calling setup");
-                        Script.setScriptFilename(filename);
-                        Script.callMethod(setup, "call", activity);
-                        Log.i(getClass().getName(), "setup ok");
+                    Log.i(getClass().getName(), "calling setup");
+                    Script.setScriptFilename(filename);
+                    Script.callMethod(setup, "call", activity);
+                    Log.i(getClass().getName(), "setup ok");
                     
-                        Script.setScriptFilename(filename);
-                        Script.callMethod(block, "call", activity);
-                        Script.setScriptFilename(oldFile);
-                    }
-                });
-            } catch (Throwable t) {
-                throw new AssertionFailedError(t.getMessage() != null ? t.getMessage() : t.getClass().getName());
+                    Script.setScriptFilename(filename);
+                    Script.callMethod(block, "call", activity);
+                    Script.setScriptFilename(oldFile);
+                }
+            };
+            if (onUiThread) {
+                runTestOnUiThread(testRunnable);
+            } else {
+                testRunnable.run();
             }
             Log.i(getClass().getName(), "runTest ok");
-        } else {
-            throw new AssertionFailedError("Ruboto Core platform is missing.");
+        } catch (Throwable t) {
+            AssertionFailedError afe = new AssertionFailedError("Exception running test.");
+            afe.initCause(t);
+            throw afe;
         }
     }
 

data/assets/src/org/ruboto/test/InstrumentationTestRunner.java

@@ -15,10 +15,12 @@ import java.net.URLDecoder;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.Enumeration;
 import java.util.jar.JarFile;
 import java.util.jar.JarEntry;
 import java.util.List;
+import java.util.Map;
 import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
@@ -34,15 +36,37 @@ public class InstrumentationTestRunner extends android.test.InstrumentationTestR
     public TestSuite getAllTests() {
         Log.i(getClass().getName(), "Finding test scripts");
         suite = new TestSuite("Sweet");
+        String loadStep = "Setup JRuby";
         
         try {
-            if (Script.setUpJRuby(getTargetContext())) {
+            final AtomicBoolean JRubyLoadedOk = new AtomicBoolean();
+
+            // TODO(uwe):  Running with large stack is currently only needed when running with JRuby 1.7.0 and android-10
+            // TODO(uwe):  Simplify when we stop support for JRuby 1.7.0 or android-10
+            Thread t = new Thread(null, new Runnable() {
+                public void run() {
+                    JRubyLoadedOk.set(Script.setUpJRuby(getTargetContext()));
+                }
+            }, "Setup JRuby from instrumentation test runner", 64 * 1024);
+            try {
+                t.start();
+                t.join();
+            } catch(InterruptedException ie) {
+                Thread.currentThread().interrupt();
+                throw new RuntimeException("Interrupted starting JRuby", ie);
+            }
+            // TODO end
+
+            if (JRubyLoadedOk.get()) {
+                loadStep = "Setup global variables";
                 Script.defineGlobalVariable("$runner", this);
                 Script.defineGlobalVariable("$test", this);
                 Script.defineGlobalVariable("$suite", suite);
 
+                loadStep = "Load test helper";
                 loadScript("test_helper.rb");
 
+                loadStep = "Get app test source dir";
                 String test_apk_path = getContext().getPackageManager().getApplicationInfo(getContext().getPackageName(), 0).sourceDir;
                 JarFile jar = new JarFile(test_apk_path);
                 Enumeration<JarEntry> entries = jar.entries();
@@ -53,17 +77,18 @@ public class InstrumentationTestRunner extends android.test.InstrumentationTestR
                         continue;
                     }
                     if (name.equals("test_helper.rb")) continue;
+                    loadStep = "Load " + name;
                     loadScript(name);
                 }
             } else {
-                addError(suite, new RuntimeException("Ruboto Core platform is missing"));
+                addError(suite, loadStep, new RuntimeException("Ruboto Core platform is missing"));
             }
         } catch (android.content.pm.PackageManager.NameNotFoundException e) {
-            addError(suite, e);
+            addError(suite, loadStep, e);
         } catch (IOException e) {
-          addError(suite, e);
+          addError(suite, loadStep, e);
         } catch (RuntimeException e) {
-          addError(suite, e);
+          addError(suite, loadStep, e);
         }
         return suite;
     }
@@ -77,18 +102,27 @@ public class InstrumentationTestRunner extends android.test.InstrumentationTestR
     }
 
     public void test(String name, Object block) {
+        test(name, null, block);
+    }
+
+    public void test(String name, Map options, Object block) {
+        // FIXME(uwe): Remove when we stop supporting Android 2.2
         if (android.os.Build.VERSION.SDK_INT <= 8) {
           name ="runTest";
         }
-        Test test = new ActivityTest(activityClass, Script.getScriptFilename(), setup, name, block);
+        // FIXME end
+
+        boolean runOnUiThread = options == null || options.get("ui") == "true";
+
+        Test test = new ActivityTest(activityClass, Script.getScriptFilename(), setup, name, runOnUiThread, block);
         suite.addTest(test);
         Log.d(getClass().getName(), "Made test instance: " + test);
     }
 
-    private void addError(TestSuite suite, Throwable t) {
+    private void addError(TestSuite suite, String loadStep, Throwable t) {
         Throwable cause = t;
         while(cause != null) {
-          Log.e(getClass().getName(), "Exception loading tests: " + cause);
+          Log.e(getClass().getName(), "Exception loading tests (" + loadStep + "): " + cause);
           t = cause;
           cause = t.getCause();
         }

data/assets/src/ruboto/activity.rb

@@ -35,7 +35,7 @@ module Ruboto
       $context_init_block = block
       $new_context_global = global_variable_name
   
-      if @initialized or (self == $activity && !$activity.kind_of?(RubotoActivity))
+      if @initialized or (self == $activity && !$activity.rubotoAttachable)
         b = Java::android.os.Bundle.new
         b.putInt("Theme", theme) if theme