ruboto-core 0.0.3 → 0.1.0

data/lib/ruboto/util/xml_element.rb

@@ -0,0 +1,197 @@
+require 'ruboto/util/code_formatting'
+require 'ruboto/util/verify'
+require 'ruboto/api'
+
+module Ruboto
+  module Util
+    ###########################################################################
+    #
+    # XMLElement:
+    #   Extends Hash to simulate a REXML::Element (but much faster) and provides
+    #   information in the necessary format to generate Java code.
+    #
+    class XMLElement < Hash
+      include Ruboto::Util::CodeFormatting
+      include Ruboto::Util::Verify
+
+      def root
+        Ruboto::API.api
+      end
+
+      def name
+        self["name"]
+      end
+
+      def attribute(name)
+        self["values"][name]
+      end
+
+      def add_element(name, attributes)
+        new_element = XMLElement.new
+        new_element["name"] = name
+        new_element["values"] = attributes
+
+        self[name] = [] unless self[name]
+        self[name] << new_element
+
+        new_element
+      end
+
+      def get_elements(name)
+        self[name] or []
+      end
+
+      def find_class_or_interface(klass, a_type)
+        abort "ERROR: Can't parse package from #{klass}" unless klass.match(/([a-z.]+)\.([A-Z][A-Za-z.]+)/)
+
+        package = self["package"].find{|i| i.attribute("name") == $1}
+        abort "ERROR: Can't find package #{$1}" unless package
+        if a_type == "either"
+          package["class"].find{|i| i.attribute("name") == $2} or package["interface"].find{|i| i.attribute("name") == $2}
+        else
+          package[a_type].find{|i| i.attribute("name") == $2}
+        end
+      end
+
+      def find_class(package_and_class)
+        find_class_or_interface(package_and_class, "class")
+      end
+
+      def find_interface(package_and_interface)
+        find_class_or_interface(package_and_interface, "interface")
+      end
+
+      def all_methods(method_base="all", method_include="", method_exclude="", implements="")
+        # get all the methogs
+        all_methods = get_elements("method")
+
+        # establish the base set of methods
+        working_methods = case method_base
+        when "all" then
+          all_methods
+        when "none" then
+          []
+        when "abstract" then
+          all_methods.select{|i| i.attribute("abstract") == "true"}
+        when "on" then
+          all_methods.select{|i| i.attribute("name").match(/^on[A-Z]/)}
+        end
+
+        # make sure to include requested methods
+        include_methods = method_include.split(",") if method_include.is_a?(String)
+        all_methods.each{|i| working_methods << i if include_methods.include?(i.attribute("name"))}
+
+        # make sure to exclude rejected methods
+        exclude_methods = method_exclude.split(",") if method_exclude.is_a?(String)
+        working_methods = working_methods.select{|i| not exclude_methods.include?(i.attribute("name"))}
+
+        # remove methods marked final
+        working_methods = working_methods.select{|i| (not i.attribute("final")) or i.attribute("final") == "false"}
+
+        # get additional methods from parent
+        if name =="class" and attribute("extends")
+          parent = root.find_class(attribute("extends"))
+          parent_methods = parent.all_methods(method_base, method_include, method_exclude)
+          working_signatures = working_methods.map(&:method_signature)
+          working_methods += parent_methods.select{|i| not working_signatures.include?(i.method_signature)}
+        end
+
+        # get additional methods from interfaces
+        if name =="class" and implements != ""
+          implements.split(",").each do |i|
+            interface = root.find_interface(i)
+            abort("Unkown interface: #{i}") unless interface
+            working_signatures = working_methods.map(&:method_signature)
+            working_methods += interface.all_methods.select{|j| not working_signatures.include?(j.method_signature)}
+          end
+        end
+
+        working_methods
+      end
+
+      def parameters
+        get_elements("parameter").map {|p| [p.attribute("name"), p.attribute("type").gsub("&lt;", "<").gsub("&gt;", ">")]}
+      end
+
+      def method_signature
+        "#{attribute("name")}(#{parameters.map{|i| i[1]}.join(',')})"
+      end
+
+      def constant_string
+        "CB_" + attribute("name").gsub(/[A-Z]/) {|i| "_#{i}"}.upcase.gsub(/^ON_/, "")
+      end
+
+      def super_string
+        if attribute("api_added") and
+          attribute("api_added").to_i > verify_min_sdk.to_i and
+          attribute("api_added").to_i <= verify_target_sdk.to_i
+          nil
+        elsif attribute("abstract") == "true"
+          nil
+        elsif name == "method"
+          "super.#{attribute("name")}(#{parameters.map{|i| i[0]}.join(", ")});"
+        elsif name == "constructor"
+          "super(#{parameters.map{|i| i[0]}.join(", ")});"
+        end
+      end
+
+      def default_return
+        return nil unless attribute("return")
+        case attribute("return")
+        when "boolean" then "return false;"
+        when "int"     then "return 0;"
+        when "void"    then nil
+        else                "return null;"
+        end
+      end
+
+      def super_return
+        rv = super_string
+        return rv unless attribute("return")
+        rv ? "return #{rv}" : default_return
+      end
+
+      def ruby_call
+        rv = []
+
+        params = parameters
+        args = ""
+        if params.size > 3
+          args = ", args"
+          rv << "IRubyObject[] args = {" + params.map{|i| "JavaUtil.convertJavaToRuby(getRuby(), #{i[0]})"}.join(", ") + "};"
+        elsif params.size > 0
+          args = ", " + params.map{|i| "JavaUtil.convertJavaToRuby(getRuby(), #{i[0]})"}.join(", ")
+        end
+
+        return_cast = ""
+        if attribute("return") and (attribute("return").include?(".") or attribute("return") == "int[]")
+          return_cast = "return (#{attribute("return")})"
+        elsif attribute("return") and attribute("return") == "int"
+          return_cast = "return (Integer)"
+        elsif attribute("return") and attribute("return") != "void"
+          return_cast = "return (#{attribute("return").capitalize})"
+        end
+        return_cast = return_cast.gsub("&lt;", "<").gsub("&gt;", ">")
+
+        convert_return = ""
+        if attribute("return") and attribute("return") != "void"
+          convert_return = ".toJava(#{attribute("return")}.class)"
+        end
+
+        rv << "#{return_cast}RuntimeHelpers.invoke(getRuby().getCurrentContext(), callbackProcs[#{constant_string}], \"call\" #{args})#{convert_return};"
+        rv
+      end
+
+      def method_definition
+        method_call((attribute("return") ? attribute("return") : "void"), attribute("name"), parameters,
+        if_else("callbackProcs[#{constant_string}] != null",
+        [super_string] + try_catch(ruby_call, ["re.printStackTrace();", default_return]),
+        [super_return])).indent.join("\n")
+      end
+
+      def constructor_definition(class_name)
+        method_call("", class_name, parameters, [super_string]).indent.join("\n")
+      end
+    end
+  end
+end

data/test/app_test.rb

@@ -0,0 +1,44 @@
+require File.expand_path("test_helper", File.dirname(__FILE__))
+require 'fileutils'
+
+class AppTest < Test::Unit::TestCase
+  PACKAGE ='org.ruboto.sample_app'
+  APP_NAME = 'RubotoSampleApp'
+  TMP_DIR = File.join PROJECT_DIR, 'tmp'
+  APP_DIR = File.join PROJECT_DIR, 'tmp', APP_NAME
+
+  def setup
+    Dir.mkdir TMP_DIR unless File.exists? TMP_DIR
+    FileUtils.rm_rf APP_DIR if File.exists? APP_DIR
+    system "jruby -rubygems -I #{PROJECT_DIR}/lib #{PROJECT_DIR}/bin/ruboto gen app --package #{PACKAGE} --path #{APP_DIR} --name #{APP_NAME} --target android-8 --min_sdk android-8 --activity #{APP_NAME}Activity"
+    raise "gen app failed with return code #$?" unless $? == 0
+  end
+
+  def teardown
+    # FileUtils.rm_rf APP_DIR if File.exists? APP_DIR
+  end
+
+  def test_that_tests_work_on_new_project
+    run_app_tests
+  end
+
+  def test_that_yaml_loads
+    filename = "#{APP_DIR}/assets/scripts/ruboto_sample_app_activity.rb"
+    s = File.read(filename)
+    s.gsub!(/(require 'ruboto.rb')/, "\\1\nrequire 'yaml'")
+    File.open(filename, 'w'){|f| f << s}
+    run_app_tests
+  end
+
+  private
+
+  def run_app_tests
+    Dir.chdir "#{APP_DIR}/test" do
+      system "adb uninstall #{PACKAGE}"
+      system 'ant run-tests'
+      raise "tests failed with return code #$?" unless $? == 0
+      system "adb uninstall #{PACKAGE}"
+    end
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require "test/unit"
+
+PROJECT_DIR = File.expand_path('..', File.dirname(__FILE__))
+$LOAD_PATH << PROJECT_DIR

metadata

@@ -1,23 +1,24 @@
 --- !ruby/object:Gem::Specification 
 name: ruboto-core
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 27
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 3
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors: 
 - Daniel Jackoway
 - Charles Nutter
 - Scott Moyer
+- Uwe Kubosch
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-12-19 00:00:00 -05:00
+date: 2011-03-24 00:00:00 -07:00
 default_executable: ruboto
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -42,7 +43,7 @@ dependencies:
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ~>
+    - - ">"
       - !ruby/object:Gem::Version 
         hash: 3
         segments: 
@@ -62,27 +63,53 @@ extra_rdoc_files: []
 
 files: 
 - COPYING
+- Rakefile
 - Gemfile
 - Gemfile.lock
-- Rakefile
 - README.md
-- assets/assets/scripts/ruboto.rb
-- assets/Rakefile
-- assets/samples/sample_activity.rb
+- assets/test/assets/scripts/test_helper.rb
+- assets/samples/sample_activity_test.rb
+- assets/samples/sample_service_test.rb
+- assets/samples/sample_broadcast_receiver_test.rb
 - assets/samples/sample_broadcast_receiver.rb
 - assets/samples/sample_service.rb
-- assets/src/InheritingActivity.java
+- assets/samples/sample_activity.rb
+- assets/Rakefile
+- assets/res/drawable-ldpi/icon.png
+- assets/res/drawable-hdpi/icon.png
+- assets/res/drawable-mdpi/icon.png
+- assets/assets/scripts/ruboto.rb
+- assets/src/RubotoBroadcastReceiver.java
 - assets/src/InheritingBroadcastReceiver.java
+- assets/src/RubotoService.java
 - assets/src/InheritingClass.java
+- assets/src/RubotoActivity.java
 - assets/src/InheritingService.java
-- assets/src/org/ruboto/RubotoDialog.java
+- assets/src/org/ruboto/test/InstrumentationTestRunner.java
+- assets/src/org/ruboto/test/ActivityTest.java
 - assets/src/org/ruboto/Script.java
-- assets/src/RubotoActivity.java
-- assets/src/RubotoBroadcastReceiver.java
-- assets/src/RubotoService.java
+- assets/src/org/ruboto/RubotoDialog.java
+- assets/src/InheritingActivity.java
 - bin/ruboto
+- lib/ruboto.rb
 - lib/java_class_gen/android_api.xml
 - lib/java_class_gen/InheritingClass.java.erb
+- lib/ruboto/api.rb
+- lib/ruboto/core_ext/array.rb
+- lib/ruboto/core_ext/object.rb
+- lib/ruboto/util/xml_element.rb
+- lib/ruboto/util/main_fix.rb
+- lib/ruboto/util/scan_in_api.rb
+- lib/ruboto/util/build.rb
+- lib/ruboto/util/update.rb
+- lib/ruboto/util/log_action.rb
+- lib/ruboto/util/code_formatting.rb
+- lib/ruboto/util/objectspace.rb
+- lib/ruboto/util/verify.rb
+- lib/ruboto/util/asset_copier.rb
+- lib/ruboto/commands/base.rb
+- test/app_test.rb
+- test/test_helper.rb
 has_rdoc: true
 homepage: http://ruboto.org/
 licenses: []