ruboto 0.8.1 → 0.9.0.rc.0

data/Rakefile

@@ -142,6 +142,80 @@ task :release_docs do
   puts "* https://github.com/ruboto/ruboto/issues?state=closed&milestone=#{milestone}\n\n"
 end
 
+desc 'Fetch download stats form rubygems.org'
+task :stats do
+  require 'rubygems'
+  require 'uri'
+  require 'net/http'
+  require 'net/https'
+  require 'openssl'
+  require 'yaml'
+  host = 'rubygems.org'
+  base_uri = "https://#{host}/api/v1"
+  https = Net::HTTP.new(host, 443)
+  https.use_ssl = true
+  https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+  counts_per_month = Hash.new{|h, k| h[k] = Hash.new{|mh,mk| mh[mk] = 0 }}
+  total = 0
+
+  %w{ruboto-core ruboto}.each do |gem|
+    versions_uri = URI("#{base_uri}/versions/#{gem}.yaml")
+    req = Net::HTTP::Get.new(versions_uri.request_uri)
+    res = https.start { |http| http.request(req) }
+    versions = YAML.load(res.body).sort_by { |v| Gem::Version.new(v['number']) }
+    puts "\n#{gem}:\n#{versions.map { |v| "#{'%10s' % v['number']} #{v['downloads_count']}" }.join("\n")}"
+
+    versions.each do |v|
+      downloads_uri = URI("#{base_uri}/versions/#{gem}-#{v['number']}/downloads/search.yaml?from=2010-08-01&to=#{Date.today}")
+      req = Net::HTTP::Get.new(downloads_uri.request_uri)
+      res = https.start { |http| http.request(req) }
+      counts = YAML.load(res.body)
+      counts.each do |date_str, count|
+        date = Date.parse(date_str)
+        counts_per_month[date.year][date.month] += count
+        total += count
+      end
+      print '.' ; STDOUT.flush
+    end
+    puts
+  end
+
+  puts "\nDownloads statistics per month:"
+  years = counts_per_month.keys
+  puts "\n    #{years.map{|year| '%6s:' % year}.join(' ')}"
+  (1..12).each do |month|
+    print "#{'%2d' % month}:"
+    years.each do |year|
+      count = counts_per_month[year][month]
+      print count > 0 ? '%8d' % count : ' ' * 8
+    end
+    puts
+  end
+
+  puts "\nTotal: #{total}\n\n"
+
+  puts "\nRubyGems download statistics per month:"
+  years = counts_per_month.keys
+  puts '    ' + years.map{|year| '%-12s' % year}.join
+  (0..20).each do |l|
+    print (l % 10 == 0) ? '%4d' % ((20-l) * 100) : '    '
+    years.each do |year|
+      (1..12).each do |month|
+        count = counts_per_month[year][month]
+        if [year, month] == [Date.today.year, Date.today.month]
+          count *= (Date.new(Date.today.year, Date.today.month, -1).day.to_f / Date.today.day).to_i
+        end
+        print count > ((20-l) * 100) ? '*' : ' '
+      end
+    end
+    puts
+  end
+  puts '    ' + years.map{|year| '%-12s' % year}.join
+
+  puts "\nTotal: #{total}\n\n"
+end
+
 desc "Push the gem to RubyGems"
 task :release => [:clean, :gem] do
   output = `git status --porcelain`
@@ -180,7 +254,7 @@ namespace :platform do
     Dir.chdir(PLATFORM_PROJECT) do
       manifest = REXML::Document.new(File.read(MANIFEST_FILE))
       manifest.root.attributes['android:versionCode'] = '408'
-      manifest.root.attributes['android:versionName'] = '0.4.8.dev'
+      manifest.root.attributes['android:versionName'] = '0.4.8'
       manifest.root.attributes['android:installLocation'] = 'auto' # or 'preferExternal' ?
       File.open(MANIFEST_FILE, 'w') { |f| manifest.document.write(f, 4) }
       File.open('Gemfile.apk', 'w'){|f| f << "source :rubygems\n\ngem 'activerecord-jdbc-adapter'\n"}

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

@@ -238,7 +238,8 @@ public class JRubyAdapter {
             // END Ruboto HeapAlloc
             setDebugBuild(appContext);
             Log.d("Setting up JRuby runtime (" + (isDebugBuild ? "DEBUG" : "RELEASE") + ")");
-            System.setProperty("jruby.compile.mode", "OFF"); // OFF OFFIR
+            System.setProperty("jruby.compile.mode", "OFF"); // OFF OFFIR JITIR? FORCEIR
+            // System.setProperty("jruby.compile.backend", "DALVIK");
             System.setProperty("jruby.bytecode.version", "1.6");
             System.setProperty("jruby.interfaces.useProxy", "true");
             System.setProperty("jruby.management.enabled", "false");
@@ -253,6 +254,10 @@ public class JRubyAdapter {
             // System.setProperty("jruby.debug.loadService", "true");
             // System.setProperty("jruby.debug.loadService.timing", "true");
 
+            // Used to enable JRuby to generate proxy classes
+            System.setProperty("jruby.ji.proxyClassFactory", "org.ruboto.DalvikProxyClassFactory");
+            System.setProperty("jruby.class.cache.path", appContext.getDir("dex", 0).getAbsolutePath());
+
             ClassLoader classLoader;
             Class<?> scriptingContainerClass;
             String apkName = null;

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

@@ -40,9 +40,9 @@ public class Script {
     public static String toSnakeCase(String s) {
         return s.replaceAll(
             String.format("%s|%s|%s",
-                "(?<=[A-Z])(?=[A-Z][a-z])",
+                "(?<=[A-Z])(?=[A-Z][a-z0-9])",
                 "(?<=[^A-Z])(?=[A-Z])",
-                "(?<=[A-Za-z])(?=[^A-Za-z])"
+                "(?<=[A-Za-z0-9])(?=[^A-Za-z0-9])"
             ),
             "_"
         ).replace("__", "_").toLowerCase();

data/lib/DalvikProxyClassFactory.java

@@ -0,0 +1,107 @@
+package org.ruboto;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.UndeclaredThrowableException;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.security.ProtectionDomain;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.jar.Attributes;
+import java.util.jar.JarEntry;
+import java.util.jar.JarOutputStream;
+import java.util.jar.Manifest;
+
+import com.android.dx.Version;
+import com.headius.android.dex.DexClient;
+
+import dalvik.system.DexClassLoader;
+
+public class DalvikProxyClassFactory extends org.jruby.javasupport.proxy.JavaProxyClassFactory {
+    private static final String DEX_IN_JAR_NAME = "classes.dex";
+    private static final Attributes.Name CREATED_BY = new Attributes.Name("Created-By");
+
+    public Class invokeDefineClass(ClassLoader loader, String className, byte[] data) {
+        String cachePath = System.getProperty("jruby.class.cache.path");
+        if (cachePath != null) {
+            byte[] dalvikByteCode = new DexClient().classesToDex(
+                    new String[] { className.replace('.', '/') + ".class" }, new byte[][] { data });
+            String jarFileName = cachePath + "/" + className.replace('.', '/') + ".jar";
+            createJar(jarFileName, dalvikByteCode);
+            try {
+                return new DexClassLoader(jarFileName, cachePath, null, loader)
+                        .loadClass(className);
+            } catch (ClassNotFoundException e1) {
+                System.out.println("Exception loading class with DexClassLoader: " + e1);
+                e1.printStackTrace();
+            }
+        }
+        return null;
+    }
+
+    private static boolean createJar(String fileName, byte[] dexArray) {
+        File parentFile = new File(fileName).getParentFile();
+        if (!parentFile.exists()) {
+            System.out.println("Creating directory: " + parentFile);
+            parentFile.mkdirs();
+        }
+        try {
+            TreeMap<String, byte[]> outputResources = new TreeMap<String, byte[]>();
+            Manifest manifest = makeManifest();
+            OutputStream out = (fileName.equals("-") || fileName.startsWith("-.")) ? System.out
+                    : new FileOutputStream(fileName);
+            JarOutputStream jarOut = new JarOutputStream(out, manifest);
+            outputResources.put(DEX_IN_JAR_NAME, dexArray);
+            try {
+                for (Map.Entry<String, byte[]> e : outputResources.entrySet()) {
+                    String name = e.getKey();
+                    byte[] contents = e.getValue();
+                    JarEntry entry = new JarEntry(name);
+                    entry.setSize(contents.length);
+                    jarOut.putNextEntry(entry);
+                    jarOut.write(contents);
+                    jarOut.closeEntry();
+                }
+            } finally {
+                jarOut.finish();
+                jarOut.flush();
+                if (out != null) {
+                    out.flush();
+                    if (out != System.out) {
+                        out.close();
+                    }
+                }
+                jarOut.close();
+            }
+        } catch (Exception ex) {
+            System.out.println("Exception writing jar: " + fileName);
+            System.out.println("Exception writing jar: " + ex);
+            ex.printStackTrace();
+            return false;
+        }
+        return true;
+    }
+    
+    private static Manifest makeManifest() throws IOException {
+        Manifest manifest = new Manifest();
+        Attributes attribs = manifest.getMainAttributes();
+        attribs.put(Attributes.Name.MANIFEST_VERSION, "1.0");
+        attribs.put(CREATED_BY, "dx " + Version.VERSION);
+        attribs.putValue("Dex-Location", DEX_IN_JAR_NAME);
+        return manifest;
+    }
+
+}

data/lib/DexClient.java

@@ -0,0 +1,85 @@
+package com.headius.android.dex;
+
+import java.io.ByteArrayOutputStream;
+import java.io.OutputStreamWriter;
+
+import com.android.dx.cf.iface.ParseException;
+import com.android.dx.dex.cf.CfOptions;
+import com.android.dx.dex.cf.CfTranslator;
+import com.android.dx.dex.code.PositionList;
+import com.android.dx.dex.file.ClassDefItem;
+import com.android.dx.dex.file.DexFile;
+
+public class DexClient {
+    /** {@code non-null;} output file in-progress */
+    private static DexFile outputDex;
+
+    private final CfOptions cfOptions;
+
+    public DexClient() {
+        outputDex = new DexFile();
+        cfOptions = new CfOptions();
+
+        cfOptions.positionInfo = PositionList.LINES;
+        cfOptions.localInfo = true;
+        cfOptions.strictNameCheck = true;
+        cfOptions.optimize = false;
+        cfOptions.optimizeListFile = null;
+        cfOptions.dontOptimizeListFile = null;
+        cfOptions.statistics = false;
+    }
+
+    public byte[] classesToDex(String[] names, byte[][] byteArrays) {
+      for (int i = 0; i < names.length; i++) {
+        String name = names[i];
+        byte[] byteArray = byteArrays[i];
+        processClass(name, byteArray);
+      }
+
+      byte[] outputArray = writeDex();
+
+      return outputArray;
+    }
+
+    /**
+     * Processes one classfile.
+     *
+     * @param name {@code non-null;} name of the file, clipped such that it
+     * <i>should</i> correspond to the name of the class it contains
+     * @param bytes {@code non-null;} contents of the file
+     * @return whether processing was successful
+     */
+    private boolean processClass(String name, byte[] bytes) {
+        try {
+            ClassDefItem clazz =
+                CfTranslator.translate(name, bytes, cfOptions);
+            outputDex.add(clazz);
+            return true;
+        } catch (ParseException ex) {
+          ex.printStackTrace();
+        }
+
+        return false;
+    }
+
+    /**
+     * Converts {@link #outputDex} into a {@code byte[]}, write
+     * it out to the proper file (if any), and also do whatever human-oriented
+     * dumping is required.
+     *
+     * @return {@code null-ok;} the converted {@code byte[]} or {@code null}
+     * if there was a problem
+     */
+    private byte[] writeDex() {
+        byte[] outArray = null;
+
+        OutputStreamWriter out = new OutputStreamWriter(new ByteArrayOutputStream());
+        try {
+            outArray = outputDex.toDex(out, false);
+        } catch (Exception ex) {
+          ex.printStackTrace();
+        }
+
+        return outArray;
+    }
+}

data/lib/ruboto/commands/base.rb

@@ -97,7 +97,7 @@ module Ruboto
                   update_icons true
                   update_classes nil, true
                   update_jruby true if params['with-jruby'].value
-                  update_dexmaker true unless params['with-jruby'].value
+                  update_dx_jar true unless params['with-jruby'].value
                   update_core_classes "exclude"
 
                   log_action("Generating the default Activity and script") do
@@ -358,7 +358,7 @@ module Ruboto
                 update_assets
                 update_ruboto force
                 update_classes old_version, force
-                update_dexmaker force
+                update_dx_jar force
                 update_jruby force
                 update_manifest nil, nil, force
                 update_icons force

data/lib/ruboto/util/update.rb

@@ -14,21 +14,9 @@ module Ruboto
       def update_android
         root = Dir.getwd
         build_xml_file = "#{root}/build.xml"
-        new_prop_file = "#{root}/project.properties"
-        old_prop_file = "#{root}/default.properties"
         name = REXML::Document.new(File.read(build_xml_file)).root.attributes['name']
 
-        # FIXME(uwe): Remove build.xml file to force regeneration.
-        # FIXME(uwe): Needed when updating apps from Android SDK <= 13 to 14
-        # FIXME(uwe): Remove when we stop supporting upgrading apps from Android SDK <= 13
-        if File.read(build_xml_file) !~ /<!-- version-tag: 1 -->/
-          puts "Forcing generation of new build.xml since upgrading a project generated with Android SDK 13 or older."
-          FileUtils.rm_f build_xml_file
-        end
-        # EMXIF
-
-        # FIXME(uwe):  Simplify when we stop supporting upgrading apps from Android SDK <= 13
-        prop_file = File.exists?(new_prop_file) ? new_prop_file : old_prop_file
+        prop_file = "#{root}/project.properties"
         version_regexp = /^(target=android-)(\d+)$/
         if (project_property_file = File.read(prop_file)) =~ version_regexp
           if $2.to_i < MINIMUM_SUPPORTED_SDK_LEVEL
@@ -36,9 +24,8 @@ module Ruboto
             File.open(prop_file, 'w') { |f| f << project_property_file.gsub(version_regexp, "\\1#{MINIMUM_SUPPORTED_SDK_LEVEL}") }
           end
         end
-        # EMXIF
 
-        system "android update project -p #{root} -n #{name}"
+        system "android update project -p #{root} -n #{name} --subprojects"
         raise "android update project failed with return code #{$?}" unless $? == 0
       end
 
@@ -51,14 +38,11 @@ module Ruboto
           FileUtils.rm_rf File.join(root, 'test', 'src', verify_package.split('.'))
           puts "Done"
         else
-          # FIXME(uwe): Remove build.xml file to force regeneration.
-          # FIXME(uwe): Needed when updating apps from Android SDK <= 13 to 14
-          FileUtils.rm_f "#{root}/test/build.xml"
-        # EMXIF
-
-          puts "\nUpdating Android test project #{name} in #{root}/test..."
-          system "android update test-project -m #{root} -p #{root}/test"
-          raise "android update test-project failed with return code #{$?}" unless $? == 0
+          test_ant_properties_file = 'test/ant.properties'
+          test_ant_properties = File.read(test_ant_properties_file)
+          if test_ant_properties.gsub!(/^tested.project.dir=.*$/, 'tested.project.dir=../')
+            File.open(test_ant_properties_file, 'w') { |f| f << test_ant_properties }
+          end
         end
 
         Dir.chdir File.join(root, 'test') do
@@ -83,15 +67,12 @@ module Ruboto
           File.open("AndroidManifest.xml", 'w') { |f| test_manifest.document.write(f, 4) }
           instrumentation_property = "test.runner=org.ruboto.test.InstrumentationTestRunner\n"
 
-          # FIXME(uwe): Cleanup when we stop supporting updating apps generated with Android SDK <= 13
-          prop_file = %w{ant.properties build.properties}.find { |f| File.exists?(f) }
+          prop_file = 'ant.properties'
           prop_lines = File.readlines(prop_file)
           File.open(prop_file, 'a') { |f| f << instrumentation_property } unless prop_lines.include?(instrumentation_property)
-          # EMXIF
 
-          ant_setup_line = /^(\s*<\/project>)/
           run_tests_override = <<-EOF
-<!-- BEGIN added by ruboto -->
+<!-- BEGIN added by Ruboto -->
 
     <macrodef name="run-tests-helper">
       <attribute name="emma.enabled" default="false"/>
@@ -132,12 +113,16 @@ module Ruboto
     <target name="run-tests-quick" description="Runs tests with previously installed packages">
       <run-tests-helper />
     </target>
-<!-- END added by ruboto -->
-
+<!-- END added by Ruboto -->
           EOF
           ant_script = File.read('build.xml')
+
+          # FIXME(uwe): Remove when we stop support for updating from Ruboto 0.8.1 and older
           ant_script.gsub!(/\s*<!-- BEGIN added by ruboto(?:-core)? -->.*?<!-- END added by ruboto(?:-core)? -->\s*/m, '')
-          raise "Bad ANT script" unless ant_script.gsub!(ant_setup_line, "#{run_tests_override}\n\n\\1")
+          # EMXIF
+
+          ant_script.gsub!(/\s*<!-- BEGIN added by Ruboto -->.*?<!-- END added by Ruboto -->\s*/m, '')
+          raise "Bad ANT script" unless ant_script.gsub!(/\s*(<\/project>)/, "\n\n#{run_tests_override}\n\n\\1")
           File.open('build.xml', 'w') { |f| f << ant_script }
 
           # FIXME(uwe): Remove when we stop supporting update from Ruboto < 0.5.3
@@ -189,7 +174,7 @@ module Ruboto
 
         # FIXME(uwe):  Try keeping the class count low to enable installation on Android 2.3 devices
         # unless new_jruby_version =~ /^1.7.0/ && verify_target_sdk < 15
-          log_action("Copying dexmaker.jar to libs") { copier.copy 'libs' }
+        log_action("Copying dx.jar to libs") { copier.copy 'libs' }
         # end
 
         reconfigure_jruby_libs(new_jruby_version)
@@ -198,21 +183,21 @@ module Ruboto
         true
       end
 
-      def update_dexmaker(force=nil)
-        jar_file = Dir.glob("libs/dexmaker*.jar")[0]
+      def update_dx_jar(force=nil)
+        jar_file = Dir.glob("libs/dx.jar")[0]
 
-        # FIXME(uwe):  Skip copying dexmaker to apps using RubotoCore when we include dexmaker.jar in RubotoCore
-        # return false if !jar_file && !force
+        # FIXME(uwe):  Skip copying dx.jar to apps using RubotoCore when we include dx.jar in RubotoCore
+        return if !jar_file && !force
 
         copier = AssetCopier.new Ruboto::ASSETS, File.expand_path(".")
-        # FIXME(uwe):  Skip copying dexmaker to apps using RubotoCore when we include dexmaker.jar in RubotoCore
-        # log_action("Removing #{jar_file}") { File.delete *Dir.glob("libs/dexmaker*.jar") } if jar_file
+        # FIXME(uwe):  Skip copying dx.jar to apps using RubotoCore when we include dx.jar in RubotoCore
+        log_action("Removing #{jar_file}") { File.delete jar_file } if jar_file
 
         # FIXME(uwe):  Try keeping the class count low to enable installation on Android 2.3 devices
-        # FIXME(uwe):  Skip copying dexmaker to apps using RubotoCore when we include dexmaker.jar in RubotoCore
-        # if verify_target_sdk < 15
-          log_action("Copying dexmaker.jar to libs") { copier.copy 'libs/dexmaker*.jar' }
-        # end
+        # FIXME(uwe):  Skip copying dx.jar to apps using RubotoCore when we include dx.jar in RubotoCore
+        #if verify_target_sdk < 15
+        #  log_action("Copying dx.jar to libs") { copier.copy 'libs' }
+        #end
         # EMXIF
       end
 
@@ -275,7 +260,7 @@ module Ruboto
               puts "Adding explicit super call in #{script_file}"
               script_content = File.read(script_file)
               script_content.gsub! /^(\s*)(def on_(?:create\(bundle\)|start|resume|pause|destroy)\n)/, "\\1\\2\\1  super\n"
-              File.open(script_file, 'w'){|of| of << script_content}
+              File.open(script_file, 'w') { |of| of << script_content }
             end
             # EMXIF
 
@@ -285,14 +270,14 @@ module Ruboto
             generate_inheriting_file 'Class', subclass_name
             generate_subclass_or_interface(:package => package, :template => 'InheritingClass', :class => class_name,
                                            :name => subclass_name, :method_base => method_base, :force => force)
-          # FIXME(uwe): Remove when we stop updating from Ruboto 0.7.0 and older
+            # FIXME(uwe): Remove when we stop updating from Ruboto 0.7.0 and older
           elsif source_code =~ /^\s*package\s+(\S+?)\s*;.*public\s+class\s+(\S+?)\s+extends\s+(.*?)\s\{.*^\s*private Object\[\] callbackProcs = new Object\[\d+\];/m
             package, subclass_name, class_name = $1, $2, $3
             puts "Regenerating subclass #{package}.#{subclass_name}"
             generate_inheriting_file 'Class', subclass_name
             generate_subclass_or_interface(:package => package, :template => 'InheritingClass', :class => class_name,
                                            :name => subclass_name, :method_base => 'on', :force => force)
-          # EMXIF
+            # EMXIF
           end
         end
       end
@@ -400,7 +385,8 @@ module Ruboto
               if jruby_core_version >= '1.7.0'
                 excluded_core_packages = [
                     'META-INF', 'cext',
-                    'com/headius',
+                    # 'com/headius', included since we are trying to use DexClient
+                    'com/headius/invokebinder',
                     'com/kenai/constantine', 'com/kenai/jffi', 'com/martiansoftware', 'ext', 'java',
                     'jline', 'jni',
                     'jnr/constants/platform/darwin', 'jnr/constants/platform/fake', 'jnr/constants/platform/freebsd',
@@ -468,7 +454,7 @@ module Ruboto
               # FIXME(uwe):  Add a Ruboto.yml config for this if it works
               # Reduces the installation footprint, but also reduces performance and stack usage
               # FIXME(uwe):  Measure the performance change
-              if false && jruby_core_version =~ /^1.7.0/ && Dir.chdir('../..'){verify_target_sdk < 15}
+              if false && jruby_core_version =~ /^1.7.0/ && Dir.chdir('../..') { verify_target_sdk < 15 }
                 invokers = Dir['**/*${INVOKER$*,POPULATOR}.class']
                 log_action("Removing invokers & populators(#{invokers.size})") do
                   FileUtils.rm invokers
@@ -481,6 +467,10 @@ module Ruboto
               #  FileUtils.rm_rf dir
               #end
 
+              # Add our proxy class factory
+              `javac -source 1.6 -target 1.6 -cp .:#{Ruboto::ASSETS}/libs/dx.jar:#{Dir["#{Ruboto::SdkVersions::ANDROID_HOME}/platforms/android-*/android.jar"][0]} -d . #{Ruboto::GEM_ROOT}/lib/*.java`
+              raise "Compile failed" unless $? == 0
+
               `jar -cf ../#{jruby_core} .`
             end
             FileUtils.remove_dir "tmp", true
@@ -515,7 +505,7 @@ module Ruboto
                 else
                   lib_dirs = ['1.8', '1.9', 'shared']
                 end
-                # TODO end
+                # ODOT
 
                 lib_dirs.each do |ld|
                   excluded_stdlibs.each do |d|

data/lib/ruboto/version.rb

@@ -1,4 +1,4 @@
 module Ruboto
-  VERSION = '0.8.1'
+  VERSION = '0.9.0.rc.0'
   UPDATE_VERSION_LIMIT = '0.5.2'
 end

data/test/activity/stack_activity_test.rb

@@ -10,13 +10,14 @@ setup do |activity|
   assert @text_view
 end
 
-# ANDROID: 10, PLATFORM: 0.4.7, JRuby: 1.7.0.dev '28334966' expected, but got '28335067'
+# ANDROID: 10, PLATFORM: 0.4.7,     JRuby: 1.7.0.dev      '28334966'         expected, but got '28335067'
+# ANDROID: 16, PLATFORM: 0.4.8.dev, JRuby: 1.7.0.preview2 '[29, 34, 47, 64]' expected, but got '[28, 33, 47, 64]'
 
 test('stack depth') do |activity|
   os_offset = {
       13 => [1]*4,
       15 => [0, 0, 1, 1],
-      16 => [1]*4,
+      16 => [0, 0, 1, 1],
   }[android.os.Build::VERSION::SDK_INT] || [0, 0, 0, 0]
   if org.ruboto.JRubyAdapter.uses_platform_apk?
     jruby_offset = {
@@ -27,6 +28,7 @@ test('stack depth') do |activity|
     jruby_offset = {
         '1.7.0.dev' => [1, 1, 1, 1],
         '1.7.0.preview2' => [0, 0, -4, -4],
+        '1.7.0.rc1' => [0, 0, -4, -4],
     }[org.jruby.runtime.Constants::VERSION] || [0, 0, 0, 0]
   end
   version_message ="ANDROID: #{android.os.Build::VERSION::SDK_INT}, PLATFORM: #{org.ruboto.JRubyAdapter.uses_platform_apk ? org.ruboto.JRubyAdapter.platform_version_name : 'STANDALONE'}, JRuby: #{org.jruby.runtime.Constants::VERSION}"

data/test/activity/subclass_activity.rb

@@ -0,0 +1,33 @@
+require 'ruboto/activity'
+require 'ruboto/widget'
+
+ruboto_import_widgets :LinearLayout, :ListView, :TextView
+
+class SubclassOfArrayAdapter < Java::AndroidWidget::ArrayAdapter
+  def get_view(position, convert_view, parent)
+    puts "IN get_view!!!"
+    @inflater ||= context.getSystemService(Context::LAYOUT_INFLATER_SERVICE)
+    row = convert_view ? convert_view : @inflater.inflate(mResource, nil)
+    row.findViewById(mFieldId).text = get_item(position)
+    row
+  rescue Exception
+    puts "Exception getting list item view: #$!"
+    puts $!.backtrace.join("\n")
+    convert_view
+  end
+end
+
+class SubclassActivity
+  def on_create(bundle)
+    super
+    setTitle File.basename(__FILE__).chomp('_activity.rb').split('_').map { |s| "#{s[0..0].upcase}#{s[1..-1]}" }.join(' ')
+
+    adapter = SubclassOfArrayAdapter.new(self, android.R.layout.simple_list_item_1 , AndroidIds::text1, ['Record one', 'Record two'])
+
+    self.content_view =
+        linear_layout :orientation => LinearLayout::VERTICAL do
+          @text_view_margins = text_view :text => 'What hath Matz wrought?', :id => 42
+          @list_view = list_view :adapter => adapter, :id => 43
+        end
+  end
+end

data/test/activity/{generate_activity_test.rb → subclass_activity_test.rb}

@@ -1,4 +1,4 @@
-activity Java::org.ruboto.test_app.GenerateActivity
+activity Java::org.ruboto.test_app.SubclassActivity
 
 setup do |activity|
   start = Time.now

data/test/app_test_methods.rb

@@ -39,6 +39,10 @@ module AppTestMethods
   def run_activity_tests(activity_dir)
     Dir[File.expand_path("#{activity_dir}/*_test.rb", File.dirname(__FILE__))].each do |test_src|
       snake_name    = test_src.chomp('_test.rb')
+
+      # FIXME(uwe):  Remove when we stop testing JRuby < 1.7.0.rc1
+      next if snake_name =~ /subclass/ && (RUBOTO_PLATFORM == 'CURRENT' || JRUBY_JARS_VERSION < Gem::Version.new('1.7.0.rc1'))
+
       activity_name = File.basename(snake_name).split('_').map { |s| "#{s[0..0].upcase}#{s[1..-1]}" }.join
       Dir.chdir APP_DIR do
         system "#{RUBOTO_CMD} gen class Activity --name #{activity_name}"

data/test/block_def_activity/stack_activity_test.rb

@@ -21,6 +21,7 @@ test('stack depth') do |activity|
     jruby_offset = {
         '1.7.0.preview1' => [0, -1, -1, -1],
         '1.7.0.preview2' => [0, -1, 0, 0],
+        '1.7.0.rc1' => [0, -1, 0, 0],
     }[org.jruby.runtime.Constants::VERSION] || [0, 0, 0, 0]
   end
   version_message ="ANDROID: #{android.os.Build::VERSION::SDK_INT}, PLATFORM: #{org.ruboto.JRubyAdapter.uses_platform_apk ? org.ruboto.JRubyAdapter.platform_version_name : 'STANDALONE'}, JRuby: #{org.jruby.runtime.Constants::VERSION}"

data/test/handle_activity/stack_activity_test.rb

@@ -27,6 +27,7 @@ test('stack depth') do |activity|
         '1.7.0.dev' => [1, 0, 0, 0],
         '1.7.0.preview1' => [0, -1, -1, -1],
         '1.7.0.preview2' => [0, -1, -1, -1],
+        '1.7.0.rc1' => [0, -1, -1, -1],
     }[org.jruby.runtime.Constants::VERSION] || [0, 0, 0, 0]
   end
   version_message ="ANDROID: #{android.os.Build::VERSION::SDK_INT}, PLATFORM: #{org.ruboto.JRubyAdapter.uses_platform_apk ? org.ruboto.JRubyAdapter.platform_version_name : 'STANDALONE'}, JRuby: #{org.jruby.runtime.Constants::VERSION}"

data/test/minimal_app_test.rb

@@ -13,12 +13,20 @@ if RubotoTest::RUBOTO_PLATFORM == 'STANDALONE'
       cleanup_app
     end
 
+    # APK was larger than 3.2MB: 3.3MB.  JRuby: 1.6.7.2,        ANDROID_TARGET: 10.
+    # APK was larger than 4.4MB: 4.7MB.  JRuby: 1.7.0.preview2, ANDROID_TARGET: 10.
+    # APK was larger than 3.2MB: 3.5MB.  JRuby: 1.6.7,          ANDROID_TARGET: 15.
+    # APK was larger than 4.6MB: 4.9MB.  JRuby: 1.7.0.preview2, ANDROID_TARGET: 15.
+
     def test_minimal_apk_is_less_than_3_mb
       apk_size = BigDecimal(File.size("#{APP_DIR}/bin/RubotoTestApp-debug.apk").to_s) / (1024 * 1024)
       upper_limit = {
-          '1.6.7' => 3.2,
+          '1.6.7' => 3.5,
+          '1.6.7.2' => 3.5,
+          '1.6.8' => 3.5,
           '1.7.0.preview1' => 4.6,
-          '1.7.0.preview2' => 4.6,
+          '1.7.0.preview2' => ANDROID_TARGET < 15 ? 4.7 : 4.9,
+          '1.7.0.rc1' => ANDROID_TARGET < 15 ? 4.7 : 4.9,
       }[JRUBY_JARS_VERSION.to_s] || 3.2
       lower_limit = upper_limit * 0.9
       version_message ="JRuby: #{JRUBY_JARS_VERSION}, ANDROID_TARGET: #{ANDROID_TARGET}"