run_loop 2.1.1 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 39af0451c6719a47b9adafba2e10d2421633d379
-  data.tar.gz: 98a21653ec46a7c7d04732ea28a81f30b574a413
+  metadata.gz: 153c09febc934625b8890c29fbead9efd47ccec9
+  data.tar.gz: def40d52e20c4e6eff000a13b14ebedaf989b11c
 SHA512:
-  metadata.gz: ac0327a5a25b1c76095520787c28aa4550474fbebcbf3d213737fd46fc89117dad93e7de1eb491af717627c56bdb932b44a771aed45ec8008d48d1d4d5df2955
-  data.tar.gz: 04541d16efd91c9f1889869db1e8fbac9364ce72371efb5cd6f1c66e13038a4410b8614ad1a7648da91dc5c56e67f9f2ad47080ed4be04d7fa37f619b7338a28
+  metadata.gz: e8e4c05e8d8ffc9287c9f8b9b8c7db070eab11580d6219156f6c25d59938448ef6a617136a54184b6459f7c66f3741352f6234c5d27cdafb3fe4300e2f8403a6
+  data.tar.gz: f2896bcd29d50e34bdc418bd3f255bddb8e0adb172263e3a5a8859662ec4aa7437485754a9e35def02b682e069dd768acb97ed5074859ebf82083c3d3d772694

data/lib/run_loop.rb

@@ -1,5 +1,7 @@
 require 'run_loop/regex'
 require 'run_loop/directory'
+require "run_loop/encoding"
+require "run_loop/shell"
 require 'run_loop/environment'
 require 'run_loop/logging'
 require 'run_loop/dot_dir'
@@ -66,10 +68,25 @@ module RunLoop
 
   def self.run(options={})
 
+    cloned_options = options.clone
+
+    # We want to use the _exact_ objects that were passed.
+    if options[:xcode]
+      cloned_options[:xcode] = options[:xcode]
+    end
+
+    if options[:simctl]
+      cloned_options[:simctl] = options[:simctl]
+    end
+
+    # Soon to be unsupported.
+    if options[:sim_control]
+      cloned_options[:sim_control] = options[:sim_control]
+    end
+
     if options[:xcuitest]
-      RunLoop::XCUITest.run(options)
+      RunLoop::XCUITest.run(cloned_options)
     else
-
       if RunLoop::Instruments.new.instruments_app_running?
         raise %q(The Instruments.app is open.
 
@@ -79,58 +96,6 @@ control of your application.
 Please quit the Instruments.app and try again.)
 
       end
-
-      uia_strategy = options[:uia_strategy]
-      if options[:script]
-        script = validate_script(options[:script])
-      else
-        if uia_strategy
-          script = default_script_for_uia_strategy(uia_strategy)
-        else
-          if options[:calabash_lite]
-            uia_strategy = :host
-            script = Core.script_for_key(:run_loop_host)
-          else
-            uia_strategy = :preferences
-            script = default_script_for_uia_strategy(uia_strategy)
-          end
-        end
-      end
-      # At this point, 'script' has been chosen, but uia_strategy might not
-      unless uia_strategy
-        desired_script = options[:script]
-        if desired_script.is_a?(String) #custom path to script
-          uia_strategy = :host
-        elsif desired_script == :run_loop_host
-          uia_strategy = :host
-        elsif desired_script == :run_loop_fast_uia
-          uia_strategy = :preferences
-        elsif desired_script == :run_loop_shared_element
-          uia_strategy = :shared_element
-        else
-          raise "Inconsistent state: desired script #{desired_script} has not uia_strategy"
-        end
-      end
-
-      # At this point script and uia_strategy selected
-      cloned_options = options.clone
-      cloned_options[:script] = script
-      cloned_options[:uia_strategy] = uia_strategy
-
-      # Xcode and SimControl will not be properly cloned and we don't want
-      # them to be; we want to use the exact objects that were passed.
-      if options[:xcode]
-        cloned_options[:xcode] = options[:xcode]
-      end
-
-      if options[:sim_control]
-        cloned_options[:sim_control] = options[:sim_control]
-      end
-
-      if options[:simctl]
-        cloned_options[:simctl] = options[:simctl]
-      end
-
       Core.run_with_options(cloned_options)
     end
   end
@@ -212,7 +177,11 @@ Please quit the Instruments.app and try again.)
     FileUtils.cp(pngs, dest) if pngs and pngs.length > 0
   end
 
+  # @!visibility private
+  #
+  # @deprecated since 2.1.2
   def self.default_script_for_uia_strategy(uia_strategy)
+    self.deprecated("2.1.2", "Replaced by methods in RunLoop::Core")
     case uia_strategy
       when :preferences
         Core.script_for_key(:run_loop_fast_uia)
@@ -225,7 +194,11 @@ Please quit the Instruments.app and try again.)
     end
   end
 
+  # @!visibility private
+  #
+  # @deprecated since 2.1.2
   def self.validate_script(script)
+    self.deprecated("2.1.2", "Replaced by methods in RunLoop::Core")
     if script.is_a?(String)
       unless File.exist?(script)
         raise "Unable to find file: #{script}"

data/lib/run_loop/core.rb

@@ -27,10 +27,6 @@ module RunLoop
     READ_SCRIPT_PATH = File.join(SCRIPTS_PATH, 'read-cmd.sh')
     TIMEOUT_SCRIPT_PATH = File.join(SCRIPTS_PATH, 'timeout3')
 
-    def self.scripts_path
-      SCRIPTS_PATH
-    end
-
     def self.log_run_loop_options(options, xcode)
       return unless RunLoop::Environment.debug?
       # Ignore :sim_control b/c it is a ruby object; printing is not useful.
@@ -67,10 +63,21 @@ module RunLoop
       xcode = options[:xcode] || RunLoop::Xcode.new
       instruments = options[:instruments] || RunLoop::Instruments.new
 
-      # Find the Device under test, the App under test, UIA strategy, and reset options
+      # Device under test: DUT
       device = RunLoop::Device.detect_device(options, xcode, simctl, instruments)
+
+      # App under test: AUT
       app_details = RunLoop::DetectAUT.detect_app_under_test(options)
-      uia_strategy = self.detect_uia_strategy(options, device, xcode)
+
+      # Find the script to pass to instruments and the strategy to communicate
+      # with UIAutomation.
+      script_n_strategy = self.detect_instruments_script_and_strategy(options,
+                                                                      device,
+                                                                      xcode)
+      instruments_script = script_n_strategy[:script]
+      uia_strategy = script_n_strategy[:strategy]
+
+      # The app life cycle reset options.
       reset_options = self.detect_reset_options(options)
 
       instruments.kill_instruments(xcode)
@@ -82,14 +89,14 @@ module RunLoop
       FileUtils.mkdir_p(results_dir_trace)
 
       dependencies = options[:dependencies] || []
-      dependencies << File.join(scripts_path, 'calabash_script_uia.js')
+      dependencies << File.join(SCRIPTS_PATH, 'calabash_script_uia.js')
       dependencies.each do |dep|
         FileUtils.cp(dep, results_dir)
       end
 
       script = File.join(results_dir, '_run_loop.js')
 
-      javascript = UIAScriptTemplate.new(SCRIPTS_PATH, options[:script]).result
+      javascript = UIAScriptTemplate.new(SCRIPTS_PATH, instruments_script).result
       UIAScriptTemplate.sub_path_var!(javascript, results_dir)
       UIAScriptTemplate.sub_read_script_path_var!(javascript, READ_SCRIPT_PATH)
       UIAScriptTemplate.sub_timeout_script_path_var!(javascript, TIMEOUT_SCRIPT_PATH)
@@ -137,7 +144,8 @@ module RunLoop
           :results_dir => results_dir,
           :script => script,
           :log_file => log_file,
-          :args => args
+          :args => args,
+          :uia_strategy => uia_strategy
         }
       merged_options = options.merge(discovered_options)
 
@@ -314,8 +322,7 @@ Logfile: #{log_file}
             begin
               FileUtils.rm_f(repl_path)
               return repl_path if system(%Q[mkfifo "#{repl_path}"])
-            rescue Errno::EINTR => e
-              #retry
+            rescue Errno::EINTR => _
               sleep(0.1)
             end
           end
@@ -516,7 +523,7 @@ Logfile: #{log_file}
     def self.detect_connected_device
       begin
         Timeout::timeout(1, RunLoop::TimeoutError) do
-          return `#{File.join(scripts_path, 'udidetect')}`.chomp
+          return `#{File.join(SCRIPTS_PATH, 'udidetect')}`.chomp
         end
       rescue RunLoop::TimeoutError => _
         `killall udidetect &> /dev/null`
@@ -670,6 +677,45 @@ Logfile: #{log_file}
       strategy
     end
 
+    # @!visibility private
+    #
+    # There is an unnatural relationship between the :script and the
+    # :uia_strategy keys.
+    #
+    # @param [Hash] options The launch options passed to .run_with_options
+    # @param [RunLoop::Device] device The device under test.
+    # @param [RunLoop::Xcode] xcode The active Xcode.
+    #
+    # @return [Hash] with two keys: :script and :uia_strategy
+    def self.detect_instruments_script_and_strategy(options, device, xcode)
+      strategy = options[:uia_strategy]
+      script = options[:script]
+
+      if script
+        script = self.expect_instruments_script(script)
+        if !strategy
+          strategy = :host
+        end
+      else
+        if strategy
+          script = self.instruments_script_for_uia_strategy(strategy)
+        else
+          if options[:calabash_lite]
+            strategy = :host
+            script = self.instruments_script_for_uia_strategy(strategy)
+          else
+            strategy = self.detect_uia_strategy(options, device, xcode)
+            script = self.instruments_script_for_uia_strategy(strategy)
+          end
+        end
+      end
+
+      {
+        :script => script,
+        :strategy => strategy
+      }
+    end
+
     # @!visibility private
     #
     # UIAutomation buffers log output in some very strange ways.  RunLoop
@@ -760,5 +806,48 @@ Logfile: #{log_file}
 
       RunLoop.log_debug("Simulator instruction set '#{device.instruction_set}' is compatible with '#{lipo.info}'")
     end
+
+    # @!visibility private
+    def self.expect_instruments_script(script)
+      if script.is_a?(String)
+        unless File.exist?(script)
+          raise %Q[Expected instruments JavaScript file at path:
+
+#{script}
+
+Check the :script key in your launch options.]
+        end
+        script
+      elsif script.is_a?(Symbol)
+        path = self.script_for_key(script)
+        if !path
+          raise %Q[Expected :#{script} to be one of:
+
+#{Core::SCRIPTS.keys.map { |key| ":#{key}" }.join("\n")}
+
+Check the :script key in your launch options.]
+        end
+        path
+      else
+        raise %Q[Expected '#{script}' to be a Symbol or a String.
+
+Check the :script key in your launch options.]
+      end
+    end
+
+    # @!visibility private
+    def self.instruments_script_for_uia_strategy(uia_strategy)
+      case uia_strategy
+      when :preferences
+        self.script_for_key(:run_loop_fast_uia)
+      when :host
+        self.script_for_key(:run_loop_host)
+      when :shared_element
+        self.script_for_key(:run_loop_shared_element)
+      else
+        self.script_for_key(:run_loop_basic)
+      end
+    end
   end
 end
+

data/lib/run_loop/core_simulator.rb

@@ -847,7 +847,7 @@ Command had no output
       return true
     end
 
-    RunLoop.log_debug("The app you are are testing is not the same as the app that is installed.")
+    RunLoop.log_debug("The app you are testing is not the same as the app that is installed.")
     RunLoop.log_debug("  Installed app SHA: #{installed_sha}")
     RunLoop.log_debug("  App to launch SHA: #{app_sha}")
     RunLoop.log_debug("Will install #{app}")

data/lib/run_loop/detect_aut/xcode.rb

@@ -42,7 +42,9 @@ module RunLoop
       def ignore_xcodeproj?(path)
         path[/CordovaLib/, 0] ||
           path[/Pods/, 0] ||
-          path[/Carthage/, 0]
+          path[/Carthage/, 0] ||
+          path[/Airship(Kit|Lib)/, 0] ||
+          path[/google-plus-ios-sdk/, 0]
       end
 
       # @!visibility private

data/lib/run_loop/device.rb

@@ -1,6 +1,7 @@
 module RunLoop
   class Device
 
+    require 'securerandom'
     include RunLoop::Regex
 
     # Starting in Xcode 7, iOS 9 simulators have a new "booting" state.
@@ -133,7 +134,7 @@ removed (1.5.0).  It has been replaced by an options hash with two keys:
     #
     # @param [Hash] options The launch options passed to RunLoop::Core
     # @param [RunLoop::Xcode] xcode An Xcode instance
-    # @param [RunLoop::Simctl] simctl A SimControl instance
+    # @param [RunLoop::Simctl] simctl A Simctl instance
     # @param [RunLoop::Instruments] instruments An Instruments instance
     #
     # @raise [ArgumentError] If "device" is detected as the device target and
@@ -318,130 +319,111 @@ version: #{version}
       end.call
     end
 
-    # @!visibility private
-    # Is this the first launch of this Simulator?
-    #
-    # TODO Needs unit and integration tests.
-    def simulator_first_launch?
-      megabytes = simulator_data_dir_size
-
-      if version >= RunLoop::Version.new('9.0')
-        megabytes < 20
-      elsif version >= RunLoop::Version.new('8.0')
-        megabytes < 12
-      else
-        megabytes < 8
-      end
-    end
-
-    # @!visibility private
-    # The size of the simulator data/ directory.
-    #
-    # TODO needs unit tests.
-    def simulator_data_dir_size
-      path = File.join(simulator_root_dir, 'data')
-      RunLoop::Directory.size(path, :mb)
-    end
-
     # @!visibility private
     #
     # Waits for three conditions:
     #
     # 1. The SHA sum of the simulator data/ directory to be stable.
-    # 2. No more log messages are begin generated
-    # 3. 1 and 2 must hold for 1 seconds.
+    # 2. No more log messages are begin generated.
+    # 3. 1 and 2 must hold for 1.5 seconds.
     #
-    # When the simulator version is >= iOS 9 _and_ it is the first launch of
-    # the simulator after a reset or a new simulator install, a fourth condition
-    # is added:
+    # When the simulator version is >= iOS 9, two more conditions are added to
+    # get past the iOS 9+ boot screen.
     #
-    # 4. The first three conditions must be met a second time.
+    # 4. Wait for com.apple.audio.SystemSoundServer-iOS-Simulator process to
+    #    start.
+    # 5. 1 and 2 must hold for 1.5 seconds.
     #
-    # and the quiet time is increased to 2.0.
+    # When the simulator version is >= iOS 9 and the device is an iPad another
+    # condition is added because simctl fails to correctly install applications;
+    # the app and data container exists, but Springboard does not detect them.
+    #
+    # 6. 1 and 2 must hold for 1.5 seconds.
     def simulator_wait_for_stable_state
-      require 'securerandom'
 
       # How long to wait between stability checks.
+      # Shorter than this gives false positives.
       delay = 0.5
 
-      first_launch = false
+      # How many times to wait for stable state.
+      max_stable_count = 3
 
-      # At launch there is a brief moment when the SHA and
-      # the log file are are stable.  Then a bunch of activity
-      # occurs.  This is the quiet time.
+      # How long to wait for iOS 9 boot screen.
+      boot_screen_wait_options = {
+        :max_boot_screen_wait => 10,
+        :raise_on_timeout => false
+      }
+
+      # How much additional time to wait for iOS 9+ iPads.
       #
-      # Starting in iOS 9, simulators display at _booting_ screen
-      # at first launch.  At first launch, these simulators need
-      # a much longer quiet time.
-      if version >= RunLoop::Version.new('9.0')
-        first_launch = simulator_data_dir_size < 20
-        quiet_time = 2.0
-      else
-        quiet_time = 1.0
+      # Installing and launching on iPads is problematic.
+      # Sometimes the app is installed, but SpringBoard does
+      # not recognize that the app is installed even though
+      # simctl says that it is.
+      additional_ipad_delay = delay * 2
+
+      # Adjust for CI environments
+      if RunLoop::Environment.ci?
+        max_stable_count = 5
+        boot_screen_wait_options[:max_boot_screen_wait] = 20
+        additional_ipad_delay = delay * 4
       end
 
-      now = Time.now
-      timeout = SIM_STABLE_STATE_OPTIONS[:timeout]
-      poll_until = now + timeout
-      quiet = now + quiet_time
+      # iOS 9 simulators have an additional boot screen.
+      is_gte_ios9 = version >= RunLoop::Version.new('9.0')
 
-      is_stable = false
+      # iOS 9 iPad simulators need additional time to stabilize.
+      is_ipad = simulator_is_ipad?
 
-      path = File.join(simulator_root_dir, 'data')
-      current_sha = nil
-      sha_fn = lambda do |data_dir|
-        begin
-          # Typically, this returns in < 0.3 seconds.
-          Timeout.timeout(10, TimeoutError) do
-            # Errors are ignorable and users are confused by the messages.
-            options = { :handle_errors_by => :ignoring }
-            RunLoop::Directory.directory_digest(data_dir, options)
-          end
-        rescue => _
-          SecureRandom.uuid
-        end
-      end
+      timeout = SIM_STABLE_STATE_OPTIONS[:timeout]
+      now = Time.now
+      poll_until = now + timeout
 
-      RunLoop.log_debug("Waiting for simulator to stabilize with timeout: #{timeout}")
-      if first_launch
-        RunLoop.log_debug("Detected the first launch of an iOS >= 9.0 Simulator")
-      end
+      RunLoop.log_debug("Waiting for simulator to stabilize with timeout: #{timeout} seconds")
 
-      current_line = nil
+      current_dir_sha = simulator_data_directory_sha
+      current_log_sha = simulator_log_file_sha
+      is_stable = false
+      waited_for_boot = false
+      waited_for_ipad = false
+      stable_count = 0
 
       while Time.now < poll_until do
-        latest_sha = sha_fn.call(path)
-        latest_line = last_line_from_simulator_log_file
+        latest_dir_sha = simulator_data_directory_sha
+        latest_log_sha = simulator_log_file_sha
 
-        is_stable = current_sha == latest_sha && current_line == latest_line
+        is_stable = [current_dir_sha == latest_dir_sha,
+                     current_log_sha == latest_log_sha].all?
 
         if is_stable
-          if Time.now > quiet
-            if first_launch
-              RunLoop.log_debug('First launch detected - allowing additional time to stabilize')
-              first_launch = false
-              sleep 1.2
-              quiet = Time.now + quiet_time
+          stable_count = stable_count + 1
+          if stable_count == max_stable_count
+            if is_gte_ios9 && !waited_for_boot
+              process_name = "com.apple.audio.SystemSoundServer-iOS-Simulator"
+              RunLoop::ProcessWaiter.new(process_name, boot_screen_wait_options).wait_for_any
+              waited_for_boot = true
+              stable_count = 0
+            elsif is_gte_ios9 && is_ipad && !waited_for_ipad
+              RunLoop.log_debug("Waiting additional time for iOS 9 iPad to stabilize")
+              sleep(additional_ipad_delay)
+              waited_for_ipad = true
+              stable_count = 0
             else
               break
             end
-          else
-            quiet = Time.now + quiet_time
           end
         end
 
-        current_sha = latest_sha
-        current_line = latest_line
-        sleep delay
+        current_dir_sha = latest_dir_sha
+        current_log_sha = latest_log_sha
+        sleep(delay)
       end
 
       if is_stable
         elapsed = Time.now - now
-        stabilized = elapsed - quiet_time
-        RunLoop.log_debug("Simulator stable after #{stabilized} seconds")
         RunLoop.log_debug("Waited a total of #{elapsed} seconds for simulator to stabilize")
       else
-        RunLoop.log_debug("Timed out: simulator not stable after #{timeout} seconds")
+        RunLoop.log_debug("Timed out after #{timeout} seconds waiting for simulator to stabilize")
       end
     end
 
@@ -530,33 +512,6 @@ version: #{version}
 
     private
 
-    # @!visibility private
-    # TODO write a unit test.
-    def last_line_from_simulator_log_file
-      file = simulator_log_file_path
-
-      return nil if !File.exist?(file)
-
-      debug = RunLoop::Environment.debug?
-
-      begin
-        io = File.open(file, 'r')
-        io.seek(-100, IO::SEEK_END)
-
-        line = io.readline
-      rescue StandardError => e
-        RunLoop.log_error("Caught #{e} while reading simulator log file") if debug
-      ensure
-        io.close if io && !io.closed?
-      end
-
-      if line
-        line.chomp
-      else
-        line
-      end
-    end
-
     # @!visibility private
     def xcrun
       RunLoop::Xcrun.new
@@ -650,6 +605,50 @@ version: #{version}
       udid
     end
 
+    # @!visibility private
+    def simulator_data_directory_sha
+      path = File.join(simulator_root_dir, 'data')
+      begin
+        # Typically, this returns in < 0.3 seconds.
+        Timeout.timeout(10, TimeoutError) do
+          # Errors are ignorable and users are confused by the messages.
+          options = { :handle_errors_by => :ignoring }
+          RunLoop::Directory.directory_digest(path, options)
+        end
+      rescue => _
+        SecureRandom.uuid
+      end
+    end
+
+    # @!visibility private
+    def simulator_log_file_sha
+      file = simulator_log_file_path
+
+      return nil if !File.exist?(file)
+
+      sha = OpenSSL::Digest::SHA256.new
+
+      begin
+        sha << File.read(file)
+      rescue => _
+        sha = SecureRandom.uuid
+      end
+
+      sha
+    end
+
+    # @!visibility private
+    # Value of <UDID>/.device.plist 'deviceType' key.
+    def simulator_device_type
+      plist = File.join(simulator_device_plist)
+      pbuddy.plist_read("deviceType", plist)
+    end
+
+    # @!visibility private
+    def simulator_is_ipad?
+      simulator_device_type[/iPad/, 0]
+    end
+
     # @!visibility private
     def self.ensure_physical_device_connected(identifier, options)
       if identifier.nil?

data/lib/run_loop/encoding.rb

@@ -0,0 +1,39 @@
+
+module RunLoop
+  module Encoding
+
+    # Raised when a string cannot be coerced to UTF8
+    class UTF8Error < RuntimeError; end
+
+    # @!visibility private
+    def ensure_command_output_utf8(string, command)
+      return '' if !string
+
+      utf8 = string.force_encoding("UTF-8").chomp
+
+      return utf8 if utf8.valid_encoding?
+
+      encoded = utf8.encode("UTF-8", "UTF-8",
+                            invalid: :replace,
+                            undef: :replace,
+                            replace: "")
+
+      return encoded if encoded.valid_encoding?
+
+      raise UTF8Error, %Q{
+Could not force UTF-8 encoding on this string:
+
+#{string}
+
+which is the output of this command:
+
+#{command}
+
+Please file an issue with a stacktrace and the text of this error.
+
+https://github.com/calabash/run_loop/issues
+      }
+    end
+  end
+end
+

data/lib/run_loop/environment.rb

@@ -15,7 +15,11 @@ module RunLoop
 
     # Returns true if Windows environment
     def self.windows_env?
-      RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+      if @@windows_env.nil?
+        @@windows_env = Environment.host_os_is_win?
+      end
+
+      @@windows_env
     end
 
     # Returns true if debugging is enabled.
@@ -256,5 +260,26 @@ Check your environment.]
         path
       end
     end
+
+    private
+
+    # @visibility private
+    WIN_PATTERNS = [
+      /bccwin/i,
+      /cygwin/i,
+      /djgpp/i,
+      /mingw/i,
+      /mswin/i,
+      /wince/i,
+    ]
+
+    # @!visibility private
+    @@windows_env = nil
+
+    # @!visibility private
+    def self.host_os_is_win?
+      ruby_platform = RbConfig::CONFIG["host_os"]
+      !!WIN_PATTERNS.find { |r| ruby_platform =~ r }
+    end
   end
 end

data/lib/run_loop/physical_device/ideviceinstaller.rb

@@ -0,0 +1,221 @@
+module RunLoop
+  # @!visibility private
+  module PhysicalDevice
+
+    # @!visibility private
+    class IDeviceInstaller < LifeCycle
+
+      # Is the tool installed?
+      def self.tool_is_installed?
+        raise RunLoop::Abstract::AbstractMethodError,
+          "Subclass must implement '.tool_is_installed?'"
+      end
+
+      # Path to tool.
+      def self.executable_path
+        raise RunLoop::Abstract::AbstractMethodError,
+          "Subclass must implement '.executable_path'"
+      end
+
+      # Is the app installed?
+      #
+      # @return [Boolean] true or false
+      def app_installed?(bundle_id)
+        abstract_method!
+      end
+
+      # Install the app or ipa.
+      #
+      # If the app is already installed, it will be reinstalled from disk;
+      # no version check is performed.
+      #
+      # App data is never preserved.  If you want to preserve the app data,
+      # call `ensure_app_installed`.
+      #
+      # Possible return values:
+      #
+      # * :reinstalled => app was installed, but app data was not preserved.
+      # * :installed => app was not installed.
+      #
+      # @raise [InstallError] If app was not installed.
+      # @return [Symbol] A keyword describing the action that was performed.
+      def install_app(app_or_ipa)
+        abstract_method!
+      end
+
+      # Uninstall the app with bundle_id.
+      #
+      # App data is never preserved.  If you want to install a new version of
+      # an app and preserve app data (upgrade testing), call
+      # `ensure_app_installed`.
+      #
+      # Possible return values:
+      #
+      # * :nothing => app was not installed
+      # * :uninstall => app was uninstalled
+      #
+      # @raise [UninstallError] If the app cannot be uninstalled, usually
+      #   because it is a system app.
+      # @return [Symbol] A keyword that describes what action was performed.
+      def uninstall_app(bundle_id)
+        abstract_method!
+      end
+
+      # Ensures the app is installed and ensures that app is not stale by
+      # asking if the version of installed app is different than the version
+      # of the app or ipa on disk.
+      #
+      # The concrete implementation needs to check the CFBundleVersion and
+      # the CFBundleShortVersionString.  If either are different, then the
+      # app should be reinstalled.
+      #
+      # If possible, the app data should be preserved across reinstallation.
+      #
+      # Possible return values:
+      #
+      # * :nothing => app was already installed and versions matched.
+      # * :upgraded => app was stale; newer version from disk was installed and
+      #                app data was preserved.
+      # * :reinstalled => app was stale; newer version from disk was installed,
+      #                   but app data was not preserved.
+      # * :installed => app was not installed.
+      #
+      # @raise [InstallError] If the app could not be installed.
+      # @raise [UninstallError] If the app could not be uninstalled.
+      #
+      # @return [Symbol] A keyword that describes the action that was taken.
+      def ensure_app_installed(app_or_ipa)
+        abstract_method!
+      end
+
+      # Is the app on disk the same as the installed app?
+      #
+      # The concrete implementation needs to check the CFBundleVersion and
+      # the CFBundleShortVersionString. If either are different, then this
+      # method returns false.
+      #
+      # @raise [RuntimeError] If app is not already installed.
+      def installed_app_same_as?(app_or_ipa)
+        abstract_method!
+      end
+
+      # Clear the app sandbox.
+      #
+      # This method will never uninstall the app.  If the concrete
+      # implementation cannot reset the app data, this method should raise
+      # an exception.
+      #
+      # Does not clear Keychain.  Use the Calabash iOS Keychain API.
+      def reset_app_sandbox(bundle_id)
+        abstract_method!
+      end
+
+      # Return the architecture of the device.
+      def architecture
+        abstract_method!
+      end
+
+      # Is the app or ipa compatible with the architecture of the device?
+      def app_has_compatible_architecture?(app_or_ipa)
+        abstract_method!
+      end
+
+      # Return true if the device is an iPhone.
+      def iphone?
+        abstract_method!
+      end
+
+      # Return false if the device is an iPad.
+      def ipad?
+        abstract_method!
+      end
+
+      # Return the model of the device.
+      def model
+        abstract_method!
+      end
+
+      # Sideload data into the app's sandbox.
+      #
+      # These directories exist in the application sandbox.
+      #
+      # * sandbox/Documents
+      # * sandbox/Library
+      # * sandbox/Preferences
+      # * sandbox/tmp
+      #
+      # The data is a hash of arrays that define source/target file
+      # path pairs.
+      #
+      #  {
+      #    :documents => [
+      #      {
+      #        :source => "path/to/file/on/disk",
+      #        :target => "sub/dir/under/Documents"
+      #      },
+      #      {
+      #        :source => "path/to/other/file",
+      #        :target => "./"
+      #      }
+      #    ],
+      #
+      #    :library => [ < ditto >],
+      #    :preferences => [ < ditto > ],
+      #    :tmp => [ < ditto >]
+      #  }
+      #
+      # * If a file exists at a target path, it will be replaced.
+      # * Subdirectories will be created as necessary.
+      # * :source files must exist.
+      def sideload(data)
+        abstract_method!
+      end
+
+      # Removes a file or directory from the app sandbox.
+      #
+      # If the path does not exist, no error will be raised.
+      #
+      # Documents, Library, Preferences, and tmp directories will be
+      # deleted, but then recreated.  For example:
+      #
+      #  remove_file_from_sandbox("Preferences")
+      #
+      # The Preferences directory will be deleted and then recreated.
+      def remove_from_sandbox(path)
+        abstract_method!
+      end
+
+      # @!visibility private
+      def expect_app_or_ipa(app_or_ipa)
+        if ![is_app?(app_or_ipa), is_ipa?(app_or_ipa)].any?
+          if app_or_ipa.nil?
+            object = "nil"
+          elsif app_or_ipa == ""
+            object = "<empty string>"
+          else
+            object = app_or_ipa
+          end
+
+          raise ArgumentError, %Q[Expected:
+
+#{object}
+
+to be a RunLoop::App or a RunLoop::Ipa.]
+        end
+
+        true
+      end
+
+      # @!visibility private
+      def is_app?(app_or_ipa)
+        app_or_ipa.is_a?(RunLoop::App)
+      end
+
+      # @!visibility private
+      def is_ipa?(app_or_ipa)
+        app_or_ipa.is_a?(RunLoop::Ipa)
+      end
+    end
+  end
+end
+

data/lib/run_loop/shell.rb

@@ -0,0 +1,103 @@
+module RunLoop
+  module Shell
+
+    require "command_runner"
+    require "run_loop/encoding"
+    include RunLoop::Encoding
+
+    # Controls the behavior of Shell#exec.
+    #
+    # You can override these values if they do not work in your environment.
+    #
+    # For cucumber users, the best place to override would be in your
+    # features/support/env.rb.
+    #
+    # For example:
+    #
+    # RunLoop::Shell::DEFAULT_OPTIONS[:timeout] = 60
+    DEFAULT_OPTIONS = {
+      :timeout => 30,
+      :log_cmd => false
+    }
+
+    # Raised when shell command fails.
+    class Error < RuntimeError; end
+
+    # Raised when shell command times out.
+    class TimeoutError < RuntimeError; end
+
+    def exec(args, options={})
+
+      merged_options = DEFAULT_OPTIONS.merge(options)
+
+      timeout = merged_options[:timeout]
+
+      unless args.is_a?(Array)
+        raise ArgumentError,
+              "Expected args '#{args}' to be an Array, but found '#{args.class}'"
+      end
+
+      args.each do |arg|
+        unless arg.is_a?(String)
+          raise ArgumentError,
+%Q{Expected arg '#{arg}' to be a String, but found '#{arg.class}'
+IO.popen requires all arguments to be Strings.
+}
+        end
+      end
+
+      cmd = "#{args.join(' ')}"
+
+      # Don't see your log?
+      # Commands are only logged when debugging.
+      RunLoop.log_unix_cmd(cmd) if merged_options[:log_cmd]
+
+      hash = {}
+
+      begin
+
+        start_time = Time.now
+        command_output = CommandRunner.run(args, timeout: timeout)
+
+        out = ensure_command_output_utf8(command_output[:out], cmd)
+        process_status = command_output[:status]
+
+        hash =
+              {
+                    :out => out,
+                    :pid => process_status.pid,
+                    # nil if process was killed before completion
+                    :exit_status => process_status.exitstatus
+              }
+
+      rescue RunLoop::Encoding::UTF8Error => e
+        raise e
+      rescue => e
+        elapsed = "%0.2f" % (Time.now - start_time)
+        raise Error,
+%Q{Encountered an error after #{elapsed} seconds:
+
+#{e.message}
+
+executing this command:
+
+#{cmd}
+}
+      end
+
+      if hash[:exit_status].nil?
+        elapsed = "%0.2f" % (Time.now - start_time)
+        raise TimeoutError,
+%Q{Timed out after #{elapsed} seconds executing
+
+#{cmd}
+
+with a timeout of #{timeout}
+}
+      end
+
+      hash
+    end
+  end
+end
+

data/lib/run_loop/version.rb

@@ -1,5 +1,5 @@
 module RunLoop
-  VERSION = "2.1.1"
+  VERSION = "2.1.2"
 
   # A model of a software release version that can be used to compare two versions.
   #

data/lib/run_loop/xcrun.rb

@@ -1,7 +1,9 @@
 module RunLoop
   class Xcrun
 
-    require 'command_runner'
+    require "command_runner"
+    require "run_loop/encoding"
+    include RunLoop::Encoding
 
     # Controls the behavior of Xcrun#exec.
     #
@@ -21,9 +23,6 @@ module RunLoop
     # Raised when Xcrun fails.
     class Error < RuntimeError; end
 
-    # Raised when the output of the command cannot be coerced to UTF8
-    class UTF8Error < RuntimeError; end
-
     # Raised when Xcrun times out.
     class TimeoutError < RuntimeError; end
 
@@ -60,7 +59,7 @@ IO.popen requires all arguments to be Strings.
         start_time = Time.now
         command_output = CommandRunner.run(['xcrun'] + args, timeout: timeout)
 
-        out = encode_utf8_or_raise(command_output[:out], cmd)
+        out = ensure_command_output_utf8(command_output[:out], cmd)
         process_status = command_output[:status]
 
         hash =
@@ -71,7 +70,7 @@ IO.popen requires all arguments to be Strings.
                     :exit_status => process_status.exitstatus
               }
 
-      rescue UTF8Error => e
+      rescue RunLoop::Encoding::UTF8Error => e
         raise e
       rescue => e
         elapsed = "%0.2f" % (Time.now - start_time)
@@ -99,35 +98,6 @@ with a timeout of #{timeout}
 
       hash
     end
-
-    private
-
-    # @!visibility private
-    def encode_utf8_or_raise(string, command)
-      return '' if !string
-
-      utf8 = string.force_encoding("UTF-8").chomp
-
-      return utf8 if utf8.valid_encoding?
-
-      encoded = utf8.encode('UTF-8', 'UTF-8', invalid: :replace, undef: :replace, replace: '')
-
-      return encoded if encoded.valid_encoding?
-
-        raise UTF8Error, %Q{
-Could not force UTF-8 encoding on this string:
-
-#{string}
-
-which is the output of this command:
-
-#{command}
-
-Please file an issue with a stacktrace and the text of this error.
-
-https://github.com/calabash/run_loop/issues
-}
-    end
   end
 end
 

data/lib/run_loop/xcuitest.rb

@@ -126,7 +126,7 @@ module RunLoop
     # @!visibility private
     def query(mark)
       options = http_options
-      parameters = { :text => mark }
+      parameters = { :id => mark }
       request = request("query", parameters)
       client = client(options)
       response = client.post(request)
@@ -135,10 +135,19 @@ module RunLoop
 
     # @!visibility private
     def tap_mark(mark)
+      body = query(mark)
+      tap_query_result(body)
+    end
+
+    # @!visibility private
+    def tap_coordinate(x, y)
       options = http_options
       parameters = {
-        :gesture => "tap",
-        :text => mark
+        :gesture => "touch",
+        :specifiers => {
+          :coordinate => {x: x, y: y}
+        },
+        :options => {}
       }
       request = request("gesture", parameters)
       client(options)
@@ -147,14 +156,31 @@ module RunLoop
     end
 
     # @!visibility private
-    def tap_coordinate(x, y)
-      options = http_options
+    def rotate_home_button_to(position, sleep_for=1.0)
+      orientation = orientation_for_position(position)
+      parameters = {
+        :orientation => orientation
+      }
+      request = request("rotate_home_button_to", parameters)
+      client(http_options)
+      response = client.post(request)
+      json = expect_200_response(response)
+      sleep(sleep_for)
+      json
+    end
+
+    # @!visibility private
+    def perform_coordinate_gesture(gesture, x, y, options={})
       parameters = {
-        :gesture => "tap_coordinate",
-        :coordinate => {x: x, y: y}
+        :gesture => gesture,
+        :specifiers => {
+          :coordinate => {x: x, y: y}
+        },
+        :options => options
       }
+
       request = request("gesture", parameters)
-      client(options)
+      client(http_options)
       response = client.post(request)
       expect_200_response(response)
     end
@@ -273,7 +299,7 @@ module RunLoop
         5.times do
           begin
             health
-            sleep(0.2)
+            sleep(1.0)
           rescue => _
             break
           end
@@ -299,6 +325,10 @@ module RunLoop
 
     # @!visibility private
     def xcodebuild
+      env = {
+        "COMMAND_LINE_BUILD" => "1"
+      }
+
       args = [
         "xcrun",
         "xcodebuild",
@@ -318,10 +348,10 @@ module RunLoop
         :err => log_file
       }
 
-      command = args.join(" ")
+      command = "#{env.map.each { |k, v| "#{k}=#{v}" }.join(" ")} #{args.join(" ")}"
       RunLoop.log_unix_cmd("#{command} >& #{log_file}")
 
-      pid = Process.spawn(*args, options)
+      pid = Process.spawn(env, *args, options)
       Process.detach(pid)
       pid
     end
@@ -334,6 +364,9 @@ module RunLoop
 
       shutdown
 
+      # Temp measure; we need to manage the xcodebuild pids.
+      system("pkill xcodebuild")
+
       if device.simulator?
         # quits the simulator
         sim = CoreSimulator.new(device, "")
@@ -361,7 +394,9 @@ module RunLoop
         RunLoop.log_debug("Launched #{bundle_id} on #{device}")
         RunLoop.log_debug("#{response.body}")
         if device.simulator?
-          device.simulator_wait_for_stable_state
+          # It is not clear yet whether we should do this.  There is a problem
+          # in the simulator_wait_for_stable_state; it waits too long.
+          # device.simulator_wait_for_stable_state
         end
         expect_200_response(response)
       rescue => e
@@ -409,6 +444,28 @@ Server replied with:
 
       path
     end
+
+    # @!visibility private
+    def orientation_for_position(position)
+      symbol = position.to_sym
+
+      case symbol
+        when :down, :bottom
+          return 1
+        when :up, :top
+          return 2
+        when :right
+          return 3
+        when :left
+          return 4
+        else
+          raise ArgumentError, %Q[
+Could not coerce '#{position}' into a valid orientation.
+
+Valid values are: :down, :up, :right, :left, :bottom, :top
+]
+      end
+    end
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: run_loop
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.1.2
 platform: ruby
 authors:
 - Karl Krukow
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-17 00:00:00.000000000 Z
+date: 2016-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -212,6 +212,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: listen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.6
 - !ruby/object:Gem::Dependency
   name: growl
   requirement: !ruby/object:Gem::Requirement
@@ -304,6 +318,7 @@ files:
 - lib/run_loop/directory.rb
 - lib/run_loop/dot_dir.rb
 - lib/run_loop/dylib_injector.rb
+- lib/run_loop/encoding.rb
 - lib/run_loop/environment.rb
 - lib/run_loop/fifo.rb
 - lib/run_loop/host_cache.rb
@@ -321,10 +336,12 @@ files:
 - lib/run_loop/logging.rb
 - lib/run_loop/otool.rb
 - lib/run_loop/patches/awesome_print.rb
+- lib/run_loop/physical_device/ideviceinstaller.rb
 - lib/run_loop/plist_buddy.rb
 - lib/run_loop/process_terminator.rb
 - lib/run_loop/process_waiter.rb
 - lib/run_loop/regex.rb
+- lib/run_loop/shell.rb
 - lib/run_loop/sim_control.rb
 - lib/run_loop/simctl.rb
 - lib/run_loop/strings.rb
@@ -367,7 +384,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: The bridge between Calabash iOS and Xcode command-line tools like instruments