ruboto-core 0.0.1

data/bin/ruboto

@@ -0,0 +1,191 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'jruby'
+  JRuby.objectspace = true
+rescue LoadError
+end
+
+require 'main'
+require 'fileutils'
+require 'rexml/document'
+require 'jruby-jars'
+
+# fix main (to an extent)
+module Main
+  class Program
+    module InstanceMethods
+      def setup_finalizers
+        @finalizers ||= []
+        ObjectSpace.define_finalizer(self) do
+          while((f = @finalizers.pop)); f.call; end
+        end
+      end
+    end
+  end
+end
+
+$assets = File.expand_path(__FILE__ + "/../../assets")
+
+class AssetCopier
+  def initialize(from, to)
+    @from = from
+    @to = to
+  end
+
+  def copy(from, to='')
+    FileUtils.mkdir_p(File.join(@to, to))
+    FileUtils.cp_r(Dir[File.join(@from, from)], File.join(@to, to))
+  end
+
+  def copy_from_absolute_path(from, to='')
+    FileUtils.mkdir_p(File.join(@to, to))
+    FileUtils.cp_r(Dir[from], File.join(@to, to))
+  end
+end
+
+def generate_inheriting_file(klass, name, package, script_name, dest='.')
+  to = File.join(dest, "src/#{package.gsub('.', '/')}")
+
+  FileUtils.cp(File.expand_path(__FILE__ + "/../../assets/src/Inheriting#{klass}.java"), to)
+  FileUtils.move(File.join(to, "Inheriting#{klass}.java"), File.join(to, "#{name}.java"))
+
+  file = File.join(to, "#{name}.java")
+  text = File.read(file)
+  File.open(file, 'w') do |f|
+    f << text.gsub("THE_PACKAGE", package).gsub("Inheriting#{klass}", name).gsub("start.rb", script_name)
+  end
+
+  sample_source = File.read(File.join($assets, "samples/sample_#{underscore klass}.rb"))
+  File.open File.join(dest, "assets/scripts/#{script_name}"), "a" do |f|
+    f << sample_source
+  end
+end
+
+# active_support/inflector.rb
+def underscore(camel_cased_word)
+  camel_cased_word.to_s.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+end
+
+
+
+Main {
+  mode "gen" do
+    mode "app" do
+      option("name"){
+        required
+        argument :required
+        description "Name of your app"
+      }
+      option("target") {
+        required
+        argument :required
+        description "android version to target. must begin with 'android-'. Currently must be 'android-8'"
+      }
+      option("path"){
+        required
+        argument :required
+        description "path to where you want your app."
+      }
+      option("package"){
+        required
+        argument :required
+        description "Name of package. Must be unique for every app. A common pattern is yourtld.yourdomain.appname (Ex. org.ruboto.irb)"
+      }
+      option("activity"){
+        required
+        argument :required
+        description "name of your primary Activity"
+      }
+
+      def run
+        path = params['path'].value
+        name = params['name'].value
+        target = params['target'].value
+        package = params['package'].value
+        activity = params['activity'].value
+
+        `android create project -n #{name} -t #{target} -p #{path} -k #{package} -a #{activity}`
+        root = File.expand_path(path)
+
+        copier = AssetCopier.new $assets, root
+        copier.copy "Rakefile"
+        copier.copy_from_absolute_path JRubyJars::core_jar_path, "libs"
+        copier.copy_from_absolute_path JRubyJars::stdlib_jar_path, "libs"
+        copier.copy ".gitignore"
+        copier.copy "assets"
+        copier.copy "src/org/ruboto/*.java", "src/org/ruboto"
+
+        java_files = File.join(root, "assets/scripts/ruboto.rb")
+        java_files.each do |file|
+          text = File.read(file)
+          File.open(file, 'w') do |f|
+            f << text.gsub("THE_PACKAGE", package).gsub("ACTIVITY_NAME", activity)
+          end
+        end
+
+        generate_inheriting_file "Activity", activity, package, "#{underscore(activity)}.rb", path
+      end
+    end
+
+    mode "class" do
+      argument("class"){
+        required
+        description "the Android Class that you want."
+      }
+
+      option("script_name"){
+        argument :required
+        description "name of the ruby script in assets/scripts/ that this class will execute. should end in .rb. optional"
+      }
+
+      option("name"){
+        required
+        argument :required
+        description "name of the class (and file). Should be CamelCase"
+      }
+
+
+      def run
+        package = REXML::Document.new(File.read('AndroidManifest.xml')).root.attribute('package').value
+        name = params['name'].value
+        script_name = params['script_name'].value || "#{underscore(name)}.rb"
+        klass = params['class'].value
+
+        generate_inheriting_file klass, name, package, script_name
+      end
+    end
+
+    mode "key" do
+      option("keystore"){
+        default "~/.android/production.keystore"
+        description "path to where the keystore will be saved. defaults to ~/.android/production.keystore"
+      }
+
+      option("alias"){
+        required
+        description "The 'alias' for the key. Identifies the key within the keystore. Required"
+      }
+
+      def run
+        keystore = params['keystore'].value
+        key_alias = params['alias'].value
+
+        `keytool -genkey -keyalg rsa -keysize 4096 -validity 1000000 -keystore #{keystore} -alias #{key_alias}`
+      end
+    end
+  end
+
+  # just running `ruboto`
+  def run
+    puts %Q{
+      Ruboto -- Ruby for Android
+      Execute `ruboto gen app --help` for instructions on how to generate a fresh Ruby-enabled Android app
+    }
+  end
+}
+

data/lib/java_class_gen/InheritingClass.java.erb

@@ -0,0 +1,11 @@
+package THE_PACKAGE;
+
+public class Inheriting<%= @class %> extends org.ruboto.Ruboto<%= @class %> {
+%       v = @callbacks[@full_class][@first_method]
+	public <%= "#{v["return_type"]} #{v["interface_method"]}(#{v["args_with_types"] })" %> {
+
+               setScriptName("start.rb");
+               super.<%= @first_method %>(<%= v["args_alone"].join(',') %>);
+        }
+
+}

data/lib/java_class_gen/RubotoClass.java.erb

@@ -0,0 +1,197 @@
+/**********************************************************************************************
+*
+* Ruboto<%= @class %>.java is generated from RubotoClass.java.erb. Any changes needed in should be 
+* made within the erb template or they will be lost.
+*
+*/
+
+package org.ruboto;
+
+import java.io.IOException;
+import <%= @full_class %>;
+% if @class == "Activity"
+import android.app.ProgressDialog;
+% end
+import android.os.Handler;
+import android.os.Bundle;
+
+import org.jruby.Ruby;
+import org.jruby.javasupport.util.RuntimeHelpers;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.javasupport.JavaUtil;
+import org.jruby.exceptions.RaiseException;
+
+public abstract class Ruboto<%= @class %> extends <%= @class %>
+%##############################################################################################
+%#
+%#  Implement all interfaces
+%#
+    <%= "implements\n        #{@implements.join(",\n        ")}" unless @implements.empty? %>
+%##############################################################################################
+{
+%##############################################################################################
+%#
+%#  Create constants for all callbacks (may get rid of this means of requesting callbacks later)
+%#
+%    @constants.each_with_index do |c, i|
+<%= "    public static final int #{c} = #{i};" %>
+%    end
+%##############################################################################################
+	public static final int CB_LAST = <%= @constants.size %>;
+	
+	private boolean[] callbackOptions = new boolean [CB_LAST];
+    
+	private String remoteVariable = "";
+
+    private final Handler loadingHandler = new Handler();
+    private IRubyObject __this__;
+    private Ruby __ruby__;
+    private String scriptName;
+    public Object[] args;
+
+	public Ruboto<%= @class %> setRemoteVariable(String var) {
+		remoteVariable = ((var == null) ? "" : (var + "."));
+		return this;
+	}
+	
+	/**********************************************************************************
+	 *  
+	 *  Callback management
+	 */
+	
+	public void requestCallback(int id) {
+		callbackOptions[id] = true;
+	}
+	
+	public void removeCallback(int id) {
+		callbackOptions[id] = false;
+	}
+	
+	/* 
+	 *  Activity Lifecycle: onCreate
+	 */
+	
+	@Override
+%       v = @callbacks[@full_class].delete(@first_method)
+	public <%= "#{v["return_type"]} #{v["interface_method"]}(#{v["args_with_types"] })" %> {
+
+               args = new Object[<%= v["args_alone"].length %>];
+%              v["args_alone"].each_with_index do |arg, index|
+               args[<%= index %>] = <%= arg %>;
+%              end
+%              unless v["abstract"]
+		super.<%= @first_method %>(<%= v["args_alone"].join(',') %>);
+%              end
+
+%               if @class == "Activity"
+%               # we'll assume the first thing that happens is an activity gets spawned. no need to do this in other classes
+                Script.copyScriptsIfNeeded(getFilesDir().getAbsolutePath() + "/scripts", getAssets());
+%               end
+
+		if (Script.getRuby() == null){
+                    Script.setUpJRuby(null);
+		}
+                Script.defineGlobalVariable("$<%= underscore(@class) %>", this);
+
+
+                __ruby__ = Script.getRuby();
+                __this__ = JavaUtil.convertJavaToRuby(__ruby__, Ruboto<%= @class %>.this);
+
+%             if @class == "Activity"
+                Bundle configBundle = getIntent().getBundleExtra("RubotoActivity Config");
+
+                Script.defineGlobalVariable("$bundle", arg0);
+
+                if (configBundle != null) {
+                    setRemoteVariable(configBundle.getString("Remote Variable"));
+                    if (configBundle.getBoolean("Define Remote Variable")) {
+                        Script.defineGlobalVariable(configBundle.getString("Remote Variable"), this);
+                        setRemoteVariable(configBundle.getString("Remote Variable"));
+                    }
+                    if (configBundle.getString("Initialize Script") != null) {
+                        Script.execute(configBundle.getString("Initialize Script"));
+                    }
+                    Script.execute(remoteVariable + "on_create($bundle)");
+                } else {
+                    Script.defineGlobalVariable("$activity", this);
+
+                    try {
+                        new Script(scriptName).execute();
+                    }
+                    catch(IOException e){
+                        ProgressDialog.show(this, "Script failed", "Something bad happened", true, false);
+                    }
+		}
+%             else
+                try {
+                    new Script(scriptName).execute();
+                }
+                catch(IOException e){
+
+                }
+%             end
+	}
+
+        public void setScriptName(String name){
+               scriptName = name;
+        }
+	
+
+
+	/*********************************************************************************
+	 *
+	 * Ruby Generated Callback Methods
+	 */
+	
+%##############################################################################################
+%#
+%#  Create one Java callback methods
+%#
+%    @callbacks.each do |interface,i_info|
+	/*
+	 * <%= interface %>
+	 */
+
+%      i_info.each do |method,v|
+	public <%= "#{v["return_type"]} #{v["interface_method"]}(#{v["args_with_types"] })" %> {
+		if (callbackOptions[<%= v['constant']%>]) {
+			<%= "super.#{v["method"]}(#{v["args_alone"].join(", ")});" if v["interface"] == "Activity" %>
+            try {
+%             if v["args_alone"].size > 3
+            	IRubyObject[] args = {<%= v["args_alone"].map{|i| "JavaUtil.convertJavaToRuby(__ruby__, #{i})"}.join(", ") %>};
+            	<%= "return (#{transform_return_type v["return_type"]})" if v["return_type"] != "void" %>RuntimeHelpers.invoke(__ruby__.getCurrentContext(), __this__, "<%=v["ruby_method"]%>", args)<%= ".toJava(#{v["return_type"]}.class)" if v["return_type"] != "void" %>;
+%             elsif v["args_alone"].size > 0 
+            	<%= "return (#{transform_return_type v["return_type"]})" if v["return_type"] != "void" %>RuntimeHelpers.invoke(__ruby__.getCurrentContext(), __this__, "<%=v["ruby_method"]%>", <%= v["args_alone"].map{|i| "JavaUtil.convertJavaToRuby(__ruby__, #{i})"}.join(", ") %>)<%= ".toJava(#{v["return_type"]}.class)" if v["return_type"] != "void"%>;
+%             else 
+            	<%= "return (#{transform_return_type v["return_type"]})" if v["return_type"] != "void" %>RuntimeHelpers.invoke(__ruby__.getCurrentContext(), __this__, "<%=v["ruby_method"]%>")<%= ".toJava(#{v["return_type"]}.class)" if v["return_type"] != "void"%>;
+%             end
+            } catch (RaiseException re) {
+                re.printStackTrace(__ruby__.getErrorStream());
+                <%= case v["return_type"]
+                           when "boolean": "return false;"
+                           when "int":     "return 0;"
+                           when "void":    ""
+                           else            "return null;"
+                           end
+                                  %>
+            }
+%     if v["interface"] == "Activity" 
+		} else {
+			<%= "return " unless v["return_type"] == "void" %><%= "super.#{v["method"]}(#{v["args_alone"].join(", ")});" %>
+%     elsif v["return_type"] != "void"
+		} else {
+                <%= case v["return_type"]
+                           when "boolean": "return false;"
+                           when "int":     "return 0;"
+                           when "void":    ""
+                           else            "return null;"
+                           end
+                                  %>
+%     end
+		}
+	}
+	
+%      end
+%    end
+%##############################################################################################
+}

data/lib/java_class_gen/callback_reflection.rb

@@ -0,0 +1,109 @@
+#
+# Run on a device and then copy interfaces.txt back to the callback_gen directory.
+#
+# The result is a hash.
+# The keys are names the names of the classes, sometimes followed by a
+# $ and then the name of the interface.
+# The keys are hashes themselves. These hashes have keys of the method
+# names and values of yet another hash, which gives the argument types
+# (and thus implicitly the number of args), the return type, etc.
+
+require 'java'
+
+class ReflectionBuilder
+  attr_reader :methods
+
+  def initialize(class_name, callbacks_only=false)
+    @methods = {}
+    @@count = 0 unless defined?(@@count)
+    reflect class_name, callbacks_only
+  end
+
+  def reflect(klass, callbacks_only=false)
+    # klass can be the java class object or a string
+    klass = java_class klass if klass.class == String
+
+    hash = @methods[klass.getName] = {}
+
+    # iterate over the public methods of the class
+    klass.getDeclaredMethods.reject {|method| java.lang.reflect.Modifier.isPrivate(method.getModifiers) || java.lang.reflect.Modifier.isFinal(method.getModifiers) }.each do |method|
+      if !callbacks_only or method.getName[0..1] == "on"
+        hash[method.getName] = {}
+        hash[method.getName]["return_type"] = method.getReturnType.getName unless method.getReturnType.getName == "void" 
+        # the gsub below converts [Ljava nonsense to ClassName[]
+        hash[method.getName]["args"] = method.getParameterTypes.map {|i| i.getName.gsub(/\[Ljava\.[\w\.]+;/) {|m| "#{m[2..-2]}[]"}} unless method.getParameterTypes.empty?
+        hash[method.getName]["abstract"] = java.lang.reflect.Modifier.isAbstract(method.getModifiers)
+        @@count += 1
+      end
+    end
+  end
+
+  def interfaces(*args)
+    args.each {|arg| reflect arg}
+  end
+
+  def interfaces_under(*args)
+    args.each do |name|
+      interfaces *java.lang.Class.forName(name).getClasses.select {|klass| klass.isInterface}
+    end
+  end
+
+  def self.count
+    @@count
+  end
+
+  def self.reset_count
+    @@count = 0
+  end
+  
+  protected
+  def java_class(class_name)
+    java.lang.Class.forName(class_name)
+  end
+end
+
+def java_reflect(class_name, callbacks_only=false, &block)
+  r = ReflectionBuilder.new(class_name, callbacks_only)
+  yield r if block
+  $result[class_name] = r.methods
+end
+
+def reflect_multiple(*classes)
+  classes.each {|c| java_reflect c }
+end
+
+$result = {}
+ReflectionBuilder.reset_count
+
+java_reflect 'android.app.Activity', true do |r|
+  r.interfaces *%w(
+  android.hardware.SensorEventListener
+  java.lang.Runnable
+  )
+
+  r.interfaces_under *%w(
+  android.view.View
+  android.widget.AdapterView
+  android.widget.TabHost
+  android.widget.TextView
+  android.widget.DatePicker
+  android.widget.TimePicker
+  android.app.DatePickerDialog
+  android.app.TimePickerDialog
+  android.content.DialogInterface
+  )
+end
+
+reflect_multiple *%w(
+android.app.Service
+android.content.BroadcastReceiver
+)
+
+
+
+File.open("/sdcard/jruby/interfaces.txt", "w") do |file|
+  file.write $result.inspect
+end
+
+puts ReflectionBuilder.count
+