ruboto 0.11.0 → 0.12.0.rc.0

data/lib/ruboto/sdk_locations.rb

@@ -0,0 +1,23 @@
+require 'pathname'
+
+module Ruboto
+  module SdkLocations
+    if ENV['ANDROID_HOME']
+      ANDROID_HOME = ENV['ANDROID_HOME']
+    else
+      adb_location = `#{RUBY_PLATFORM =~ /mingw|mswin/ ? 'where' : 'which'} adb`.chomp
+      if adb_location.empty?
+        raise 'Unable to locate the "adb" command.  Either set the ANDROID_HOME environment variable or add the location of the "adb" command to your path.'
+      end
+      ANDROID_HOME = File.dirname(File.dirname(Pathname.new(adb_location).realpath))
+      unless File.exists? "#{ANDROID_HOME}/tools"
+        puts "Found '#{adb_location}' but it is not in a proper Android SDK installation."
+      end
+    end
+    unless File.exists? "#{ANDROID_HOME}/tools"
+      raise "The '<ANDROID_HOME>/tools' directory is missing.
+Please set the ANDROID_HOME environment variable to a proper Android SDK installation."
+    end
+    ANDROID_TOOLS_REVISION = File.read("#{ANDROID_HOME}/tools/source.properties").slice(/Pkg.Revision=\d+/).slice(/\d+$/).to_i
+  end
+end

data/lib/ruboto/sdk_versions.rb

@@ -3,7 +3,6 @@ require 'pathname'
 module Ruboto
   module SdkVersions
     VERSION_TO_API_LEVEL = {
-        '2.1' => 'android-7', '2.1-update1' => 'android-7', '2.2' => 'android-8',
         '2.3' => 'android-9', '2.3.1' => 'android-9', '2.3.2' => 'android-9',
         '2.3.3' => 'android-10', '2.3.4' => 'android-10',
         '3.0' => 'android-11', '3.1' => 'android-12', '3.2' => 'android-13',
@@ -11,26 +10,9 @@ module Ruboto
         '4.1' => 'android-16', '4.1.1' => 'android-16', '4.1.2' => 'android-16',
         '4.2' => 'android-17', '4.2.2' => 'android-17',
     }
-    MINIMUM_SUPPORTED_SDK_LEVEL = 7
+    MINIMUM_SUPPORTED_SDK_LEVEL = 10
     MINIMUM_SUPPORTED_SDK = "android-#{MINIMUM_SUPPORTED_SDK_LEVEL}"
     DEFAULT_TARGET_SDK_LEVEL = 10
     DEFAULT_TARGET_SDK = "android-#{DEFAULT_TARGET_SDK_LEVEL}"
-    if ENV['ANDROID_HOME']
-      ANDROID_HOME = ENV['ANDROID_HOME']
-    else
-      adb_location = `#{RUBY_PLATFORM =~ /mingw|mswin/ ? 'where' : 'which'} adb`.chomp
-      if adb_location.empty?
-        raise 'Unable to locate the "adb" command.  Either set the ANDROID_HOME environment variable or add the location of the "adb" command to your path.'
-      end
-      ANDROID_HOME = File.dirname(File.dirname(Pathname.new(adb_location).realpath))
-      unless File.exists? "#{ANDROID_HOME}/tools"
-        puts "Found '#{adb_location}' but it is not in a proper Android SDK installation."
-      end
-    end
-    unless File.exists? "#{ANDROID_HOME}/tools"
-      raise "The '<ANDROID_HOME>/tools' directory is missing.
-Please set the ANDROID_HOME environment variable to a proper Android SDK installation."
-    end
-    ANDROID_TOOLS_REVISION = File.read("#{ANDROID_HOME}/tools/source.properties").slice(/Pkg.Revision=\d+/).slice(/\d+$/).to_i
   end
 end

data/lib/ruboto/util/build.rb

@@ -30,11 +30,11 @@ module Ruboto
       #   all api levels
       #
       def get_class_or_interface(klass, force=nil)
-        element = verify_api.find_class_or_interface(klass, "either")
+        element = verify_api.find_class_or_interface(klass, 'either')
 
         abort "ERROR: #{klass} not found" unless element
 
-        unless force == "include"
+        unless force == 'include'
           abort "#{klass} not available in minSdkVersion, added in #{element.attribute('api_added')}; use '--force include' to create it" if
             element.attribute('api_added') and element.attribute('api_added').to_i > verify_min_sdk.to_i
           abort "#{klass} deprecated for targetSdkVersion, deprecated in #{element.attribute('deprecated')}; use '--force include' to create it" if
@@ -71,16 +71,16 @@ module Ruboto
 
         abort = false
         new_methods = methods
-        unless force == "include"
+        unless force == 'include'
           # Inform and remove methods changed inside the scope of the sdk versions
           new_methods = methods.select do |i|
-            if i.attribute('api_added') and i.attribute('api_added').to_i > min_api and force == "exclude"
+            if i.attribute('api_added') and i.attribute('api_added').to_i > min_api and force == 'exclude'
               false
             elsif i.attribute('api_added') and i.attribute('api_added').to_i > min_api
               puts "Can't create #{i.method_signature} -- added in #{i.attribute('api_added')} -- use method_exclude or force exclude"
               abort = true
               false
-            elsif i.attribute('deprecated') and i.attribute('deprecated').to_i <= target_api and force == "exclude"
+            elsif i.attribute('deprecated') and i.attribute('deprecated').to_i <= target_api and force == 'exclude'
               false
             elsif i.attribute('deprecated') and i.attribute('deprecated').to_i <= target_api
               puts "Can't create #{i.method_signature} -- deprecated in #{i.attribute('deprecated')} -- use method_exclude or force exclude"
@@ -91,7 +91,7 @@ module Ruboto
             end
           end
 
-          abort("Aborting!") if abort
+          abort('Aborting!') if abort
         end
 
         new_methods
@@ -101,7 +101,7 @@ module Ruboto
       # generate_subclass_or_interface: Creates a subclass or interface based on the specifications.
       #
       def generate_subclass_or_interface(params)
-        defaults = {:template => "InheritingClass", :method_base => "all", :method_include => "", :method_exclude => "", :force => nil, :implements => ""}
+        defaults = {:template => 'InheritingClass', :method_base => 'all', :method_include => '', :method_exclude => '', :force => nil, :implements => ''}
         params = defaults.merge(params)
         params[:package] ||= verify_package
 
@@ -112,19 +112,19 @@ module Ruboto
         methods = check_methods(methods, params[:force])
         puts "Done. Methods created: #{methods.count}"
 
-        params[:implements] = params[:implements].split(",").push('org.ruboto.RubotoComponent').join(",")
+        params[:implements] = params[:implements].split(',').push('org.ruboto.RubotoComponent').join(',')
 
-        action = class_desc.name == "class" ? "extends" : "implements"
+        action = class_desc.name == 'class' ? 'extends' : 'implements'
         build_file params[:template], params[:package], params[:name], {
-            "THE_METHOD_BASE" => params[:method_base].to_s,
-            "THE_PACKAGE" => params[:package],
-            "THE_ACTION" => action,
-            "THE_ANDROID_CLASS" => (params[:class] || params[:interface]) +
-                (params[:implements] == "" ? "" : ((action != 'implements' ? " implements " : ', ') + params[:implements].split(",").join(", "))),
-            "THE_RUBOTO_CLASS" => params[:name],
-            "THE_CONSTRUCTORS" => class_desc.name == "class" ?
-                class_desc.get_elements("constructor").map { |i| i.constructor_definition(params[:name]) }.join("\n\n") : "",
-            "THE_METHODS" => methods.map { |i| i.method_definition(params[:name]) }.join("\n\n")
+            'THE_METHOD_BASE' => params[:method_base].to_s,
+            'THE_PACKAGE' => params[:package],
+            'THE_ACTION' => action,
+            'THE_ANDROID_CLASS' => (params[:class] || params[:interface]) +
+                (params[:implements] == '' ? '' : ((action != 'implements' ? ' implements ' : ', ') + params[:implements].split(',').join(', '))),
+            'THE_RUBOTO_CLASS' => params[:name],
+            'THE_CONSTRUCTORS' => class_desc.name == 'class' ?
+                class_desc.get_elements('constructor').map { |i| i.constructor_definition(params[:name]) }.join("\n\n") : '',
+            'THE_METHODS' => methods.map { |i| i.method_definition(params[:name]) }.join("\n\n")
         }
       end
 
@@ -133,22 +133,22 @@ module Ruboto
       #   on the API specifications.
       #
       def generate_core_classes(params)
-        hash = {:package => "org.ruboto"}
+        hash = {:package => 'org.ruboto'}
         %w(method_base method_include implements force).inject(hash) {|h, i| h[i.to_sym] = params[i.to_sym]; h}
-        hash[:method_exclude] = params[:method_exclude].split(",").push("onCreate").push("onBind").push("onStartCommand").join(",")
+        hash[:method_exclude] = params[:method_exclude].split(',').push('onCreate').push('onBind').push('onStartCommand').join(',')
 
         %w(android.app.Activity android.app.Service android.content.BroadcastReceiver).each do |i|
-          name = i.split(".")[-1]
-          if(params[:class] == name or params[:class] == "all")
+          name = i.split('.')[-1]
+          if params[:class] == name or params[:class] == 'all'
             generate_subclass_or_interface(hash.merge({:template => "Ruboto#{name}", :class => i, :name => "Ruboto#{name}"}))
           end
         end
 
         # Activities that can be created, but only directly  (i.e., not included in all)
         %w(android.preference.PreferenceActivity android.app.TabActivity).each do |i|
-          name = i.split(".")[-1]
+          name = i.split('.')[-1]
           if params[:class] == name
-            generate_subclass_or_interface(hash.merge({:template => "RubotoActivity", :class => i, :name => "Ruboto#{name}"}))
+            generate_subclass_or_interface(hash.merge({:template => 'RubotoActivity', :class => i, :name => "Ruboto#{name}"}))
           end
         end
       end
@@ -164,30 +164,30 @@ module Ruboto
         text = File.read(File.join(Ruboto::ASSETS, "src/Inheriting#{klass}.java"))
         file_existed = File.exists?(file)
         File.open(file, 'w') do |f|
-          f << text.gsub("THE_PACKAGE", package).gsub("Sample#{klass}", name).gsub("Inheriting#{klass}", name).gsub("sample_#{underscore(klass)}.rb", script_name)
+          f << text.gsub('THE_PACKAGE', package).gsub("Sample#{klass}", name).gsub("Inheriting#{klass}", name).gsub("sample_#{underscore(klass)}.rb", script_name)
         end
         puts "#{file_existed ? 'Updated' : 'Added'} file #{file}."
 
         script_file = File.expand_path("#{SCRIPTS_DIR}/#{script_name}", dest)
-        if !File.exists? script_file
+        unless File.exists? script_file
           sample_source = File.read(File.join(Ruboto::ASSETS, "samples/sample_#{underscore klass}.rb"))
-          sample_source.gsub!("THE_PACKAGE", package)
+          sample_source.gsub!('THE_PACKAGE', package)
           sample_source.gsub!("Sample#{klass}", name)
-          sample_source.gsub!("start.rb", script_name)
+          sample_source.gsub!('start.rb', script_name)
           FileUtils.mkdir_p File.join(dest, SCRIPTS_DIR)
-          File.open script_file, "a" do |f|
+          File.open script_file, 'a' do |f|
             f << sample_source
           end
           puts "Added file #{script_file}."
         end
 
         test_file = File.expand_path("test/src/#{script_name.chomp('.rb')}_test.rb", dest)
-        if !File.exists? test_file
+        unless File.exists? test_file
           sample_test_source = File.read(File.join(Ruboto::ASSETS, "samples/sample_#{underscore klass}_test.rb"))
-          sample_test_source.gsub!("THE_PACKAGE", package)
+          sample_test_source.gsub!('THE_PACKAGE', package)
           sample_test_source.gsub!("Sample#{klass}", name)
           sample_test_source.gsub!('SampleActivity', verify_activity)
-          File.open test_file, "a" do |f|
+          File.open test_file, 'a' do |f|
             f << sample_test_source
           end
           puts "Added file #{test_file}."

data/lib/ruboto/util/setup.rb

@@ -0,0 +1,240 @@
+require 'ruboto/sdk_versions'
+
+module Ruboto
+  module Util
+    module Setup
+      # Todo: Find a way to look this up
+      ANDROID_SDK_VERSION = '21.1'
+
+      #########################################
+      #
+      # Core Set up Method
+      #
+
+      def setup_ruboto
+        check =  check_all
+
+        if not check and RbConfig::CONFIG['host_os'] == /^windows(.*)/
+          puts "\nWe can't directly install Android on Windows."
+          puts 'If you would like to contribute to the setup for Windows,'
+          puts 'please file an issue at https://github.com/ruboto/ruboto/issues'
+          puts
+          return
+       end
+
+       install_all if not check
+       config_path
+      end
+
+      #########################################
+      #
+      # Utility Methods
+      #
+
+      def android_package_os_id
+        case RbConfig::CONFIG['host_os']
+        when /^darwin(.*)/ then 'macosx'
+        when /^linux(.*)/ then 'linux'
+        when /^windows(.*)/ then 'windows'
+        else
+          ## Error
+          nil
+        end
+      end
+
+      def android_package_directory
+        "android-sdk-#{android_package_os_id}"
+      end
+
+      def api_level
+        begin
+          return $1 if File.read('project.properties') =~ /target=(.*)/
+        rescue
+        end
+
+        Ruboto::SdkVersions::DEFAULT_TARGET_SDK
+      end
+
+      def path_setup_file
+        case RbConfig::CONFIG['host_os']
+        when /^darwin(.*)/ then '.profile'
+        when /^linux(.*)/ then '.bashrc'
+        when /^windows(.*)/ then 'windows'
+          ## Error
+        else
+          ## Error
+          nil
+        end
+      end
+
+      #
+      # OS independent "which"
+      # From: http://stackoverflow.com/questions/2108727/which-in-ruby-checking-if-program-exists-in-path-from-ruby
+      #
+      def which(cmd)
+        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+          exts.each { |ext|
+            exe = File.join(path, "#{cmd}#{ext}")
+            return exe if File.executable? exe
+          }
+        end
+        nil
+      end
+
+      #########################################
+      #
+      # Check Methods
+      #
+
+      def check_all
+        @missing_paths = []
+
+        @java_loc = check_for('java', 'Java')
+        @javac_loc = check_for('javac', 'Java Compiler')
+        @ant_loc = check_for('ant', 'Apache ANT')
+        @android_loc = check_for('android', 'Android Package Installer',
+                                  File.join(File.expand_path('~'), android_package_directory, 'tools', 'android'))
+        @emulator_loc = check_for('emulator', 'Android Emulator')
+        @adb_loc = check_for('adb', 'Android SDK Command adb',
+                              File.join(File.expand_path('~'), android_package_directory, 'platform-tools', 'adb'))
+        @dx_loc = check_for('dx', 'Android SDK Command dx')
+        check_for_android_platform
+
+        puts
+        if @java_loc && @javac_loc && @adb_loc && @dx_loc && @emulator_loc && @platform_sdk_loc
+          puts "    *** Ruboto setup is OK! ***\n"
+          true
+        else
+          puts "    !!! Ruboto setup is NOT OK !!!\n"
+          false
+        end
+      end
+
+      def check_for(cmd, pretty_name=nil, alt_dir=nil)
+        rv = which(cmd)
+        rv = nil if rv.nil? or rv.empty?
+
+        if rv.nil? and alt_dir and File.exists?(alt_dir)
+          rv = alt_dir
+          ENV['PATH'] = "#{File.dirname(rv)}:#{ENV['PATH']}"
+          @missing_paths << "#{File.dirname(rv)}"
+        end
+
+        puts "#{pretty_name || cmd}: " + (rv ?  "Found at #{rv}" : 'Not found')
+        rv
+      end
+
+      def check_for_android_platform
+        begin
+          @platform_sdk_loc = File.expand_path "#{@dx_loc}/../../platforms/#{api_level}"
+          if File.exists? @platform_sdk_loc
+            puts "Android platform SDK: Found at #{@platform_sdk_loc}"
+          else
+            puts 'Android platform SDK: Not found'
+            @platform_sdk_loc = nil
+          end
+        rescue
+          @platform_sdk_loc = nil
+        end
+      end
+
+      #########################################
+      #
+      # Install Methods
+      #
+
+      def install_all
+        install_android
+        install_adb
+        install_platform
+      end
+
+      def install_android
+        unless @android_loc
+          puts 'Android package installer not found.'
+          print 'Would you like to download and install it? (Y/n): '
+          a = STDIN.gets.chomp.upcase
+          if a == 'Y' || a.empty?
+            Dir.chdir File.expand_path('~/') do
+              case RbConfig::CONFIG['host_os']
+              when /^darwin(.*)/ 
+                asdk_file_name = "android-sdk_r#{ANDROID_SDK_VERSION}-#{android_package_os_id}.zip"
+                system "wget http://dl.google.com/android/#{asdk_file_name}"
+                system "unzip #{asdk_file_name}"
+                system "rm #{asdk_file_name}"
+              when /^linux(.*)/
+                asdk_file_name = "android-sdk_r#{ANDROID_SDK_VERSION}-#{android_package_os_id}.tgz"
+                system "wget http://dl.google.com/android/#{asdk_file_name}"
+                system "tar -xzf #{asdk_file_name}"
+                system "rm #{asdk_file_name}"
+              when /^windows(.*)/
+                # Todo: Need platform independent download
+                ## Error
+                asdk_file_name = "installer_r#{ANDROID_SDK_VERSION}-#{android_package_os_id}.exe"
+                return
+              end
+            end
+            @android_loc = File.join(File.expand_path('~'), android_package_directory, 'tools', 'android')
+            ENV['PATH'] = "#{File.dirname(@android_loc)}:#{ENV['PATH']}"
+            @missing_paths << "#{File.dirname(@android_loc)}"
+          end
+        end
+      end
+
+      def install_adb
+        if @android_loc and not @adb_loc
+          puts 'Android command adb not found.'
+          print 'Would you like to download and install it? (Y/n): '
+          a = STDIN.gets.chomp.upcase
+          if a == 'Y' || a.empty?
+            system 'android update sdk --no-ui --filter tool,platform-tool'
+            @adb_loc = File.join(File.expand_path('~'), android_package_directory, 'platform-tools', 'adb')
+            ENV['PATH'] = "#{File.dirname(@adb_loc)}:#{ENV['PATH']}"
+            @missing_paths << "#{File.dirname(@adb_loc)}"
+          end
+        end
+      end
+
+      def install_platform
+        if @android_loc and not @platform_sdk_loc
+          puts "Android platform SDK for #{api_level} not found."
+          print 'Would you like to download and install it? (Y/n): '
+          a = STDIN.gets.chomp.upcase
+          if a == 'Y' || a.empty?
+            system "android update sdk --no-ui --filter #{api_level},sysimg-#{api_level.slice(/\d+$/)} --all"
+            @platform_sdk_loc = File.expand_path "#{@dx_loc}/../../platforms/#{api_level}"
+          end
+        end
+      end
+
+      #########################################
+      #
+      # Path Config Method
+      #
+
+      def config_path
+        unless @missing_paths.empty?
+          puts "\nYou are missing some paths.  Execute these lines to add them:\n\n"
+          @missing_paths.each do |path|
+            puts %Q{    export PATH="#{path}:$PATH"}
+          end
+          print "\nWould you like to append these lines to your configuration script? (Y/n): "
+          a = STDIN.gets.chomp.upcase
+          if a == 'Y' || a.empty?
+            print "What script do you use to configure your PATH? (#{path_setup_file}): "
+            a = STDIN.gets.chomp.downcase
+
+            File.open(File.expand_path("~/#{a.empty? ? path_setup_file : a}"), 'a') do |f|
+              f.puts "\n# BEGIN Ruboto PATH setup"
+              @missing_paths.each{|path| f.puts %Q{export PATH="#{path}:$PATH"}}
+              f.puts '# END Ruboto PATH setup'
+              f.puts
+            end
+            puts 'Path updated. Please close your command window and reopen.'
+          end
+        end
+      end
+    end
+  end
+end