calabash 2.0.0.pre10 → 2.0.0.pre11

data/lib/calabash/device.rb

@@ -5,7 +5,7 @@ module Calabash
     include Utility
 
     # @!visibility private
-    @@default = nil
+    @@default ||= nil
 
     # @!visibility private
     def self.default
@@ -180,29 +180,14 @@ module Calabash
     # @see Calabash::Gestures#pan
     # @!visibility private
     def pan(query, from, to, options={})
-      Query.ensure_valid_query(query)
-
-      ensure_valid_swipe_params(from, to)
-
-      gesture_options = options.dup
-      gesture_options[:duration] ||= 0.5
-      gesture_options[:timeout] ||= Calabash::Gestures::DEFAULT_GESTURE_WAIT_TIMEOUT
-
-      _pan(query, from, to, gesture_options)
+      _pan(query, from, to, options)
     end
 
     # Performs a `pan` between two elements.
     # @see Calabash::Gestures#pan_between
     # @!visibility private
     def pan_between(query_from, query_to, options={})
-      Query.ensure_valid_query(query_from)
-      Query.ensure_valid_query(query_to)
-
-      gesture_options = options.dup
-      gesture_options[:duration] ||= 1
-      gesture_options[:timeout] ||= Calabash::Gestures::DEFAULT_GESTURE_WAIT_TIMEOUT
-
-      _pan_between(query_from, query_to, gesture_options)
+      _pan_between(query_from, query_to, options)
     end
 
     # Performs a `flick` on the (first) view that matches `query`.
@@ -239,7 +224,7 @@ module Calabash
     # Enter `text` into the currently focused view.
     # @see Calabash::Text#enter_text
     # @!visibility private
-    def enter_text(text)
+    def enter_text(text, options={})
       abstract_method!
     end
 

data/lib/calabash/gestures.rb

@@ -1,8 +1,6 @@
 module Calabash
   # Methods for performing gestures.  Gestures are taps, flicks, and pans.
-  #
-  # Many gestures take an optional :duration. On iOS, the duration must be
-  # between 0.5 and 60 (seconds).  This is a limitation of the UIAutomation API.
+  # All gestures execute "physical gestures" like human users would.
   #
   # @note All gestures have _undefined return values._  This is intentional.
   #  Please do not rely on return values of gestures in your tests.  For
@@ -31,23 +29,24 @@ module Calabash
     #      |    │                 4                   │
     #      ┴    └─────────────────────────────────────┘
     #
-    #   1. tap("* marked:'email'")
-    #   2. tap("* marked:'email'", at:  {x: 0, y: 0})
-    #   3. tap("* marked:'email'", at:  {x: 100, y: 0})
-    #   4. tap("* marked:'email'", at:  {x: 50, y: 100})
+    #   1. cal.tap("* marked:'email'")
+    #   2. cal.tap("* marked:'email'", at: {x: 0, y: 0})
+    #   3. cal.tap("* marked:'email'", at: {x: 100, y: 0})
+    #   4. cal.tap("* marked:'email'", at: {x: 50, y: 100})
     #
     # @param [String, Hash, Calabash::Query] query A query describing the view
     #   to tap.
-    # @param [Hash] options Options for modifying the details of the touch.
-    # @option options [Hash] :at ({x: 50, y: 50}) The point at which the
+    # @param [Hash] at (default: `{x: 50, y: 50}`) The point at which the
     #   gesture originates from.  It is a percentage-based translation using
-    #   top-left `(0,0)` as the reference point.
+    #   top-left `{x: 0, y: 0}` as the reference point.
     # @raise [ViewNotFoundError] If the `query` returns no results.
     # @raise [ArgumentError] If `query` is invalid.
-    def tap(query, options={})
+    def tap(query, at: nil)
       Query.ensure_valid_query(query)
 
-      Device.default.tap(Query.new(query), options)
+      options = {at: at || {x: 50, y: 50}}
+
+      Calabash::Internal.with_default_device {|device| device.tap(Query.new(query), options)}
     end
 
     # Performs a **double_tap** on the first view that matches `query`.
@@ -56,17 +55,18 @@ module Calabash
     #
     # @param [String, Hash, Calabash::Query] query A query describing the view
     #  to tap.
-    # @param [Hash] options Options for modifying the details of the touch.
-    # @option options [Hash] :at ({x: 50, y: 50}) The point at which the
+    # @param [Hash] at (default: `{x: 50, y: 50}`) The point at which the
     #   gesture originates from.  It is a percentage-based translation using
-    #   top-left `(0,0)` as the reference point.
+    #   top-left `{x: 0, y: 0}` as the reference point.
     #
     # @raise [ViewNotFoundError] If the `query` returns no results.
     # @raise [ArgumentError] If `query` is invalid.
-    def double_tap(query, options={})
+    def double_tap(query, at: nil)
       Query.ensure_valid_query(query)
 
-      Device.default.double_tap(Query.new(query), options)
+      options = {at: at || {x: 50, y: 50}}
+
+      Calabash::Internal.with_default_device {|device| device.double_tap(Query.new(query), options)}
     end
 
     # Performs a **long_press** on the first view that matches `query`.
@@ -77,33 +77,39 @@ module Calabash
     # @see #tap
     #
     # @param [String] query A query describing the view to tap.
-    # @param [Hash] options Options for modifying the details of the touch.
-    # @option options [Number] :duration (1.0) The amount of time in seconds to
+    # @param [Number] duration (default: 1.0) The amount of time in seconds to
     #  press.  On iOS, the duration must be between 0.5 and 60.
+    # @param [Hash] at (default: `{x: 50, y: 50}`) The point at which the
+    #   gesture originates from.  It is a percentage-based translation using
+    #   top-left `{x: 0, y: 0}` as the reference point.
     # @raise [ViewNotFoundError] If the `query` returns no results.
     # @raise [ArgumentError] If `query` is invalid.
-    # @raise [ArgumentError] iOS: if the `:duration` is not between 0.5 and 60.
-    def long_press(query, options={})
+    def long_press(query, duration: nil, at: nil)
       Query.ensure_valid_query(query)
 
-      Device.default.long_press(Query.new(query), options)
+      options = {
+          at: at || {x: 50, y: 50},
+          duration: duration || 1.0
+      }
+
+      Calabash::Internal.with_default_device {|device| device.long_press(Query.new(query), options)}
     end
 
-    # Performs a **pan** on the first view that matches `query`.
+    # Performs a **pan** inside the first view that matches `query`.
     #
     # A pan is a straight line swipe that pauses at the final point
     # before releasing the gesture. This is the general purpose pan method. For
-    # standardized pans see `pan_left`, `pan_right`, `pan_up`, and `pan_down`.
-    #
-    # Also known as **scroll** and **swipe**.
+    # standardized pans see {pan_left}, {pan_right}, {pan_up}, and {pan_down}.
     #
     # @example
-    #  Consider a pan on a scrollable view.  When the finger is is released,
-    #  the velocity of the view is zero.
+    #  # Consider a pan on a scrollable view.  When the finger is is released,
+    #  # the velocity of the view is zero.
     #
     # @example
-    #  A scrollable view displays the alphabet. Panning left will cause the
-    #  view to scroll right.
+    #  # A scrollable view displays the alphabet. Panning left will cause the
+    #  # view to scroll right.
+    #
+    #  cal.pan("* id:'alphabetView'", cal.pct(80, 80), cal.pct(20, 80))
     #
     #      Before             After
     #   ┌───────────┐  |  ┌───────────┐
@@ -112,15 +118,6 @@ module Calabash
     #   │ <───────┤ │  |  │           │
     #   └───────────┘  |  └───────────┘
     #
-    # Apple's UIAutomation 'dragInsideWithOptions' is broken on iOS Simulators.
-    # Call `pan` on iOS Simulators >= iOS 7.0 will raise an error.  See the
-    # iOS Scroll API for alternatives.
-    #
-    # @see Calabash::IOS::Scroll#scroll
-    # @see Calabash::IOS::Scroll#scroll_to_row
-    # @see Calabash::IOS::Scroll#scroll_to_row_with_mark
-    # @see Calabash::IOS::Scroll#scroll_to_item
-    # @see Calabash::IOS::Scroll#scroll_to_item_with_mark
     #
     # @param [String, Hash, Calabash::Query] query A query describing the view
     #  to pan inside.
@@ -128,19 +125,18 @@ module Calabash
     #   originates from.
     # @param [Hash] to `({:x, :y})` The point at which the gesture
     #   ends.
-    #
-    # @param [Hash] options Options for modifying the details of the pan.
-    # @option options [Number] :duration (0.5) How many seconds the pan takes
-    #   to complete. On iOS, the duration must be between 0.5 and 60.
-    #
+    # @param [Number] duration (default: 1.0) The amount of time in seconds the
+    #  gesture lasts.
     # @raise [ViewNotFoundError] If the `query` returns no results.
     # @raise [ArgumentError] If `query` is invalid.
-    # @raise [ArgumentError] iOS: if the `:duration` is not between 0.5 and 60.
-    # @raise [RuntimeError] If called on an iOS Simulator > iOS 7.
-    def pan(query, from, to, options={})
+    def pan(query, from, to, duration: nil)
       Query.ensure_valid_query(query)
 
-      Device.default.pan(Query.new(query), from, to, options)
+      options = {
+          duration: duration || DEFAULT_PAN_OPTIONS[:duration]
+      }
+
+      Calabash::Internal.with_default_device {|device| device.pan(Query.new(query), from, to, options)}
     end
 
     # Performs a **pan** from the center of the first view that matches
@@ -149,8 +145,8 @@ module Calabash
     # Also known as **drag and drop**.
     #
     # @example
-    #  Panning between two elements.
-    #  `pan_between("* id:'first'", "* id:'second'")`
+    #  #Panning between two elements.
+    #  cal.pan_between("* id:'first'", "* id:'second'")
     #
     #
     #      ┌───────────┐
@@ -170,86 +166,137 @@ module Calabash
     #                 │           │
     #                 └───────────┘
     #
-    # @option options [Number] :duration (1.0) How many seconds the swipe takes
-    #   to complete.
+    # @param [String, Hash, Calabash::Query] query_from A query describing the
+    #  view to pan *from*
+    # @param [String, Hash, Calabash::Query] query_to A query describing the
+    #  view to pan *to*
+    # @param [Number] duration (default: 1.0) The amount of time in seconds the
+    #  gesture lasts.
     # @raise [ViewNotFoundError] If the `query_from` returns no results.
     # @raise [ViewNotFoundError] If the `query_to` returns no results.
     # @raise [ArgumentError] If `query_from` is invalid.
     # @raise [ArgumentError] If `query_to` is invalid.
-    # @raise [ArgumentError] iOS: if the `:duration` is not between 0.5 and 60.
-    def pan_between(query_from, query_to, options={})
+    def pan_between(query_from, query_to, duration: nil)
       Query.ensure_valid_query(query_from)
       Query.ensure_valid_query(query_to)
 
-      Device.default.pan_between(Query.new(query_from), Query.new(query_to), options)
+      options = {
+          duration: duration || DEFAULT_PAN_OPTIONS[:duration]
+      }
+
+      Calabash::Internal.with_default_device do |device|
+        device.pan_between(Query.new(query_from), Query.new(query_to), options)
+      end
     end
 
-    # Performs a **pan** heading _left_ on the first view that matches `query`.
+    # Performs a **pan** heading _left_ inside the first view that matches
+    # `query`.
     #
     # @see #pan
-    def pan_left(query, options={})
-      pan(query, {x: 90, y: 50}, {x: 10, y: 50}, options)
+    # @param [Number] duration (default: 1.0) The amount of time in seconds the
+    #  gesture lasts.
+    def pan_left(query, duration: nil)
+      pan(query, {x: 90, y: 50}, {x: 10, y: 50}, duration: duration)
     end
 
-    # Performs a **pan** heading _right_ on the first view that matches `query`.
+    # Performs a **pan** heading _right_ inside the first view that matches
+    # `query`.
     #
     # @see #pan
-    def pan_right(query, options={})
-      pan(query, {x: 10, y: 50}, {x: 90, y: 50}, options)
+    # @param [Number] duration (default: 1.0) The amount of time in seconds the
+    #  gesture lasts.
+    def pan_right(query, duration: nil)
+      pan(query, {x: 10, y: 50}, {x: 90, y: 50}, duration: duration)
     end
 
-    # Performs a **pan** heading _up_ on the first view that matches `query`.
+    # Performs a **pan** heading _up_ inside the first view that matches
+    # `query`.
     #
     # @see #pan
-    def pan_up(query, options={})
-      pan(query, {x: 50, y: 90}, {x: 50, y: 10}, options)
+    # @param [Number] duration (default: 1.0) The amount of time in seconds the
+    #  gesture lasts.
+    def pan_up(query, duration: nil)
+      pan(query, {x: 50, y: 90}, {x: 50, y: 10}, duration: duration)
     end
 
-    # Performs a **pan** heading _down_ on the first view that matches `query`.
+    # Performs a **pan** heading _down_ inside the first view that matches
+    # `query`.
     #
     # @see #pan
-    def pan_down(query, options={})
-      pan(query, {x: 50, y: 10}, {x: 50, y: 90}, options)
+    # @param [Number] duration (default: 1.0) The amount of time in seconds the
+    #  gesture lasts.
+    def pan_down(query, duration: nil)
+      pan(query, {x: 50, y: 10}, {x: 50, y: 90}, duration: duration)
     end
 
     # Performs a **pan** heading _left_ on the screen.
     #
     # @see #pan
-    def pan_screen_left(options={})
+    # @param [Number] duration (default: 1.0) The amount of time in seconds the
+    #  gesture lasts.
+    def pan_screen_left(duration: nil)
+      options = {
+          duration: duration || DEFAULT_PAN_OPTIONS[:duration]
+      }
+
       pan_left('*', options)
     end
 
     # Performs a **pan** heading _right_ on the screen.
     #
     # @see #pan
-    def pan_screen_right(options={})
+    # @param [Number] duration (default: 1.0) The amount of time in seconds the
+    #  gesture lasts.
+    def pan_screen_right(duration: nil)
+      options = {
+          duration: duration || DEFAULT_PAN_OPTIONS[:duration]
+      }
+
       pan_right('*', options)
     end
 
     # Performs a **pan** heading _up_ on the screen.
     #
     # @see #pan
-    def pan_screen_up(options={})
+    # @param [Number] duration (default: 1.0) The amount of time in seconds the
+    #  gesture lasts.
+    def pan_screen_up(duration: nil)
+      options = {
+          duration: duration || DEFAULT_PAN_OPTIONS[:duration]
+      }
+
       _pan_screen_up(options)
     end
 
     # Performs a **pan** heading _down_ on the screen.
     #
     # @see #pan
-    def pan_screen_down(options={})
+    # @param [Number] duration (default: 1.0) The amount of time in seconds the
+    #  gesture lasts.
+    def pan_screen_down(duration: nil)
+      options = {
+          duration: duration || DEFAULT_PAN_OPTIONS[:duration]
+      }
+
       _pan_screen_down(options)
     end
 
-    # Performs a **flick** on the first view that matches `query`.
+    # Performs a **flick** inside the first view that matches `query`.
     #
     # A flick is a straight line swipe that **lifts the finger while
     # the gesture is still in motion**. This will often cause scrollable
     # views to continue moving for some time after the gesture is released.
+    #
+    # It is likely that the gesture you want to automate is a {pan}, not a
+    # flick.
+    #
     # @see pan
     #
     # @example
-    #  A scrollable view displays the alphabet. Flicking left will cause the
-    #  view to scroll right.
+    #  # A scrollable view displays the alphabet. Flicking left will cause the
+    #  # view to scroll right.
+    #
+    #  cal.flick("* id:'alphabetView'", cal.pct(80, 80), cal.pct(20, 80))
     #
     #       Before             After
     #    ┌───────────┐  |  ┌───────────┐
@@ -259,219 +306,266 @@ module Calabash
     #    └───────────┘  |  └───────────┘
     #
     # @param [String,Hash,Query] query A query describing the view to flick
-    #  inside of.
+    #  inside.
     # @param [Hash] from `({:x, :y})` The point at which the gesture
     #   originates from.
     # @param [Hash] to `({:x, :y})` The point at which the gesture
     #   ends.
-    #
-    # @param [Hash] options Options for controlling the flick.
-    # @option options [Numeric] :duration The duration of the flick. On iOS,
-    #   the duration must be between 0.5 and 60.
-    #
+    # @param [Number] duration (default: 1.0) The amount of time in seconds the
+    #  gesture lasts.
     # @raise [ViewNotFoundError] If the `query` returns no results.
     # @raise [ArgumentError] If `query` is invalid.
-    # @raise [ArgumentError] iOS: if the `:duration` is not between 0.5 and 60.
-    def flick(query, from, to, options={})
+    def flick(query, from, to, duration: nil)
       Query.ensure_valid_query(query)
 
-      Device.default.flick(Query.new(query), from, to, options)
+      options = {
+          duration: duration || DEFAULT_PAN_OPTIONS[:duration]
+      }
+
+      Calabash::Internal.with_default_device do |device|
+        device.flick(Query.new(query), from, to, options)
+      end
     end
 
-    # Performs a **flick** heading _left_ on the first view that matches `query`.
+    # Performs a **flick** heading _left_ inside the first view that matches
+    # `query`.
     # @see #flick
-    def flick_left(query, options={})
-      flick(query, {x: 90, y: 50}, {x: 10, y: 50}, options)
+    # @param [Number] duration (default: 1.0) The amount of time in seconds the
+    #  gesture lasts.
+    def flick_left(query, duration: nil)
+      flick(query, {x: 90, y: 50}, {x: 10, y: 50}, duration: duration)
     end
 
-    # Performs a **flick** heading _right_ on the first view that matches
+    # Performs a **flick** heading _right_ inside the first view that matches
     # `query`.
     # @see #flick
-    def flick_right(query, options={})
-      flick(query, {x: 10, y: 50}, {x: 90, y: 50}, options)
+    # @param [Number] duration (default: 1.0) The amount of time in seconds the
+    #  gesture lasts.
+    def flick_right(query, duration: nil)
+      flick(query, {x: 10, y: 50}, {x: 90, y: 50}, duration: duration)
     end
 
-    # Performs a **flick** heading _up_ on the first view that matches `query`.
+    # Performs a **flick** heading _up_ inside the first view that matches
+    # `query`.
     # @see #flick
-    def flick_up(query, options={})
-      flick(query, {x: 50, y: 90}, {x: 50, y: 10}, options)
+    # @param [Number] duration (default: 1.0) The amount of time in seconds the
+    #  gesture lasts.
+    def flick_up(query, duration: nil)
+      flick(query, {x: 50, y: 90}, {x: 50, y: 10}, duration: duration)
     end
 
-    # Performs a **flick** heading _down_ on the first view that matches `query`.
+    # Performs a **flick** heading _down_ inside the first view that matches
+    # `query`.
     # @see #flick
-    def flick_down(query, options={})
-      flick(query, {x: 50, y: 10}, {x: 50, y: 90}, options)
+    # @param [Number] duration (default: 1.0) The amount of time in seconds the
+    #  gesture lasts.
+    def flick_down(query, duration: nil)
+      flick(query, {x: 50, y: 10}, {x: 50, y: 90}, duration: duration)
     end
 
     # Performs a **flick** heading _left_ on the screen.
     # @see #flick
-    def flick_screen_left(options={})
+    # @param [Number] duration (default: 1.0) The amount of time in seconds the
+    #  gesture lasts.
+    def flick_screen_left(duration: nil)
+      options = {
+          duration: duration || DEFAULT_PAN_OPTIONS[:duration]
+      }
+
       flick_left('*', options)
     end
 
     # Performs a **flick** heading _right_ on the screen.
     # @see #flick
-    def flick_screen_right(options={})
+    # @param [Number] duration (default: 1.0) The amount of time in seconds the
+    #  gesture lasts.
+    def flick_screen_right(duration: nil)
+      options = {
+          duration: duration || DEFAULT_PAN_OPTIONS[:duration]
+      }
+
       flick_right('*', options)
     end
 
     # Performs a **flick** heading _up_ on the screen.
     # @see #flick
-    def flick_screen_up(options={})
+    # @param [Number] duration (default: 1.0) The amount of time in seconds the
+    #  gesture lasts.
+    def flick_screen_up(duration: nil)
+      options = {
+          duration: duration || DEFAULT_PAN_OPTIONS[:duration]
+      }
+
       _flick_screen_up(options)
     end
 
     # Performs a **flick** heading _down_ on the screen.
     # @see #flick
-    def flick_screen_down(options={})
+    # @param [Number] duration (default: 1.0) The amount of time in seconds the
+    #  gesture lasts.
+    def flick_screen_down(duration: nil)
+      options = {
+          duration: duration || DEFAULT_PAN_OPTIONS[:duration]
+      }
+
       _flick_screen_down(options)
     end
 
-    # Performs a **pinch** outwards on the first view match by `query`.
+    # Performs a **pinch** outwards inside the first view match by `query`.
     #
-    # @param [String, Hash, Calabash::Query] query A query describing the view
-    #   to pinch.
-    # @param [Hash] options Options for controlling the pinch.
-    # @option options [Numeric] :duration The duration of the pinch. On iOS,
-    #   the duration must be between 0.5 and 60.
+    # The gestures will be similar to two fingers pressing down near the
+    # center of the view and simultaneously moving towards the opposite corners
+    # of the view
     #
-    # @raise [ViewNotFoundError] If the `query` returns no results.
-    # @raise [ArgumentError] If `query` is invalid.
-    # @raise [ArgumentError] iOS: if the `:duration` is not between 0.5 and 60.
-    def pinch_out(query, options={})
-      Device.default.pinch(:out, query, options)
-    end
-
-    # Performs a **pinch** inwards on the first view match by `query`.
+    # @example
+    #  # We have a webview that we want to pinch out on
+    #
+    #  cal.pinch_out("* id:'webView'")
+    #
+    #         Application
+    #  ┌───────────────────────┐
+    #  │───────────────────────│
+    #  │      id: webview      │
+    #  │  ┌─────────────────┐  │
+    #  │  │  ^              │  │
+    #  │  │   \             │  │
+    #  │  │    \            │  │
+    #  │  │     *    *      │  │
+    #  │  │           \     │  │
+    #  │  │            \    │  │
+    #  │  │             v   │  │
+    #  │  └─────────────────┘  │
+    #  └───────────────────────┘
+    #
+    # @example
+    #  # We have a MapView rendering a map. We want to zoom it in.
+    #  # On iOS, we should pinch out to zoom in
+    #  # On Android, we should pinch in to zoom in.
+    #
+    #  if cal.android?
+    #    cal.pinch_in({class: "MapView"})
+    #  elsif cal.ios?
+    #    cal.pinch_out({class: "MapView"})
+    #  end
     #
     # @param [String, Hash, Calabash::Query] query A query describing the view
     #   to pinch.
-    # @param [Hash] options Options for controlling the pinch.
-    # @option options [Numeric] :duration The duration of the pinch. On iOS,
-    #   the duration must be between 0.5 and 60.
-    #
+    # @param [Number] duration (default: 1.0) The amount of time in seconds the
+    #  gesture lasts.
     # @raise [ViewNotFoundError] If the `query` returns no results.
     # @raise [ArgumentError] If `query` is invalid.
-    # @raise [ArgumentError] iOS: if the `:duration` is not between 0.5 and 60.
-    def pinch_in(query, options={})
-      Device.default.pinch(:in, query, options)
-    end
+    def pinch_out(query, duration: nil)
+      options = {
+          duration: duration || DEFAULT_PAN_OPTIONS[:duration]
+      }
 
-    # Performs a **pinch** outwards on the screen.
-    #
-    # @param [Hash] options Options for controlling the pinch.
-    # @option options [Numeric] :duration The duration of the pinch. On iOS,
-    #   the duration must be between 0.5 and 60.
-    #
-    # @raise [ViewNotFoundError] If the `query` returns no results.
-    # @raise [ArgumentError] If `query` is invalid.
-    # @raise [ArgumentError] iOS: if the `:duration` is not between 0.5 and 60.
-    def pinch_screen_out(options={})
-      _pinch_screen(:out, options)
+      Calabash::Internal.with_default_device {|device| device.pinch(:out, query, options)}
     end
 
-    # Performs a **pinch** inwards on the screen.
+    # Performs a **pinch** inwards inside the first view match by `query`.
     #
-    # @param [Hash] options Options for controlling the pinch.
-    # @option options [Numeric] :duration The duration of the pinch. On iOS,
-    #   the duration must be between 0.5 and 60.
+    # The gestures will be similar to two fingers pressing down in the opposite
+    # corners of the view  and simultaneously moving towards the center of the
+    # view.
     #
-    # @raise [ViewNotFoundError] If the `query` returns no results.
-    # @raise [ArgumentError] If `query` is invalid.
-    # @raise [ArgumentError] iOS: if the `:duration` is not between 0.5 and 60.
-    def pinch_screen_in(options={})
-      _pinch_screen(:in, options)
-    end
-
-    # Performs a **pinch** to zoom out.
+    # @example
+    #  # We have a webview that we want to pinch in on
+    #
+    #  cal.pinch_in("* id:'webView'")
+    #
+    #         Application
+    #  ┌───────────────────────┐
+    #  │───────────────────────│
+    #  │      id: webview      │
+    #  │  ┌─────────────────┐  │
+    #  │  │  *              │  │
+    #  │  │   \             │  │
+    #  │  │    \            │  │
+    #  │  │     v    ^      │  │
+    #  │  │           \     │  │
+    #  │  │            \    │  │
+    #  │  │             *   │  │
+    #  │  └─────────────────┘  │
+    #  └───────────────────────┘
     #
-    # @param [String, Hash, Calabash::Query] query A query describing the view
-    #   to pinch.
-    # @param [Hash] options Options for controlling the pinch.
-    # @option options [Numeric] :duration The duration of the pinch. On iOS,
-    #   the duration must be between 0.5 and 60.
+    # @example
+    #  # We have a MapView rendering a map. We want to zoom it in.
+    #  # On iOS, we should pinch out to zoom in
+    #  # On Android, we should pinch in to zoom in.
     #
-    # @raise [ViewNotFoundError] If the `query` returns no results.
-    # @raise [ArgumentError] If `query` is invalid.
-    # @raise [ArgumentError] iOS: if the `:duration` is not between 0.5 and 60.
-    def pinch_to_zoom_out(query, options={})
-      _pinch_to_zoom(:out, query, options)
-    end
-
-    # Performs a **pinch** to zoom in.
+    #  if cal.android?
+    #    cal.pinch_in({class: "MapView"})
+    #  elsif cal.ios?
+    #    cal.pinch_out({class: "MapView"})
+    #  end
     #
     # @param [String, Hash, Calabash::Query] query A query describing the view
     #   to pinch.
-    # @param [Hash] options Options for controlling the pinch.
-    # @option options [Numeric] :duration The duration of the pinch. On iOS,
-    #   the duration must be between 0.5 and 60.
-    #
+    # @param [Number] duration (default: 1.0) The amount of time in seconds the
+    #  gesture lasts.
     # @raise [ViewNotFoundError] If the `query` returns no results.
     # @raise [ArgumentError] If `query` is invalid.
-    # @raise [ArgumentError] iOS: if the `:duration` is not between 0.5 and 60.
-    def pinch_to_zoom_in(query, options={})
-      _pinch_to_zoom(:in, query, options)
+    def pinch_in(query, duration: nil)
+      options = {
+          duration: duration || DEFAULT_PAN_OPTIONS[:duration]
+      }
+
+      Calabash::Internal.with_default_device {|device| device.pinch(:in, query, options)}
     end
 
-    # Performs a **pinch** on the screen to zoom in.
+    # Performs a **pinch** outwards on the screen.
     #
-    # @param [Hash] options Options for controlling the pinch.
-    # @option options [Numeric] :duration The duration of the pinch. On iOS,
-    #   the duration must be between 0.5 and 60.
+    # @see #pinch_out
     #
+    # @param [Number] duration (default: 1.0) The amount of time in seconds the
+    #  gesture lasts.
     # @raise [ViewNotFoundError] If the `query` returns no results.
     # @raise [ArgumentError] If `query` is invalid.
-    # @raise [ArgumentError] iOS: if the `:duration` is not between 0.5 and 60.
-    def pinch_screen_to_zoom_in(options={})
-      _pinch_screen_to_zoom(:in, options)
+    def pinch_screen_out(duration: nil)
+      options = {
+          duration: duration || DEFAULT_PAN_OPTIONS[:duration]
+      }
+
+      _pinch_screen(:out, options)
     end
 
-    # Performs a **pinch** on the screen to zoom out.
+    # Performs a **pinch** inwards on the screen.
     #
-    # @param [Hash] options Options for controlling the pinch.
-    # @option options [Numeric] :duration The duration of the pinch. On iOS,
-    #   the duration must be between 0.5 and 60.
+    # @see #pinch_in
     #
+    # @param [Number] duration (default: 1.0) The amount of time in seconds the
+    #  gesture lasts.
     # @raise [ViewNotFoundError] If the `query` returns no results.
     # @raise [ArgumentError] If `query` is invalid.
-    # @raise [ArgumentError] iOS: if the `:duration` is not between 0.5 and 60.
-    def pinch_screen_to_zoom_out(options={})
-      _pinch_screen_to_zoom(:out, options)
-    end
+    def pinch_screen_in(duration: nil)
+      options = {
+          duration: duration || DEFAULT_PAN_OPTIONS[:duration]
+      }
 
-    # @!visibility private
-    def _pan_screen_up(options={})
-      abstract_method!
-    end
-
-    # @!visibility private
-    def _pan_screen_down(options={})
-      abstract_method!
+      _pinch_screen(:in, options)
     end
 
     # @!visibility private
-    def _flick_screen_up(options={})
-      abstract_method!
+    define_method(:_pan_screen_up) do |options={}|
+      abstract_method!(:_pan_screen_up)
     end
 
     # @!visibility private
-    def _flick_screen_down(options={})
-      abstract_method!
+    define_method(:_pan_screen_down) do |options={}|
+      abstract_method!(:_pan_screen_down)
     end
 
     # @!visibility private
-    def _pinch_screen(direction, options={})
-      abstract_method!
+    define_method(:_flick_screen_up) do |options={}|
+      abstract_method!(:_flick_screen_up)
     end
 
     # @!visibility private
-    def _pinch_to_zoom(direction, query, options={})
-      abstract_method!
+    define_method(:_flick_screen_down) do |options={}|
+      abstract_method!(:_flick_screen_down)
     end
 
     # @!visibility private
-    def _pinch_screen_to_zoom(direction, options={})
-      abstract_method!
-    end
+    DEFAULT_PAN_OPTIONS = {duration: 1}
   end
 end