ruboto 0.9.0 → 0.10.0.rc.0

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

@@ -152,15 +152,15 @@ public class Script {
 		}
 	}
 
-    // public File getFile() {
-    //     for (String dir : scriptsDir) {
-    //         File f = new File(dir, name);
-    //         if (f.exists()) {
-    //             return f;
-    //         }
-    //     }
-    //     return new File(scriptsDir[0], name);
-    // }
+  public File getFile() {
+    for (String dir : scriptsDir) {
+      File f = new File(dir, name);
+      if (f.exists()) {
+        return f;
+      }
+    }
+    return new File(scriptsDir[0], name);
+  }
 
     public String getName() {
         return name;

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

@@ -5,21 +5,6 @@ public class ScriptInfo {
     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);

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

@@ -31,34 +31,43 @@ public class ScriptLoader {
                 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"));
-                            }
+                    boolean scriptContainsClass = script.matches("(?s).*class "
+                            + component.getScriptInfo().getRubyClassName() + ".*");
+                    boolean hasBackingJavaClass = component.getScriptInfo().getRubyClassName()
+                            .equals(component.getClass().getSimpleName());
+                    if (scriptContainsClass && !hasBackingJavaClass) {
+                        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);
+                            rubyClass = JRubyAdapter.runScriptlet("class << $java_instance; self; end");
+                        } else if (JRubyAdapter.isJRubyOneSeven() && JRubyAdapter.isRubyOneNine()) {
+                            JRubyAdapter.runScriptlet("Java::" + component.getClass().getName() + ".__persistent__ = true");
+                            rubyClass = JRubyAdapter.runRubyMethod(component, "singleton_class");
+                        } else {
+                            throw new RuntimeException("Unknown JRuby/Ruby version: " + JRubyAdapter.get("JRUBY_VERSION") + "/" + JRubyAdapter.get("RUBY_VERSION"));
                         }
+                        // EMXIF
+
                     }
-                    if (rubyClass == null) {
+                    if (rubyClass == null || !hasBackingJavaClass) {
                         System.out.println("Loading script: " + component.getScriptInfo().getScriptName());
-                        if (script.matches("(?s).*class " + component.getScriptInfo().getRubyClassName() + ".*")) {
+                        if (scriptContainsClass) {
                             System.out.println("Script contains class definition");
-                            if (component.getScriptInfo().getRubyClassName().equals(component.getClass().getSimpleName())) {
+                            if (rubyClass == null && hasBackingJavaClass) {
                                 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()));
+                                // EMXIF
+
+                                rubyClass = JRubyAdapter.runScriptlet("Java::" + component.getClass().getName());
                             }
-                            System.out.println("Set class: " + JRubyAdapter.get(component.getScriptInfo().getRubyClassName()));
+                            System.out.println("Set class: " + rubyClass);
+                            JRubyAdapter.put(component.getScriptInfo().getRubyClassName(), rubyClass);
                             Thread t = new Thread(new Runnable(){
                                 public void run() {
                                     JRubyAdapter.setScriptFilename(rubyScript.getAbsolutePath());
@@ -72,17 +81,11 @@ public class ScriptLoader {
                                 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(rubyScript.getAbsolutePath());
-                            JRubyAdapter.runScriptlet(script);
+                            throw new RuntimeException("Expected file "
+                                    + component.getScriptInfo().getScriptName()
+                                    + " to define class "
+                                    + component.getScriptInfo().getRubyClassName());
                         }
                     }
                 } else if (rubyClass != null) {
@@ -98,23 +101,8 @@ public class ScriptLoader {
                     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();

data/assets/src/ruboto/activity.rb

@@ -5,34 +5,21 @@ require 'ruboto/package'
 #
 # ruboto/activity.rb
 #
-# Basic activity set up and callback configuration.
+# Basic activity set up.
 #
 #######################################################
 
 #
 # Context
 #
-
 module Ruboto
   module Context
-    def initialize_ruboto()
-      eval("#{$new_context_global} = self")
-      $new_context_global = nil
-
-      instance_eval &$context_init_block if $context_init_block
-      $context_init_block = nil
-      setup_ruboto_callbacks 
-
-      @initialized = true
-      self
-    end
-  
     def start_ruboto_dialog(remote_variable, theme=Java::android.R.style::Theme_Dialog, &block)
-      ruboto_import "org.ruboto.RubotoDialog"
+      java_import "org.ruboto.RubotoDialog"
       start_ruboto_activity(remote_variable, RubotoDialog, theme, &block)
     end
-  
-    def start_ruboto_activity(global_variable_name = '$activity', klass=RubotoActivity, theme=nil, options = nil, &block)
+
+    def start_ruboto_activity(global_variable_name = '$block_based_activity', klass=RubotoActivity, theme=nil, options = nil, &block)
       # FIXME(uwe): Translate old positional signature to new options-based signature.
       # FIXME(uwe): Remove when we stop supporting Ruboto 0.8.0 or older.
       if options.nil?
@@ -44,31 +31,19 @@ module Ruboto
         global_variable_name = nil
       end
 
-      # FIXME(uwe): Used for block-based definition of main activity.
-      # FIXME(uwe): Remove when we stop supporting Ruboto 0.8.0 or older.
-      puts "start_ruboto_activity self: #{self.inspect}"
-      if @ruboto_java_class and not @ruboto_java_class_initialized
-        @ruboto_java_class_initialized = true
-        puts "Block based main activity definition"
-        instance_eval &block if block
-        setup_ruboto_callbacks
-        on_create nil
+      class_name = options[:class_name] || "#{klass.name.split('::').last}_#{source_descriptor(block)[0].split("/").last.gsub(/[.-]+/, '_')}_#{source_descriptor(block)[1]}"
+      if !Object.const_defined?(class_name)
+        Object.const_set(class_name, Class.new(&block))
       else
-        puts "Class based main activity definition"
-        class_name = options[:class_name] || "#{klass.name.split('::').last}_#{source_descriptor(block)[0].split("/").last.gsub(/[.]+/, '_')}_#{source_descriptor(block)[1]}"
-        if !Object.const_defined?(class_name)
-          Object.const_set(class_name, Class.new(&block))
-        else
-          Object.const_get(class_name).class_eval(&block)
-        end
-        b = Java::android.os.Bundle.new
-        b.putInt("Theme", theme) if theme
-        b.putString("ClassName", class_name)
-        i = android.content.Intent.new
-        i.setClass self, klass.java_class
-        i.putExtra("RubotoActivity Config", b)
-        startActivity i
+        Object.const_get(class_name).class_eval(&block) if block_given?
       end
+      b = Java::android.os.Bundle.new
+      b.putInt("Theme", theme) if theme
+      b.putString("ClassName", class_name)
+      i = android.content.Intent.new
+      i.setClass self, klass.java_class
+      i.putExtra("RubotoActivity Config", b)
+      startActivity i
       self
     end
 
@@ -110,6 +85,6 @@ def ruboto_configure_activity(klass)
 end
 
 java_import "android.app.Activity"
-ruboto_import "org.ruboto.RubotoActivity"
+java_import "org.ruboto.RubotoActivity"
 ruboto_configure_activity(RubotoActivity)
 

data/assets/src/ruboto/base.rb

@@ -6,15 +6,6 @@
 #
 #######################################################
 
-# Only used needed for ruboto-core apps
-require 'ruboto/version'
-$RUBOTO_VERSION = 10
-
-def confirm_ruboto_version(required_version, exact=true)
-  raise "requires $RUBOTO_VERSION=#{required_version} or greater, current version #{$RUBOTO_VERSION}" if $RUBOTO_VERSION < required_version and not exact
-  raise "requires $RUBOTO_VERSION=#{required_version}, current version #{$RUBOTO_VERSION}" if $RUBOTO_VERSION != required_version and exact
-end
-
 require 'java'
 
 # Create convenience method for top-level android package so we do not need to prefix with 'Java::'.
@@ -32,64 +23,3 @@ end
 
 java_import "android.R"
 AndroidIds = JavaUtilities.get_proxy_class("android.R$id")
-
-#
-# Callbacks
-#
-
-module Ruboto
-  module CallbackClass
-    def new_with_callbacks(*args, &block)
-      new(*args).initialize_ruboto_callbacks(&block)
-    end
-  end
-    
-  module Callbacks
-    def initialize_ruboto_callbacks &block
-      instance_eval &block
-      setup_ruboto_callbacks
-      self
-    end
-    
-    def ruboto_callback_methods
-      # FIXME(uwe): Remove to_sym conversion when we stop supporting Ruby 1.8 mode
-      (singleton_methods - ["on_create", "on_receive"]).select{|i| self.class.constants.map(&:to_sym).include?(i.to_s.sub(/^on_/, "CB_").upcase.to_sym) || self.class.constants.map(&:to_sym).include?("CB_#{i}".upcase.to_sym)}
-    end 
-
-    def setup_ruboto_callbacks
-      ruboto_callback_methods.each do |i|
-        begin
-          # FIXME(uwe): Remove to_sym conversion when we stop supporting Ruby 1.8 mode
-          scriptInfo.setCallbackProc((self.class.constants.map(&:to_sym).include?(i.to_s.sub(/^on_/, "CB_").upcase.to_sym) && self.class.const_get(i.to_s.sub(/^on_/, "CB_").upcase)) || (self.class.constants.map(&:to_sym).include?("CB_#{i}".upcase.to_sym) && self.class.const_get("CB_#{i}".upcase)), method(i))
-        rescue
-        end
-      end 
-    end 
-  end
-end
-
-#
-# Import a class and set it up for handlers
-#
-
-def ruboto_import(*package_classes)
-  already_classes = package_classes.select{|i| not i.is_a?(String) and not i.is_a?(Symbol)}
-  imported_classes = package_classes - already_classes
-
-  unless imported_classes.empty?
-    # TODO(uwe): The first part of this "if" is only needed for JRuby 1.6.x.  Simplify when we stop supporting JRuby 1.6.x
-    if imported_classes.size == 1
-      imported_classes = [*(java_import(*imported_classes) || eval("Java::#{imported_classes[0]}"))]
-    else
-      imported_classes = java_import(imported_classes)
-    end
-  end
-
-  (already_classes + imported_classes).each do |package_class|
-    package_class.class_eval do
-      extend Ruboto::CallbackClass
-      include Ruboto::Callbacks
-    end
-  end
-end
-

data/assets/src/ruboto/broadcast_receiver.rb

@@ -2,33 +2,13 @@
 #
 # ruboto/broadcast_receiver.rb
 #
-# Basic broadcast_receiver set up and callback configuration.
+# Basic broadcast_receiver set up.
 #
 #######################################################
 
 require 'ruboto/base'
 
-ruboto_import "org.ruboto.RubotoBroadcastReceiver"
-RubotoBroadcastReceiver.class_eval do
-    def self.new_with_callbacks &block
-      (($broadcast_receiver.nil? || $broadcast_receiver.initialized) ? new : $broadcast_receiver).initialize_ruboto_callbacks &block
-    end
-
-    def initialized
-      @initialized ||= false
-    end
-
-    def initialize_ruboto_callbacks &block
-      instance_eval &block
-      setup_ruboto_callbacks
-      @initialized = true
-      self
-    end
-
-    def on_receive(context, intent)
-    end
-end
-
+java_import "org.ruboto.RubotoBroadcastReceiver"
 module Ruboto
   module BroadcastReceiver
   end

data/assets/src/ruboto/package.rb

@@ -1,4 +1,3 @@
-$package_name = ($activity || $service).package_name
 $package      = eval("Java::#{$package_name}")
 
 module Ruboto

data/assets/src/ruboto/preference.rb

@@ -10,14 +10,16 @@ require 'ruboto/activity'
 
 java_import "android.preference.PreferenceScreen"
 java_import "android.preference.Preference"
-ruboto_import "org.ruboto.RubotoPreferenceActivity"
+java_import "org.ruboto.RubotoPreferenceActivity"
 ruboto_configure_activity(RubotoPreferenceActivity)
 
 RubotoPreferenceActivity.class_eval do
     def preference_screen(params={})
       rv = self.getPreferenceManager.createPreferenceScreen(self)
+      parent = params.delete(:parent) || @parent
       rv.configure self, params
-      @parent.addPreference(rv) if @parent
+      parent.addPreference(rv) if parent
+
       if block_given?
         old_parent, @parent = @parent, rv
         yield
@@ -54,8 +56,10 @@ def ruboto_import_preference(class_name, package_name="android.preference")
   RubotoPreferenceActivity.class_eval "
      def #{(class_name.to_s.gsub(/([A-Z])/) { '_' + $1.downcase })[1..-1]}(params={})
         rv = #{class_name}.new self
+        parent = params.delete(:parent) || @parent
         rv.configure self, params
-        @parent.addPreference(rv) if @parent
+        parent.addPreference(rv) if parent
+      
         if block_given?
           old_parent, @parent = @parent, rv
           yield

data/assets/src/ruboto/service.rb

@@ -5,71 +5,34 @@ require 'ruboto/package'
 #
 # ruboto/service.rb
 #
-# Basic service set up and callback configuration.
+# Basic service set up.
 #
 #######################################################
 
-#
-# Context
-#
+java_import "android.content.Context"
+java_import "org.ruboto.RubotoService"
 
 module Ruboto
   module Context
-    def initialize_ruboto()
-      eval("#{$new_context_global} = self")
-      $new_context_global = nil
-
-      instance_eval &$context_init_block if $context_init_block
-      $context_init_block = nil
-      setup_ruboto_callbacks 
-
-      @initialized = true
-      self
-    end
-  
     def start_ruboto_service(global_variable_name = '$service', klass=RubotoService, &block)
-      $context_init_block = block
-      $new_context_global = global_variable_name
-  
-      if @initialized or (self == $service) or ($service == nil) # FIx mix between activity and service
-        self.startService Java::android.content.Intent.new(self, klass.java_class)
+      class_name = options[:class_name] || "#{klass.name.split('::').last}_#{source_descriptor(block)[0].split("/").last.gsub(/[.-]+/, '_')}_#{source_descriptor(block)[1]}"
+      if !Object.const_defined?(class_name)
+        Object.const_set(class_name, Class.new(&block))
       else
-        initialize_ruboto
-        on_create
+        Object.const_get(class_name).class_eval(&block) if block_given?
       end
-  
+      b = Java::android.os.Bundle.new
+      b.putInt("Theme", theme) if theme
+      b.putString("ClassName", class_name)
+      i = android.content.Intent.new
+      i.setClass self, klass.java_class
+      i.putExtra("RubotoActivity Config", b)
+      self.startService Java::android.content.Intent.new(self, klass.java_class)
       self
     end
   end
 end
 
-java_import "android.content.Context"
 Context.class_eval do
   include Ruboto::Context
 end
-
-#
-# Leave for legacy Service Subclass Setup
-#
-
-module Ruboto
-  module Service
-  end
-end
-
-#
-# Basic Service Setup
-#
-
-def ruboto_configure_service(klass)
-  klass.class_eval do
-    include Ruboto::Service
-    
-    def on_create
-    end
-  end
-end
-
-ruboto_import "org.ruboto.RubotoService"
-ruboto_configure_service(RubotoService)
-