calabash 2.0.0.pre10 → 2.0.0.pre11

data/lib/calabash/ios/device.rb

@@ -16,7 +16,6 @@ module Calabash
     require 'calabash/ios/device/rotation_mixin'
     require 'calabash/ios/device/keyboard_mixin'
     require 'calabash/ios/device/uia_keyboard_mixin'
-    require 'calabash/ios/device/text_mixin'
     require 'calabash/ios/device/uia_mixin'
     require 'calabash/ios/device/ipad_1x_2x_mixin'
     require 'calabash/ios/device/device_implementation'

data/lib/calabash/ios/device/device_implementation.rb

@@ -17,13 +17,11 @@ module Calabash
       include Calabash::IOS::RotationMixin
       include Calabash::IOS::KeyboardMixin
       include Calabash::IOS::UIAKeyboardMixin
-      include Calabash::IOS::TextMixin
       include Calabash::IOS::UIAMixin
       include Calabash::IOS::IPadMixin
       include Calabash::IOS::GesturesMixin
 
       attr_reader :run_loop
-      attr_reader :uia_strategy
       attr_reader :start_options
 
       # Returns the default simulator identifier.  The string that is return
@@ -50,7 +48,7 @@ module Calabash
           if run_loop_device.nil?
             raise "Could not find a simulator with a UDID or name matching '#{identifier}'"
           end
-          run_loop_device.instruments_identifier
+          run_loop_device.instruments_identifier(RunLoop::SimControl.new.xcode)
         end
       end
 
@@ -84,14 +82,14 @@ module Calabash
           elsif connected_devices.count > 1
             raise 'There is more than one physical devices connected.  Use CAL_DEVICE_ID to indicate which you want to connect to.'
           else
-            connected_devices.first.instruments_identifier
+            connected_devices.first.instruments_identifier(RunLoop::SimControl.new.xcode)
           end
         else
           run_loop_device = Device.fetch_matching_physical_device(identifier)
           if run_loop_device.nil?
             raise "Could not find a physical device with a UDID or name matching '#{identifier}'"
           end
-          run_loop_device.instruments_identifier
+          run_loop_device.instruments_identifier(RunLoop::SimControl.new.xcode)
         end
       end
 
@@ -345,8 +343,7 @@ module Calabash
 
         {
            :device => self,
-           :application => application,
-           :uia_strategy => uia_strategy
+           :application => application
         }
       end
 
@@ -394,7 +391,7 @@ module Calabash
       def start_app_with_device_and_options(application, run_loop_device, user_defined_options)
         start_options = merge_start_options!(application, run_loop_device, user_defined_options)
         @run_loop = RunLoop.run(start_options)
-        @uia_strategy = @run_loop[:uia_strategy]
+        @automator = Calabash::IOS::Automator::DeviceAgent.new(@run_loop)
       end
 
       # @!visibility private
@@ -528,12 +525,6 @@ module Calabash
         end
       end
 
-      # @!visibility private
-      def enter_text(text)
-        # @todo implement this
-        raise 'ni'
-      end
-
       # @!visibility private
       def clear_app_data_on_simulator(application, run_loop_device, bridge)
         begin
@@ -630,9 +621,8 @@ module Calabash
       # @!visibility private
       # Expensive!
       def Device.fetch_matching_simulator(udid_or_name)
-        sim_control = RunLoop::SimControl.new
-        sim_control.simulators.detect do |sim|
-          sim.instruments_identifier == udid_or_name ||
+        RunLoop::SimControl.new.simulators.detect do |sim|
+          sim.instruments_identifier(RunLoop::SimControl.new.xcode) == udid_or_name ||
                 sim.udid == udid_or_name
         end
       end
@@ -662,7 +652,7 @@ module Calabash
             Logger.error('which resolves to a physical device.')
             Logger.error("The server endpoint '#{server.endpoint}' is for an iOS Simulator.")
             Logger.error('Use CAL_ENDPOINT to specify the IP address of your device')
-            Logger.error("Ex. $ CAL_ENDPOINT=http://10.0.1.2:37265 CAL_DEVICE_ID=#{identifier} be calabash ...")
+            Logger.error("Ex. $ CAL_ENDPOINT=http://10.0.1.2:37265 CAL_DEVICE_ID=#{identifier} #{Calabash::Utility.bundle_exec_prepend}calabash ...")
             raise "Invalid device endpoint '#{server.endpoint}'"
           end
         end
@@ -703,7 +693,7 @@ module Calabash
               {
                     :app => application.path,
                     :bundle_id => application.identifier,
-                    :device_target => run_loop_device.instruments_identifier,
+                    :device_target => run_loop_device.instruments_identifier(RunLoop::SimControl.new.xcode),
                     :uia_strategy => strategy
               }
         @start_options = default_options.merge(options_from_user)
@@ -775,13 +765,11 @@ module Calabash
 
         if strategy == :host
           @run_loop = RunLoop::HostCache.default.read
-          @uia_strategy = :host
         else
           pid = instruments_pid
           @run_loop = {}
           @run_loop[:uia_strategy] = strategy
           @run_loop[:pid] = pid
-          @uia_strategy = strategy
         end
 
         # populate the @runtime_attributes

data/lib/calabash/ios/device/gestures_mixin.rb

@@ -96,36 +96,33 @@ module Calabash
 
       # @!visibility private
       def _tap(query, options={})
-        view_to_touch = _gesture_waiter.wait_for_view(query, options)
+        view_to_touch = _gesture_waiter.wait_for_view(query, timeout: options[:timeout])
 
         rect = view_to_touch['rect']
         x = rect['x'] + (rect['width'] * (options[:at][:x] / 100.0)).to_i
         y = rect['y'] + (rect['height'] * (options[:at][:y] / 100.0)).to_i
 
-        offset = coordinate(x, y)
-
-        uia_serialize_and_call(:tapOffset, offset, options)
+        @automator.touch({coordinates: coordinate(x, y)})
 
         Calabash::QueryResult.create([view_to_touch], query)
       end
 
       # @!visibility private
       def _double_tap(query, options={})
-        view_to_touch = _gesture_waiter.wait_for_view(query, options)
+        view_to_touch = _gesture_waiter.wait_for_view(query, timeout: options[:timeout])
 
         rect = view_to_touch['rect']
         x = rect['x'] + (rect['width'] * (options[:at][:x] / 100.0)).to_i
         y = rect['y'] + (rect['height'] * (options[:at][:y] / 100.0)).to_i
 
-        offset = coordinate(x, y)
-
-        uia_serialize_and_call(:doubleTapOffset, offset, options)
+        @automator.double_tap({coordinates: coordinate(x, y)})
 
         Calabash::QueryResult.create([view_to_touch], query)
       end
 
       # @!visibility private
       def _long_press(query, options={})
+        options[:duration] += 0.2
 
         begin
           _expect_valid_duration(options)
@@ -133,39 +130,66 @@ module Calabash
           raise ArgumentError e
         end
 
-        view_to_touch = _gesture_waiter.wait_for_view(query, options)
+        view_to_touch = _gesture_waiter.wait_for_view(query, timeout: options[:timeout])
 
         rect = view_to_touch['rect']
         x = rect['x'] + (rect['width'] * (options[:at][:x] / 100.0)).to_i
         y = rect['y'] + (rect['height'] * (options[:at][:y] / 100.0)).to_i
 
-        offset = coordinate(x, y)
-
-        uia_serialize_and_call(:touchHoldOffset, options[:duration], offset)
+        @automator.touch_hold({coordinates: coordinate(x, y), duration: options[:duration]})
 
         Calabash::QueryResult.create([view_to_touch], query)
       end
 
       # @!visibility private
       def _pan_between(query_from, query_to, options={})
+        from_query_result = nil
+        to_query_result  = nil
+        from = coordinate(0, 0)
+        to = coordinate(0, 0)
+
+        unless query_from.nil?
+          from_view = _gesture_waiter.wait_for_view(query_from, timeout: options[:timeout])
+          from = coordinate(from_view['rect']['center_x'], from_view['rect']['center_y'])
+          from_query_result = Calabash::QueryResult.create([from_view], query_from)
+        end
 
-        begin
-          _expect_valid_duration(options)
-        rescue ArgumentError => e
-          raise ArgumentError e
+        unless query_to.nil?
+          to_view = _gesture_waiter.wait_for_view(query_to, timeout: options[:timeout])
+          to = coordinate(to_view['rect']['center_x'], to_view['rect']['center_y'])
+          Calabash::QueryResult.create([to_view], query_to)
         end
 
-        from_view = _gesture_waiter.wait_for_view(query_from, options)
-        to_view = _gesture_waiter.wait_for_view(query_to, options)
+        offset = options[:offset]
+
+        if offset
+          from_offset = offset[:from]
+
+          if from_offset
+            x, y = from_offset[:x], from_offset[:y]
 
-        from_offset = uia_center_of_view(from_view)
-        to_offset = uia_center_of_view(to_view)
+            from[:x] += x || 0
+            from[:y] += y || 0
+          end
+
+          to_offset = offset[:to]
+
+          if from_offset
+            x, y = to_offset[:x], to_offset[:y]
+
+            to[:x] += x || 0
+            to[:y] += y || 0
+          end
+        end
 
-        uia_serialize_and_call(:panOffset, from_offset, to_offset, options)
+        @automator.pan({coordinates:
+                            {from: from,
+                             to: to},
+                        duration: options[:duration]})
 
         {
-          :from => Calabash::QueryResult.create([from_view], query_from),
-          :to => Calabash::QueryResult.create([to_view], query_to)
+          :from => from_query_result,
+          :to => to_query_result
         }
       end
 
@@ -178,48 +202,22 @@ module Calabash
       # If the view has a UINavigationBar or UITabBar, the defaults *might*
       # cause vertical gestures to start and/or end on one of these bars.
       def _pan(query, from, to, options={})
-
-        begin
-          _expect_valid_duration(options)
-        rescue ArgumentError => e
-          raise ArgumentError, e
-        end
-
         gesture_waiter = _gesture_waiter
-        view_to_pan = gesture_waiter.wait_for_view(query, options)
-
-        begin
-          check_for_broken_uia_automation(query, view_to_pan, gesture_waiter)
-        rescue => e
-          raise "Could not pan with query: #{query}\n#{e.message}"
-        end
+        view_to_pan = gesture_waiter.wait_for_view(query, timeout: options[:timeout])
 
         rect = view_to_pan['rect']
 
         from_x = rect['width'] * (from[:x]/100.0)
         from_y = rect['height'] * (from[:y]/100.0)
-        from_offset = coordinate(from_x, from_y)
 
         to_x = rect['width'] * (to[:x]/100.0)
         to_y = rect['height'] * (to[:y]/100.0)
-        to_offset = coordinate(to_x, to_y)
 
-        uia_serialize_and_call(:panOffset, from_offset, to_offset)
+        @automator.pan({coordinates: {from: coordinate(from_x, from_y), to: coordinate(to_x, to_y)},
+                               duration: options[:duration]})
 
-        Calabash::QueryResult.create([view_to_pan], query)
-      end
 
-      # @!visibility private
-      def pan_screen(view_to_pan, from_offset, to_offset, options)
-        begin
-          _expect_valid_duration(options)
-        rescue ArgumentError => e
-          raise ArgumentError, e
-        end
-
-        uia_serialize_and_call(:panOffset, from_offset, to_offset, options)
-
-        Calabash::QueryResult.create([view_to_pan], '*')
+        Calabash::QueryResult.create([view_to_pan], query)
       end
 
       # @!visibility private
@@ -238,7 +236,7 @@ module Calabash
         end
 
         gesture_waiter = _gesture_waiter
-        view_to_flick = gesture_waiter.wait_for_view(query, options)
+        view_to_flick = gesture_waiter.wait_for_view(query, timeout: options[:timeout])
 
         begin
           check_for_broken_uia_automation(query, view_to_flick, gesture_waiter)
@@ -287,7 +285,7 @@ module Calabash
 
         gesture_waiter = _gesture_waiter
 
-        view_to_pinch = gesture_waiter.wait_for_view(query, options)
+        view_to_pinch = gesture_waiter.wait_for_view(query, timeout: options[:timeout])
         offset = uia_center_of_view(view_to_pinch)
 
         gesture_direction = direction == :in ? :out : :in

data/lib/calabash/ios/device/keyboard_mixin.rb

@@ -3,6 +3,12 @@ module Calabash
 
     # @!visibility private
     module KeyboardMixin
+      # Enter `text` into the currently focused view.
+      # @see Calabash::Text#enter_text
+      # @!visibility private
+      def enter_text(text, options={})
+        @automator.enter_text_with_keyboard(text, options)
+      end
 
       # Returns true if a docked keyboard is visible.
       #
@@ -61,6 +67,21 @@ module Calabash
         docked_keyboard_visible? || undocked_keyboard_visible? || split_keyboard_visible?
       end
 
+      def tap_keyboard_delete_key(options={})
+        @automator.tap_keyboard_delete_key
+      end
+
+      def tap_keyboard_action_key
+        results = keyboard_waiter.query("* isFirstResponder:1", :returnKeyType)
+
+        if results.empty?
+          RunLoop.log_debug("Cannot find keyboard first responder to ask for its returnKeyType")
+          raise 'Cannot tap_keyboard_action_key. No view has focus'
+        end
+
+        @automator.tap_keyboard_action_key(results.first)
+      end
+
       # Returns the the text in the first responder.
       #
       # The first responder will be the UITextField or UITextView instance

data/lib/calabash/ios/device/rotation_mixin.rb

@@ -14,55 +14,14 @@ module Calabash
           wait_for_server_to_start({:timeout => 1})
         end
 
-        family = device_family
-
-        current_orientation = status_bar_orientation.to_sym
-        recording_name = nil
-        case direction
-          when :left
-            if current_orientation == :down
-              recording_name = 'left_home_down'
-            elsif current_orientation == :right
-              recording_name = 'left_home_right'
-            elsif current_orientation == :left
-              recording_name = 'left_home_left'
-            elsif current_orientation == :up
-              recording_name = 'left_home_up'
-            end
-          when :right
-            if current_orientation == :down
-              recording_name = 'right_home_down'
-            elsif current_orientation == :left
-              recording_name = 'right_home_left'
-            elsif current_orientation == :right
-              recording_name = 'right_home_right'
-            elsif current_orientation == :up
-              recording_name = 'right_home_up'
-            end
-          else
-            # Caller should have guarded us against this case.
-            raise ArgumentError, "Expected '#{direction}' to be :left or :right"
-        end
-
-        if family == 'iPad'
-          form_factor = 'ipad'
-        else
-          form_factor = 'iphone'
-        end
-
-        if recording_name.nil?
-          raise "Could not rotate device in direction '#{direction}' " \
-                "with orientation '#{current_orientation}'"
-        end
+        orientation = status_bar_orientation.to_sym
 
-        recording_name = "rotate_#{recording_name}"
-        playback_route(recording_name, form_factor)
+        @automator.rotate(direction, orientation)
       end
 
       # @!visibility private
       # Caller must pass position one of these positions :down, :left, :right, :up
       def rotate_home_button_to(position)
-
         valid_positions = [:down, :left, :right, :up]
         unless valid_positions.include?(position)
           raise ArgumentError,
@@ -83,28 +42,7 @@ module Calabash
           return orientation
         end
 
-        family = device_family
-
-        if family == 'iPad'
-          form_factor = 'ipad'
-        else
-          form_factor = 'iphone'
-        end
-
-        ROTATION_CANDIDATES.each do |recording_name|
-          playback_route(recording_name, form_factor)
-
-          # Wait for rotation animation.
-          #
-          # Can't wait for animations because there might be animations other
-          # than rotation on the screen.
-          sleep(0.4)
-
-          orientation = status_bar_orientation.to_sym
-          if orientation == position
-            return orientation.to_s
-          end
-        end
+        @automator.rotate_home_button_to(position, status_bar_orientation)
 
         orientation.to_s
       end

data/lib/calabash/ios/gestures.rb

@@ -3,15 +3,8 @@ module Calabash
 
     # @!visibility private
     module Gestures
-
       # @!visibility private
-      # Concrete implementation of pan_screen_up gesture.
-      def _pan_screen_up(options={})
-
-        gesture_options = options.dup
-        gesture_options[:duration] ||= 0.5
-        gesture_options[:timeout] ||= Calabash::Gestures::DEFAULT_GESTURE_WAIT_TIMEOUT
-
+      define_method (:_swipe_coordinates_for_screen) do
         points_from_top = gesture_points_from_top
         points_from_bottom = gesture_points_from_bottom
 
@@ -24,108 +17,49 @@ module Calabash
         end_y = points_from_top
         x = width/2.0
 
-        from_offset = coordinate(x, start_y)
-        to_offset = coordinate(x, end_y)
-
-        Device.default.pan_screen(top_view, from_offset, to_offset, gesture_options)
+        {bottom: coordinate(x, start_y), top: coordinate(x, end_y)}
       end
 
       # @!visibility private
-      # Concrete implementation of pan_screen_down gesture.
-      def _pan_screen_down(options={})
-
-        gesture_options = options.dup
-        gesture_options[:duration] ||= 0.5
-        gesture_options[:timeout] ||= Calabash::Gestures::DEFAULT_GESTURE_WAIT_TIMEOUT
-
-        points_from_top = gesture_points_from_top
-        points_from_bottom = gesture_points_from_bottom
-
-        top_view = query('*').first
-
-        height = top_view['frame']['height'].to_f
-        width = top_view['frame']['width'].to_f
+      # Concrete implementation of pan_screen_up gesture.
+      define_method (:_pan_screen_up) do |options={}|
+        swipe = _swipe_coordinates_for_screen
+        gesture_options = options.merge({offset: {from: swipe[:bottom], to: swipe[:top]}})
 
-        start_y = points_from_top
-        end_y = height - points_from_bottom
-        x = width/2.0
+        Calabash::Internal.with_default_device(required_os: :ios) {|device| device.pan_between(nil, nil, gesture_options)}
+      end
 
-        from_offset = coordinate(x, start_y)
-        to_offset = coordinate(x, end_y)
+      # @!visibility private
+      # Concrete implementation of pan_screen_down gesture.
+      define_method (:_pan_screen_down) do |options={}|
+        swipe = _swipe_coordinates_for_screen
+        gesture_options = options.merge({offset: {from: swipe[:top], to: swipe[:bottom]}})
 
-        Device.default.pan_screen(top_view, from_offset, to_offset, gesture_options)
+        Calabash::Internal.with_default_device(required_os: :ios) {|device| device.pan_between(nil, nil, gesture_options)}
       end
 
       # @!visibility private
       # Concrete implementation of flick_screen_up gesture.
-      def _flick_screen_up(options={})
-
-        gesture_options = options.dup
-        gesture_options[:duration] ||= 0.5
-        gesture_options[:timeout] ||= Calabash::Gestures::DEFAULT_GESTURE_WAIT_TIMEOUT
-
-        points_from_top = gesture_points_from_top
-        points_from_bottom = gesture_points_from_bottom
-
-        top_view = query('*').first
+      define_method (:_flick_screen_up) do |options={}|
+        swipe = _swipe_coordinates_for_screen
+        gesture_options = options.merge({offset: {from: swipe[:bottom], to: swipe[:top]}})
 
-        height = top_view['frame']['height'].to_f
-        width = top_view['frame']['width'].to_f
-
-        start_y = height - points_from_bottom
-        end_y = points_from_top
-        x = width/2.0
-
-        from_offset = coordinate(x, start_y)
-        to_offset = coordinate(x, end_y)
-
-        Device.default.flick_screen(top_view, from_offset, to_offset, gesture_options)
+        Calabash::Internal.with_default_device(required_os: :ios) {|device| device.flick_between(nil, nil, gesture_options)}
       end
 
       # @!visibility private
       # Concrete implementation of flick_screen_down gesture.
-      def _flick_screen_down(options={})
-
-        gesture_options = options.dup
-        gesture_options[:duration] ||= 0.5
-        gesture_options[:timeout] ||= Calabash::Gestures::DEFAULT_GESTURE_WAIT_TIMEOUT
-
-        points_from_top = gesture_points_from_top
-        points_from_bottom = gesture_points_from_bottom
-
-        top_view = query('*').first
-
-        height = top_view['frame']['height'].to_f
-        width = top_view['frame']['width'].to_f
-
-        start_y = points_from_top
-        end_y = height - points_from_bottom
-        x = width/2.0
-
-        from_offset = coordinate(x, start_y)
-        to_offset = coordinate(x, end_y)
+      define_method (:_flick_screen_down) do |options={}|
+        swipe = _swipe_coordinates_for_screen
+        gesture_options = options.merge({offset: {from: swipe[:top], to: swipe[:bottom]}})
 
-        Device.default.flick_screen(top_view, from_offset, to_offset, gesture_options)
+        Calabash::Internal.with_default_device(required_os: :ios) {|device| device.flick_between(nil, nil, gesture_options)}
       end
 
       # @!visibility private
       # Concrete implementation of pinch_screen
-      def _pinch_screen(direction, options={})
-        Device.default.pinch(direction, '*', options)
-      end
-
-      # @!visibility private
-      # Concrete implementation of pinch_to_zoom
-      def _pinch_to_zoom(direction, query, options={})
-        gesture_direction = direction == :in ? :out : :in
-        Device.default.pinch(gesture_direction, query, options)
-      end
-
-      # @!visibility private
-      # Concrete implementation of pinch_screen_to_zoom
-      def _pinch_screen_to_zoom(direction, options={})
-        gesture_direction = direction == :in ? :out : :in
-        Device.default.pinch(gesture_direction, '*', options)
+      define_method (:_pinch_screen) do |direction, options={}|
+        Calabash::Internal.with_default_device(required_os: :ios) {|device| device.pinch(direction, '*', options)}
       end
 
       private