ruboto-core 0.3.3 → 0.4.0

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

@@ -1,11 +1,13 @@
 package org.ruboto;
 
 import android.content.Context;
+import android.content.Intent;
 import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
 import android.content.pm.PackageManager.NameNotFoundException;
 import android.content.res.AssetManager;
+import android.net.Uri;
 import android.os.Environment;
 import android.util.Log;
 
@@ -19,22 +21,38 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.PrintStream;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.List;
 
-import org.jruby.RubyInstanceConfig;
-import org.jruby.embed.ScriptingContainer;
-import org.jruby.exceptions.RaiseException;
+import dalvik.system.PathClassLoader;
 
 public class Script {
     private static String scriptsDir = "scripts";
     private static File scriptsDirFile = null;
 
     private String name = null;
-    private static ScriptingContainer ruby;
+    private static Object ruby;
     private static boolean initialized = false;
 
-    private String contents = null;
+    private static String localContextScope = "SINGLETON";
+    private static String localVariableBehavior = "TRANSIENT";
 
     public static final String TAG = "RUBOTO"; // for logging
+    private static String JRUBY_VERSION;
+
+    /*************************************************************************************************
+     * 
+     * Static Methods: ScriptingContainer config
+     */
+
+    public static void setLocalContextScope(String val) {
+        localContextScope = val;
+    }
+
+    public static void setLocalVariableBehavior(String val) {
+        localVariableBehavior = val;
+    }
 
     /*************************************************************************************************
      * 
@@ -47,100 +65,189 @@ public class Script {
         }
     };
 
-    public static boolean initialized() {
-        return initialized;
-    }
+	public static synchronized boolean isInitialized() {
+		return initialized;
+	}
 
-    public static synchronized ScriptingContainer setUpJRuby(Context appContext) {
+    public static synchronized boolean setUpJRuby(Context appContext) {
         return setUpJRuby(appContext, System.out);
     }
 
-    public static synchronized ScriptingContainer setUpJRuby(Context appContext, PrintStream out) {
-        if (ruby == null) {
-
-/*
-            http://www.anddev.org/view-layout-resource-problems-f27/dexclassloader-problem-t14666.html
-            http://lsd.luminis.nl/osgi-on-google-android-using-apache-felix/
+    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");
+            System.setProperty("jruby.interfaces.useProxy", "true");
+            System.setProperty("jruby.management.enabled", "false");
 
-            String packagePath = "org.ruboto.core";
-            String classPath = "org.jruby.embed.ScriptingContainer";
+            ClassLoader classLoader;
+            Class<?> scriptingContainerClass;
 
-            String apkName = null;
             try {
-                apkName = getPackageManager().getApplicationInfo(packagePath,0).sourceDir;
-            } catch (PackageManager.NameNotFoundException e) {
-                // catch this
+                scriptingContainerClass = Class.forName("org.jruby.embed.ScriptingContainer");
+                System.out.println("Found JRuby in this APK");
+                classLoader = Script.class.getClassLoader();
+            } catch (ClassNotFoundException e1) {
+                String packagePath = "org.ruboto.core";
+                String apkName = null;
+                try {
+                    apkName = appContext.getPackageManager().getApplicationInfo(packagePath, 0).sourceDir;
+                } catch (PackageManager.NameNotFoundException e) {
+                    System.out.println("JRuby not found");
+                    return false;
+                }
+
+                System.out.println("Found JRuby in platform APK");
+                classLoader = new PathClassLoader(apkName, Script.class.getClassLoader());
+                try {
+                    scriptingContainerClass = Class.forName("org.jruby.embed.ScriptingContainer", true, classLoader);
+                } catch (ClassNotFoundException e) {
+                    // FIXME(uwe): ScriptingContainer not found in the platform APK...
+                    e.printStackTrace();
+                    return false;
+                }
             }
 
-            // add path to apk that contains classes you wish to load
-            String extraApkPath = apkName + ":/path/to/extraLib.apk"
+            try {
+                try {
+                    JRUBY_VERSION = (String) Class.forName("org.jruby.runtime.Constants", true, classLoader).getDeclaredField("VERSION").get(String.class);
+                } catch (java.lang.NoSuchFieldException nsfex) {
+                    nsfex.printStackTrace();
+                    JRUBY_VERSION = "ERROR";
+                }
 
-            PathClassLoader pathClassLoader = new dalvik.system.PathClassLoader(apkName, ClassLoader.getSystemClassLoader());
+                Class scopeClass = Class.forName("org.jruby.embed.LocalContextScope", true, scriptingContainerClass.getClassLoader());
+                Class behaviorClass = Class.forName("org.jruby.embed.LocalVariableBehavior", true, scriptingContainerClass.getClassLoader());
 
-            try {
-                Class<?> handler = Class.forName(classPath, true, pathClassLoader);
-            } catch (ClassNotFoundException e) {
-                // catch this
-            }
-*/
+                ruby = scriptingContainerClass
+                         .getConstructor(scopeClass, behaviorClass)
+                         .newInstance(Enum.valueOf(scopeClass, localContextScope), 
+                                      Enum.valueOf(behaviorClass, localVariableBehavior));
 
-            Log.d(TAG, "Setting up JRuby runtime");
-            System.setProperty("jruby.bytecode.version", "1.5");
-            System.setProperty("jruby.interfaces.useProxy", "true");
-            System.setProperty("jruby.management.enabled", "false");
+                Class compileModeClass = Class.forName("org.jruby.RubyInstanceConfig$CompileMode", true, classLoader);
+                callScriptingContainerMethod(Void.class, "setCompileMode", Enum.valueOf(compileModeClass, "OFF"));
 
-		    // ruby = new ScriptingContainer(LocalContextScope.THREADSAFE);
-		    ruby = new ScriptingContainer();
-		    RubyInstanceConfig config = ruby.getProvider().getRubyInstanceConfig();
-            config.setCompileMode(RubyInstanceConfig.CompileMode.OFF);
+                // callScriptingContainerMethod(Void.class, "setClassLoader", classLoader);
+        	    Method setClassLoaderMethod = ruby.getClass().getMethod("setClassLoader", ClassLoader.class);
+        	    setClassLoaderMethod.invoke(ruby, classLoader);
 
-            config.setLoader(Script.class.getClassLoader());
-		    if (scriptsDir != null) {
-                Log.d(TAG, "Setting JRuby current directory to " + scriptsDir);
-                config.setCurrentDirectory(scriptsDir);
-            }
-            if (out != null) {
-            	config.setOutput(out);
-            	config.setError(out);
+                Thread.currentThread().setContextClassLoader(classLoader);
+
+                if (scriptsDir != null) {
+                    Log.d(TAG, "Setting JRuby current directory to " + scriptsDir);
+                    callScriptingContainerMethod(Void.class, "setCurrentDirectory", scriptsDir);
+                }
+                if (out != null) {
+                    // callScriptingContainerMethod(Void.class, "setOutput", out);
+        	        Method setOutputMethod = ruby.getClass().getMethod("setOutput", PrintStream.class);
+        	        setOutputMethod.invoke(ruby, out);
+
+                    // callScriptingContainerMethod(Void.class, "setError", out);
+        	        Method setErrorMethod = ruby.getClass().getMethod("setError", PrintStream.class);
+        	        setErrorMethod.invoke(ruby, out);
+                }
+                String extraScriptsDir = scriptsDirName(appContext);
+                Log.i(TAG, "Checking scripts in " + extraScriptsDir);
+                if (configDir(extraScriptsDir)) {
+                    Log.i(TAG, "Added extra scripts path: " + extraScriptsDir);
+                }
+                initialized = true;
+            } catch (ClassNotFoundException e) {
+                handleInitException(e);
+            } catch (IllegalArgumentException e) {
+                handleInitException(e);
+            } catch (SecurityException e) {
+                handleInitException(e);
+            } catch (InstantiationException e) {
+                handleInitException(e);
+            } catch (IllegalAccessException e) {
+                handleInitException(e);
+            } catch (InvocationTargetException e) {
+                handleInitException(e);
+            } catch (NoSuchMethodException e) {
+                handleInitException(e);
             }
-            copyScriptsIfNeeded(appContext);
-            initialized = true;
-		} else {
-			while (!initialized) {
-                Log.i(TAG, "Waiting for JRuby runtime to initialize.");
-				try {
-					Thread.sleep(1000);
-				} catch (InterruptedException iex) {
-				}
-			}
-		}
+        }
+        return initialized;
+    }
 
-        return ruby;
+    private static void handleInitException(Exception e) {
+        Log.e(TAG, "Exception starting JRuby");
+        Log.e(TAG, e.getMessage() != null ? e.getMessage() : e.getClass().getName());
+        e.printStackTrace();
+        ruby = null;
     }
 
-    public static String execute(String code) {
+    @SuppressWarnings("unchecked")
+    public static <T> T callScriptingContainerMethod(Class<T> returnType, String methodName, Object... args) {
+        Class<?>[] argClasses = new Class[args.length];
+        for (int i = 0; i < argClasses.length; i++) {
+            argClasses[i] = args[i].getClass();
+        }
         try {
-			return getRuby().callMethod(exec(code), "inspect", String.class);
-        } catch (RaiseException re) {
-			re.printStackTrace(ruby.getError());
-            return null;
+        	Method method = ruby.getClass().getMethod(methodName, argClasses);
+        	System.out.println("callScriptingContainerMethod: method: " + method);
+        	T result = (T) method.invoke(ruby, args);
+        	System.out.println("callScriptingContainerMethod: result: " + result);
+            return result;
+        } catch (RuntimeException re) {
+            re.printStackTrace();
+        } catch (IllegalAccessException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+        	try {
+                e.printStackTrace();
+        	} catch (NullPointerException npe) {
+        	}
+        } catch (NoSuchMethodException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
         }
+        return null;
     }
 
-	public static Object exec(String code) throws RaiseException {
-		return ruby.runScriptlet(code);
+    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"; 
+    }
+
+	public static Object exec(String code) {
+        // return callScriptingContainerMethod(Object.class, "runScriptlet", code);
+        try {
+            Method runScriptletMethod = ruby.getClass().getMethod("runScriptlet", String.class);
+            return runScriptletMethod.invoke(ruby, code);
+        } catch (NoSuchMethodException nsme) {
+            throw new RuntimeException(nsme);
+        } catch (IllegalAccessException iae) {
+            throw new RuntimeException(iae);
+        } catch (java.lang.reflect.InvocationTargetException ite) {
+            throw ((RuntimeException) ite.getCause());
+        }
 	}
 
     public static void defineGlobalConstant(String name, Object object) {
-		ruby.put(name, object);
+    	put(name, object);
     }
-    
-    public static void defineGlobalVariable(String name, Object object) {
-		ruby.put(name, object);
+
+    public static void put(String name, Object object) {
+        // callScriptingContainerMethod(Void.class, "put", name, object);
+        try {
+            Method putMethod = ruby.getClass().getMethod("put", String.class, Object.class);
+            putMethod.invoke(ruby, name, object);
+        } catch (NoSuchMethodException nsme) {
+            throw new RuntimeException(nsme);
+        } catch (IllegalAccessException iae) {
+            throw new RuntimeException(iae);
+        } catch (java.lang.reflect.InvocationTargetException ite) {
+            throw new RuntimeException(ite);
+        }
     }
     
-	public static ScriptingContainer getRuby() {
-    	return ruby;
+    public static void defineGlobalVariable(String name, Object object) {
+		defineGlobalConstant(name, object);
     }
 
     /*************************************************************************************************
@@ -151,11 +258,11 @@ public class Script {
     public static void setDir(String dir) {
     	scriptsDir = dir;
     	scriptsDirFile = new File(dir);
-		if (ruby != null) {
+        if (ruby != null) {
             Log.d(TAG, "Changing JRuby current directory to " + scriptsDir);
-			ruby.setCurrentDirectory(scriptsDir);
+            callScriptingContainerMethod(Void.class, "setCurrentDirectory", scriptsDir);
         }
-	}
+    }
     
     public static String getDir() {
     	return scriptsDir;
@@ -165,25 +272,34 @@ public class Script {
     	return scriptsDirFile;
     }
 
-    public static Boolean configDir(String noSdcard) {
-        setDir(noSdcard);
-        if (!ruby.getLoadPaths().contains(noSdcard)) {
-            Log.i(TAG, "Adding scripts dir to load path: " + noSdcard);
-            java.util.List paths = ruby.getLoadPaths();
-            paths.add(noSdcard);
-            ruby.setLoadPaths(paths);
+    public static Boolean configDir(String scriptsDir) {
+        setDir(scriptsDir);
+        Method getLoadPathsMethod;
+        List<String> loadPath = callScriptingContainerMethod(List.class, "getLoadPaths");
+        
+        if (!loadPath.contains(scriptsDir)) {
+            Log.i(TAG, "Adding scripts dir to load path: " + scriptsDir);
+            loadPath.add(0, scriptsDir);
+            // callScriptingContainerMethod(Void.class, "setLoadPaths", loadPath);
+            try {
+                Method setLoadPathsMethod = ruby.getClass().getMethod("setLoadPaths", List.class);
+                setLoadPathsMethod.invoke(ruby, loadPath);
+            } catch (NoSuchMethodException nsme) {
+                throw new RuntimeException(nsme);
+            } catch (IllegalAccessException iae) {
+                throw new RuntimeException(iae);
+            } catch (java.lang.reflect.InvocationTargetException ite) {
+                throw new RuntimeException(ite);
+            }
         }
 
-        /* Create directory if it doesn't exist */
-        if (!scriptsDirFile.exists()) {
-            boolean dirCreatedOk = scriptsDirFile.mkdirs();
-            if (!dirCreatedOk) {
-                throw new RuntimeException("Unable to create script directory");
-            }
+        if (scriptsDirFile.exists()) {
+            Log.i(TAG, "Found extra scripts dir: " + scriptsDir);
             return true;
+        } else {
+            Log.i(TAG, "Extra scripts dir not present: " + scriptsDir);
+            return false;
         }
-
-        return false;
     }
 
     private static void copyScripts(String from, File to, AssetManager assets) {
@@ -240,35 +356,35 @@ public class Script {
     }
 
     private static String scriptsDirName(Context context) {
-		File toFile = null;
+        File storageDir = null;
         if (isDebugBuild(context)) {
 
-        	// 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: " + org.jruby.runtime.Constants.VERSION);
-            if (!org.jruby.runtime.Constants.VERSION.equals("1.5.6") && !org.jruby.runtime.Constants.VERSION.equals("1.6.2") && android.os.Build.VERSION.SDK_INT >= 8) {
-            	ruby.put("script_context", context);
-            	toFile = (File) exec("script_context.getExternalFilesDir(nil)");
+            // 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);
+            if (!JRUBY_VERSION.equals("1.5.6") && !JRUBY_VERSION.equals("1.6.2") && android.os.Build.VERSION.SDK_INT >= 8) {
+                put("script_context", context);
+                storageDir = (File) exec("script_context.getExternalFilesDir(nil)");
             } else {
-                toFile = new File(Environment.getExternalStorageDirectory(), "Android/data/" + context.getPackageName() + "/files");
-                Log.e(TAG, "Calculated path to sdcard the old way: " + toFile);
+                storageDir = new File(Environment.getExternalStorageDirectory(), "Android/data/" + context.getPackageName() + "/files");
+                Log.e(TAG, "Calculated path to sdcard the old way: " + storageDir);
             }
             // FIXME end
 
-	        if (toFile == null || (!toFile.exists() && !toFile.mkdirs())) {
-		    	Log.e(TAG,
+            if (storageDir == null || (!storageDir.exists() && !storageDir.mkdirs())) {
+                Log.e(TAG,
                         "Development mode active, but sdcard is not available.  Make sure you have added\n<uses-permission android:name='android.permission.WRITE_EXTERNAL_STORAGE' />\nto your AndroidManifest.xml file.");
-	            toFile = context.getFilesDir();
+                storageDir = context.getFilesDir();
             }
-		} else {
-            toFile = context.getFilesDir();
+        } else {
+            storageDir = context.getFilesDir();
         }
-		String to = toFile.getAbsolutePath() + "/scripts";
-		return to;
+        return storageDir.getAbsolutePath() + "/scripts";
     }
 
     private static void copyScriptsIfNeeded(Context context) {
         String to = scriptsDirName(context);
 		Log.i(TAG, "Checking scripts in " + to);
+
         /* the if makes sure we only do this the first time */
         if (configDir(to)) {
 			Log.i(TAG, "Copying scripts to " + to);
@@ -283,12 +399,7 @@ public class Script {
     */
 
     public Script(String name) {
-        this(name, null);
-    }
-
-    public Script(String name, String contents) {
         this.name = name;
-        this.contents = contents;
     }
 
     /*************************************************************************************************
@@ -306,12 +417,17 @@ public class Script {
 
     public Script setName(String name) {
         this.name = name;
-        // TODO: Other states possible
         return this;
     }
 
     public String getContents() throws IOException {
-        BufferedReader buffer = new BufferedReader(new FileReader(getFile()), 8192);
+        InputStream is;
+        if (new File(scriptsDir + "/" + name).exists()) {
+            is = new java.io.FileInputStream(scriptsDir + "/" + name);
+        } else {
+            is = getClass().getClassLoader().getResourceAsStream(name);
+        }
+        BufferedReader buffer = new BufferedReader(new java.io.InputStreamReader(is), 8192);
         StringBuilder source = new StringBuilder();
         while (true) {
             String line = buffer.readLine();
@@ -321,8 +437,7 @@ public class Script {
             source.append(line).append("\n");
         }
         buffer.close();
-        contents = source.toString();
-        return contents;
+        return source.toString();
     }
 
     /*************************************************************************************************
@@ -330,8 +445,65 @@ public class Script {
      * Script Actions
      */
 
+    public static String getScriptFilename() {
+        return callScriptingContainerMethod(String.class, "getScriptFilename");
+    }
+
+    public static void setScriptFilename(String name) {
+        callScriptingContainerMethod(Void.class, "setScriptFilename", name);
+    }
+
     public String execute() throws IOException {
-    	Script.getRuby().setScriptFilename(name);
+    	Script.setScriptFilename(getClass().getClassLoader().getResource(name).getPath());
         return Script.execute(getContents());
     }
+
+	public static void callMethod(Object receiver, String methodName, Object[] args) {
+		// callScriptingContainerMethod(Void.class, "callMethod", receiver, methodName, 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) {
+            throw (RuntimeException)(ite.getCause());
+        }
+    }
+
+	public static void callMethod(Object object, String methodName, Object arg) {
+		callMethod(object, methodName, new Object[] { arg });
+	}
+
+	public static void callMethod(Object object, String methodName) {
+		callMethod(object, methodName, new Object[] {});
+	}
+
+	@SuppressWarnings("unchecked")
+	public static <T> T callMethod(Object receiver, String methodName, Object[] args, Class<T> returnType) {
+		// return callScriptingContainerMethod(returnType, "callMethod", receiver, methodName, args, 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) {
+            throw (RuntimeException) ite.getCause();
+        }
+	}
+
+	public static <T> T callMethod(Object receiver, String methodName,
+			Object arg, Class<T> returnType) {
+		return callMethod(receiver, methodName, new Object[]{arg}, returnType);
+	}
+
+	public static <T> T callMethod(Object receiver, String methodName,
+			Class<T> returnType) {
+		return callMethod(receiver, methodName, new Object[]{}, returnType);
+	}
+
 }
+

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

@@ -13,18 +13,14 @@ import junit.framework.AssertionFailedError;
 import junit.framework.Test;
 import junit.framework.TestResult;
 import junit.framework.TestSuite;
-import org.jruby.exceptions.RaiseException;
-import org.jruby.javasupport.JavaUtil;
-import org.jruby.javasupport.util.RuntimeHelpers;
-import org.jruby.runtime.builtin.IRubyObject;
 import org.ruboto.Script;
 
 public class ActivityTest extends ActivityInstrumentationTestCase2 {
     private final Object setup;
-    private final IRubyObject block;
+    private final Object block;
     private final String filename;
 
-    public ActivityTest(Class activityClass, String filename, IRubyObject setup, String name, IRubyObject block) {
+    public ActivityTest(Class activityClass, String filename, Object setup, String name, Object block) {
         super(activityClass.getPackage().getName(), activityClass);
         this.filename = filename;
         this.setup = setup;
@@ -36,29 +32,32 @@ public class ActivityTest extends ActivityInstrumentationTestCase2 {
     public void runTest() throws Exception {
         Log.i(getClass().getName(), "runTest");
         Log.i(getClass().getName(), "runTest: " + getName());
-        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.getRuby().getScriptFilename();
+        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();
 
-                    Log.i(getClass().getName(), "calling setup");
-                    Script.getRuby().setScriptFilename(filename);
-                    Script.getRuby().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.getRuby().setScriptFilename(filename);
-                    Script.getRuby().callMethod(block, "call", activity);
-                    Script.getRuby().setScriptFilename(oldFile);
-                }
-            });
-        } catch (Throwable t) {
-            throw new AssertionFailedError(t.getMessage());
+                        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());
+            }
+            Log.i(getClass().getName(), "runTest ok");
+        } else {
+            throw new AssertionFailedError("Ruboto Core platform is missing.");
         }
-        Log.i(getClass().getName(), "runTest ok");
     }
 
 }