calabash-android 0.5.1 → 0.5.2.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: daf5c99e264d3b69f5429e1fe0e14de3e4e7a145
-  data.tar.gz: 1d6538452dd8984a966286dfdf415c53d440f2ac
+  metadata.gz: ea9071972253360f02e1b1ed07308aca2b219e0e
+  data.tar.gz: 4b7f3b9df746943d83ebacf832da0a992b9a4ed2
 SHA512:
-  metadata.gz: c40fd803a4d516ec0ac3d7276c85c294b063302ac256cba1c2369706a9a61fa2246992db8c31d162c25a482060dfa45c74cc16eb8fe98b957ff0091c89936d7a
-  data.tar.gz: 666399f4f8597e263ee6e18579926d5435171452bba5735ca1b64c2a8d9654ed653608afea57ccb325805d1acd83dbc92615895c698b9f310d3f6e2a6ddf3cc4
+  metadata.gz: 4067273b985fec4f1c3cf4dfb0f2ac0ddc365f65bf406d82fb8cd03c1138229e8845791a84ea8b01a20449de0e025f441b9f5d06f44a6bd3a4a6fdcf73829a30
+  data.tar.gz: 760f7891db8314ad420179f5cb5e4219db7ac3738ea165032e14c534bb6472a9906ddde18e28a24d7abfdbf4d0f516d35b4e99f374b907abf7daf453d0af5034

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    calabash-android (0.5.1)
+    calabash-android (0.5.2.pre1)
       awesome_print
       cucumber
       escape (~> 0.0.4)

data/bin/calabash-android-console.rb

@@ -1,23 +1,38 @@
 def calabash_console(app_path = nil)
   test_server_path = test_server_path(app_path)
 
-  unless ENV['IRBRC']
-    ENV['IRBRC'] = File.join(File.dirname(__FILE__), '..', 'irbrc')
+
+  path = ENV['CALABASH_IRBRC']
+  unless path
+    if File.exist?('.irbrc')
+      path = File.expand_path('.irbrc')
+    end
+  end
+
+  unless path
+    path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'irbrc'))
   end
 
-  unless ENV["MAIN_ACTIVITY"]
-    ENV["MAIN_ACTIVITY"] = main_activity(app_path)
+  ENV['IRBRC'] = path
+
+
+  unless ENV['MAIN_ACTIVITY']
+    ENV['MAIN_ACTIVITY'] = main_activity(app_path)
   end
 
-  unless ENV["APP_PATH"]
-    ENV["APP_PATH"] = app_path
+  unless ENV['APP_PATH']
+    ENV['APP_PATH'] = app_path
   end
 
-  unless ENV["TEST_APP_PATH"]
-    ENV["TEST_APP_PATH"] = test_server_path
+  unless ENV['TEST_APP_PATH']
+    ENV['TEST_APP_PATH'] = test_server_path
   end
 
   build_test_server_if_needed(app_path)
 
-  system "#{RbConfig.ruby} -S irb"
+  puts 'Starting calabash-android console...'
+  puts "Loading #{ENV['IRBRC']}"
+  puts 'Running irb...'
+  exec('irb')
+
 end

data/bin/calabash-android-run.rb

@@ -16,7 +16,10 @@ def calabash_run(app_path = nil)
     build_test_server_if_needed(app_path)
 
     test_server_path = test_server_path(app_path)
-    env = "MAIN_ACTIVITY=#{main_activity(app_path)} "\
+
+    main_activity = ENV['MAIN_ACTIVITY'] || main_activity(app_path)
+
+    env = "MAIN_ACTIVITY=#{main_activity} "\
           "APP_PATH=\"#{app_path}\" "\
           "TEST_APP_PATH=\"#{test_server_path}\""
   else

data/bin/calabash-android-setup.rb

@@ -9,7 +9,7 @@ def calabash_setup
   ask_for_setting(:keystore_password, "Please enter the password for the keystore")
   ask_for_setting(:keystore_alias, "Please enter the alias")
 
-  open('calabash_settings', 'w') do |f|
+  open('.calabash_settings', 'w') do |f|
     f.puts @settings.to_json
   end
   puts "Saved your settings to .calabash_settings. You can edit the settings manually or run this setup script again"

data/lib/calabash-android/deprecated_actions.map

@@ -0,0 +1,8 @@
+send_key_enter,press_enter_button
+send_key_left,press_left_button
+send_key_right,press_right_button
+send_key_up,press_up_button
+send_key_down,press_down_button
+press_menu,press_menu_button
+go_back,press_back_button
+backdoor,backdoor(method_name, arguments)

data/lib/calabash-android/env.rb

@@ -1,3 +1,4 @@
+require_relative 'helpers'
 
 class Env
   require 'win32/registry' if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
@@ -79,7 +80,28 @@ class Env
   end
 
   def self.zipalign_path
-    %Q("#{android_home_path}/tools/zipalign")
+    zipalign_path = File.join(android_home_path, 'tools', zipalign_executable)
+
+    unless File.exists?(zipalign_path)
+      log "Did not find zipalign at '#{zipalign_path}'. Trying to find zipalign in tools directories."
+
+      tools_directories.each do |dir|
+        zipalign_path = File.join(dir, zipalign_executable)
+        break if File.exists?(zipalign_path)
+      end
+    end
+
+    if File.exists?(zipalign_path)
+      log "Found zipalign at '#{zipalign_path}'"
+      zipalign_path
+    else
+      log("Did not find zipalign in any of '#{tools_directories.join("','")}'.", true)
+      raise 'Could not find zipalign'
+    end
+  end
+
+  def self.zipalign_executable
+    is_windows? ? 'zipalign.exe' : 'zipalign'
   end
 
   def self.jarsigner_executable
@@ -107,10 +129,16 @@ class Env
   end
 
   def self.tools_dir
+    tools_dir = tools_directories.first
+    log "Found tools directory at '#{tools_dir}'"
+    tools_dir
+  end
+
+  def self.tools_directories
     Dir.chdir(android_home_path) do
       dirs = Dir["build-tools/*"] + Dir["platform-tools"]
       raise "Could not find tools directory in #{android_home_path}" if dirs.empty?
-      File.expand_path(dirs.first)
+      dirs.map {|dir| File.expand_path(dir)}
     end
   end
 

data/lib/calabash-android/environment_helpers.rb

@@ -0,0 +1,12 @@
+module Calabash
+  module Android
+    module EnvironmentHelpers
+      # Are we running in the Xamarin Test Cloud?
+      #
+      # @return [Boolean] Returns true if cucumber is running in the test cloud.
+      def xamarin_test_cloud?
+        ENV['XAMARIN_TEST_CLOUD'] == '1'
+      end
+    end
+  end
+end

data/lib/calabash-android/gestures.rb

@@ -0,0 +1,308 @@
+require 'json'
+
+module Calabash
+  module Android
+    module Gestures
+      class MultiTouchGesture
+        attr_reader :gestures
+        attr_accessor :timeout
+
+        DEFAULT_TIMEOUT = 5
+
+        def initialize(gestures = [])
+          unless gestures.is_a?(Array)
+            gestures = [gestures]
+          end
+
+          @gestures = gestures
+          @timeout = (ENV['CALABASH_DEFAULT_TIMEOUT'] && ENV['CALABASH_DEFAULT_TIMEOUT'].to_i) || DEFAULT_TIMEOUT
+        end
+
+        def +(gesture_collection)
+          MultiTouchGesture.new(@gestures + gesture_collection.gestures)
+        end
+
+        def add_gesture
+          gestures = @gestures
+          MultiTouchGesture.new(gestures + gesture_collection.gestures)
+        end
+
+        def <<(gesture)
+          @gestures << gesture
+        end
+
+        def add_touch(touch, index=0)
+          gestures = @gestures
+          gestures[index] << touch
+          MultiTouchGesture.new(gestures)
+        end
+
+        def add_touch!(touch, index=0)
+          @gestures = add_touch(touch, index).gestures
+        end
+
+        def merge(multi_touch_gesture)
+          MultiTouchGesture.new(gestures.map.with_index {|gesture, index| gesture + multi_touch_gesture.gestures[index]})
+        end
+
+        def merge!(multi_touch_gesture)
+          @gestures = merge(multi_touch_gesture).gestures
+        end
+
+        def to_json(*object)
+          {
+              query_timeout: @timeout.to_f,
+              gestures: @gestures
+          }.to_json(*object)
+        end
+
+        def query_string=(query_string)
+          @gestures.each {|gesture| gesture.query_string=query_string}
+        end
+
+        def reset_query_string
+          @gestures.each {|gesture| gesture.reset_query_string}
+        end
+
+        def offset=(offset)
+          @gestures.each {|gesture| gesture.offset=offset}
+        end
+
+        def max_execution_time
+          (@gestures.map {|gesture| gesture.max_execution_time}).max
+        end
+      end
+
+      class Gesture
+        attr_reader :touches
+
+        def initialize(touches = [], query_string = nil)
+          unless touches.is_a?(Array)
+            touches = [touches]
+          end
+
+          @touches = []
+
+          touches.each do |touch|
+            @touches << Touch.new(touch)
+          end
+
+          @query_string = query_string
+        end
+
+        def from(touch)
+          to(touch)
+        end
+
+        def to(touch)
+          if touch.is_a?(Hash)
+            touch = Touch.new(touch)
+          end
+
+          unless (last_touch = @touches.last).nil?
+            touch.x ||= last_touch.x
+            touch.y ||= last_touch.y
+          end
+
+          Gesture.new(@touches << touch, @query_string)
+        end
+
+        def +(gesture)
+          Gesture.new(@touches + gesture.touches, @query_string)
+        end
+
+        def add_touch(touch)
+          touches = @touches
+          Gesture.new(touches << touch, @query_string)
+        end
+
+        def <<(touch)
+          @touches << touch
+        end
+
+        def to_json(*object)
+          {
+              query_string: @query_string,
+              touches: @touches
+          }.to_json(*object)
+        end
+
+        def query_string=(query_string)
+          @query_string = query_string
+        end
+
+        def reset_query_string
+          touches.each {|touch| touch.query_string=nil}
+        end
+
+        def offset=(offset)
+          @touches.each {|touch| touch.offset=offset}
+        end
+
+        def max_execution_time
+          (@touches.map {|touch| touch.wait + touch.time}).reduce(:+)
+        end
+
+        def self.with_parameters(multi_touch_gesture, params={})
+          multi_touch_gesture.query_string = params[:query_string] if params[:query_string]
+          multi_touch_gesture.timeout = params[:timeout] if params[:timeout]
+
+          multi_touch_gesture
+        end
+
+        def self.generate_tap(touch_hash)
+          MultiTouchGesture.new(Gesture.new(Touch.new(touch_hash)))
+        end
+
+        def self.tap(opt={})
+          touch = opt[:touch] || {}
+          touch[:x] ||= (opt[:x] || 50)
+          touch[:y] ||= (opt[:y] || 50)
+          touch[:time] ||= (opt[:time] || 0.2)
+          touch[:release] = touch[:release].nil? ? (opt[:release].nil? ? true : opt[:release]) : touch[:release]
+          touch[:wait] ||= (opt[:wait] || 0)
+          touch[:offset] ||= opt[:offset]
+
+          generate_tap(touch)
+        end
+
+        def self.double_tap(opt={})
+          self.tap(opt).merge(self.tap({wait: 0.1}.merge(opt)))
+        end
+
+        def self.generate_swipe(from_hash, to_hash, opt={})
+          from_params = from_hash.merge(opt).merge(opt[:from] || {})
+          to_params = {time: 0}.merge(to_hash).merge(opt[:to] || {})
+
+          if opt[:flick]
+            to_params.merge!(wait: 0)
+          else
+            to_params = {wait: 0.2}.merge(to_params)
+          end
+
+          self.tap({release: false}.merge(from_params)).merge(self.tap(to_params))
+        end
+
+        def self.swipe(direction, opt={})
+          from = {x: 50, y: 50}
+          to = {x: 50, y: 50}
+
+          case direction
+            when :left
+              from[:x] = 90
+              to[:x] = 10
+            when :right
+              from[:x] = 10
+              to[:x] = 90
+            when :up
+              from[:y] = 90
+              to[:y] = 10
+            when :down
+              from[:y] = 10
+              to[:y] = 90
+            else
+              raise "Cannot swipe in #{direction}"
+          end
+
+          opt[:time] ||= 0.3
+
+          generate_swipe(from, to, opt)
+        end
+
+        def self.generate_pinch_out(from_arr, to_arr, opt={})
+          self.generate_swipe(from_arr[0], to_arr[0], opt) + self.generate_swipe(from_arr[1], to_arr[1], opt)
+        end
+
+        def self.pinch(direction, opt={})
+          opt[:from] ||= []
+          opt[:from][0] = (opt[:from][0] || {}).merge(opt)
+          opt[:from][1] = (opt[:from][1] || {}).merge(opt)
+          opt[:to] ||= []
+          opt[:to][0] ||= {}
+          opt[:to][1] ||= {}
+
+          from = [{x: 40, y: 40}.merge(opt[:from][0]), {x: 60, y: 60}.merge(opt[:from][1])]
+          to = [{x: 10, y: 10}.merge(opt[:to][0]), {x: 90, y: 90}.merge(opt[:to][1])]
+
+          case direction
+            when :out
+
+            when :in
+              from,to = to,from
+            else
+              raise "Cannot pinch #{direction}"
+          end
+
+          generate_pinch_out(from, to)
+        end
+      end
+
+      class Touch
+        attr_accessor :x, :y, :offset_x, :offset_y, :wait, :time, :release, :query_string
+
+        def initialize(touch)
+          if touch.is_a?(Touch)
+            touch = touch.to_hash
+          end
+
+          touch[:offset] ||= {}
+          touch[:offset_x] ||= touch[:offset][:x]
+          touch[:offset_y] ||= touch[:offset][:y]
+
+          @x = touch[:x]
+          @y = touch[:y]
+          @offset_x = touch[:offset_x] || 0
+          @offset_y = touch[:offset_y] || 0
+          @wait = touch[:wait] || 0
+          @time = touch[:time] || 0
+          @release = touch[:release].nil? ? false : touch[:release]
+          @query_string = touch[:query_string]
+        end
+
+        def merge(touch)
+          Touch.new(to_hash.merge(touch.to_hash))
+        end
+
+        def to_hash
+          {
+              x: @x,
+              y: @y,
+              offset_x: @offset_x || 0,
+              offset_y: @offset_y || 0,
+              wait: @wait.to_f,
+              time: @time.to_f,
+              release: @release,
+              query_string: @query_string
+          }
+        end
+
+        def to_json(object = Hash)
+          to_hash.to_json(object)
+        end
+
+        def +(touch)
+          hash = to_hash
+          hash[:x] += touch.x
+          hash[:y] += touch.y
+          hash[:offset_x] += touch.offset_x
+          hash[:offset_y] += touch.offset_y
+          Touch.new(hash)
+        end
+
+        def -(touch)
+          hash = to_hash
+          hash[:x] -= touch.x
+          hash[:y] -= touch.y
+          hash[:offset_x] -= touch.offset_x
+          hash[:offset_y] -= touch.offset_y
+          Touch.new(hash)
+        end
+
+        def offset=(offset)
+          @offset_x = offset[:x]
+          @offset_y = offset[:y]
+        end
+      end
+    end
+  end
+end