run_loop 2.0.10.pre1 → 2.1.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7d2bb26dc2c4256fc698902883a2c1ab14e3fc64
-  data.tar.gz: 1e52a50fa5717c9ad21afaaf51e4ae014b20ef27
+  metadata.gz: 7ea9c17ad6325b7381a689e16ea30c98b34e2765
+  data.tar.gz: a1f044d25c196213e310f2f70f096f35bb558c65
 SHA512:
-  metadata.gz: e33dee1343def117171e6efc85d384400c9a67c9542cded949a856866c3411daaa053b435fc00031d14d04e7dcc0e89da223117ac863a7b17776973d5ce9069a
-  data.tar.gz: 93e99e9e49920d2cf47fbd8021f2468e1cc74b653268708a95ee648626959de854cd2edb7ee2fb01db6d39aadd04b1d0ab5f1eac97c6525b3d82247c29ad6b18
+  metadata.gz: 49f63b7057fb4448850252365b840843b05a4ac39f81db367dd32a52d0b23dc0cdcb67c8de22e4838f02bfb81ef7f2bf3c189da4d4953a008f1812b6bd108326
+  data.tar.gz: 30aed60ffb8069e15260ea81f02fa8a2261a59e473fcd4beaeacfcec940030671c6eb730423d088f73864cfc66daf18972df60a0cfc671013ed61e7f3b8f293f

data/lib/run_loop/core.rb

@@ -57,179 +57,24 @@ module RunLoop
       SCRIPTS[key]
     end
 
-    def self.detect_connected_device
-      begin
-        Timeout::timeout(1, RunLoop::TimeoutError) do
-          return `#{File.join(scripts_path, 'udidetect')}`.chomp
-        end
-      rescue RunLoop::TimeoutError => _
-        `killall udidetect &> /dev/null`
-      end
-      nil
-    end
-
-    # @deprecated 1.5.2 No public replacement.
-    #
-    # Raise an error if the application binary is not compatible with the
-    # target simulator.
-    #
-    # @note This method is implemented for CoreSimulator environments only;
-    #  for Xcode < 6.0 this method does nothing.
-    #
-    # @param [Hash] launch_options These options need to contain the app bundle
-    #   path and a udid that corresponds to a simulator name or simulator udid.
-    #   In practical terms:  call this after merging the original launch
-    #   options with those options that are discovered.
-    #
-    # @param [RunLoop::SimControl] sim_control A simulator control object.
-    # @raise [RuntimeError] Raises an error if the `launch_options[:udid]`
-    #  cannot be used to find a simulator.
-    # @raise [RunLoop::IncompatibleArchitecture] Raises an error if the
-    #  application binary is not compatible with the target simulator.
-    def self.expect_compatible_simulator_architecture(launch_options, sim_control)
-      RunLoop.deprecated('1.5.2', 'No public replacement.')
-      logger = launch_options[:logger]
-      if sim_control.xcode_version_gte_6?
-        sim_identifier = launch_options[:udid]
-        simulator = sim_control.simulators.find do |simulator|
-          [simulator.instruments_identifier(sim_control.xcode),
-           simulator.udid].include?(sim_identifier)
-        end
-
-        if simulator.nil?
-          raise "Could not find simulator with identifier '#{sim_identifier}'"
-        end
-
-        lipo = RunLoop::Lipo.new(launch_options[:bundle_dir_or_bundle_id])
-        lipo.expect_compatible_arch(simulator)
-        RunLoop::Logging.log_debug(logger, "Simulator instruction set '#{simulator.instruction_set}' is compatible with #{lipo.info}")
-        true
-      else
-        RunLoop::Logging.log_debug(logger, "Xcode #{sim_control.xcode_version} detected; skipping simulator architecture check.")
-        false
-      end
-    end
-
-    # Raise an error if the application binary is not compatible with the
-    # target simulator.
-    #
-    # @note This method is implemented for CoreSimulator environments only;
-    #  for Xcode < 6.0 this method does nothing.
-    #
-    # @param [RunLoop::Device] device The device to install on.
-    # @param [RunLoop::App] app The app to install.
-    # @param [RunLoop::Xcode] xcode The active Xcode.
-    #
-    # @raise [RunLoop::IncompatibleArchitecture] Raises an error if the
-    #  application binary is not compatible with the target simulator.
-    def self.expect_simulator_compatible_arch(device, app, xcode)
-      if !xcode.version_gte_6?
-        RunLoop.log_warn("Checking for compatible arches is only available in CoreSimulator environments")
-        return
-      end
-
-      lipo = RunLoop::Lipo.new(app.path)
-      lipo.expect_compatible_arch(device)
-
-      RunLoop.log_debug("Simulator instruction set '#{device.instruction_set}' is compatible with '#{lipo.info}'")
-    end
-
-    # Prepares the simulator for running.
-    #
-    # 1. enabling accessibility and software keyboard
-    # 2. installing / uninstalling apps
-    def self.prepare_simulator(launch_options, sim_control)
-
-      xcode = sim_control.xcode
-
-      # Respect option passed from Calabash
-      if launch_options[:relaunch_simulator]
-        sim_control.quit_sim
-      end
-
-      if !xcode.version_gte_6?
-        # Xcode 5.1.1
-
-        # Will quit the simulator!
-        sim_control.enable_accessibility_on_sims({:verbose => false})
-      else
-
-        # CoreSimulator
-
-        app_bundle_path = launch_options[:bundle_dir_or_bundle_id]
-        app = RunLoop::App.new(app_bundle_path)
-
-        unless app.valid?
-          if !File.exist?(app.path)
-            message = "App '#{app_bundle_path}' does not exist."
-          else
-            message = "App '#{app_bundle_path}' is not a valid .app bundle"
-          end
-          raise RuntimeError, message
-        end
-
-        udid = launch_options[:udid]
-
-        device = sim_control.simulators.find do |sim|
-          sim.udid == udid || sim.instruments_identifier(xcode) == udid
-        end
-
-        if device.nil?
-          raise RuntimeError,
-                "Could not find simulator with name or UDID that matches: '#{udid}'"
-        end
-
-        # Validate the architecture.
-        self.expect_simulator_compatible_arch(device, app, xcode)
-
-        # Quits the simulator.
-        core_sim = RunLoop::CoreSimulator.new(device, app)
-
-        # :reset is a legacy variable; has been replaced with :reset_app_sandbox
-        if launch_options[:reset] || launch_options[:reset_app_sandbox]
-          core_sim.reset_app_sandbox
-        end
-
-        # Will quit the simulator if it is running.
-        # @todo fix accessibility_enabled? so we don't have to quit the sim
-        # SimControl#accessibility_enabled? is always false during Core#prepare_simulator
-        # https://github.com/calabash/run_loop/issues/167
-        sim_control.ensure_accessibility(device)
-
-        # Will quit the simulator if it is running.
-        # @todo fix software_keyboard_enabled? so we don't have to quit the sim
-        # SimControl#software_keyboard_enabled? is always false during Core#prepare_simulator
-        # https://github.com/calabash/run_loop/issues/168
-        sim_control.ensure_software_keyboard(device)
-
-        # Launches the simulator if the app is not installed.
-        core_sim.install
-
-        # If CoreSimulator has already launched the simulator, it will not
-        # launching it again.
-        core_sim.launch_simulator
-      end
-    end
-
     def self.run_with_options(options)
       before = Time.now
 
       self.prepare(options)
 
       logger = options[:logger]
-      sim_control ||= options[:sim_control] || RunLoop::SimControl.new
+      sim_control = options[:sim_control] || options[:simctl] || RunLoop::SimControl.new
+      xcode = options[:xcode] || RunLoop::Xcode.new
+      instruments = options[:instruments] || RunLoop::Instruments.new
 
-      xcode ||= options[:xcode] || sim_control.xcode
+      # Find the Device under test, the App under test, UIA strategy, and reset options
+      device = RunLoop::Device.detect_device(options, xcode, sim_control, instruments)
+      app_details = RunLoop::DetectAUT.detect_app_under_test(options)
+      uia_strategy = self.detect_uia_strategy(options, device, xcode)
+      reset_options = self.detect_reset_options(options)
 
-      instruments = RunLoop::Instruments.new
       instruments.kill_instruments(xcode)
 
-      device_target = options[:udid] || options[:device_target] || detect_connected_device || 'simulator'
-      if device_target && device_target.to_s.downcase == 'device'
-        device_target = detect_connected_device
-      end
-
-      log_file = options[:log_path]
       timeout = options[:timeout] || 30
 
       results_dir = options[:results_dir] || RunLoop::DotDir.make_results_dir
@@ -253,8 +98,6 @@ module RunLoop
       repl_path = File.join(results_dir, 'repl-cmd.pipe')
       FileUtils.rm_f(repl_path)
 
-      uia_strategy = options[:uia_strategy]
-
       if uia_strategy == :host
         create_uia_pipe(repl_path)
       else
@@ -271,39 +114,33 @@ module RunLoop
         file.puts code
       end
 
-      udid = options[:udid]
-      bundle_dir_or_bundle_id = options[:bundle_dir_or_bundle_id]
-
-      if !(udid && bundle_dir_or_bundle_id)
-        # Compute udid and bundle_dir / bundle_id from options and target depending on Xcode version
-        udid, bundle_dir_or_bundle_id = self.udid_and_bundle_for_launcher(device_target, options, sim_control)
-      end
-
       args = options.fetch(:args, [])
 
-      log_file ||= File.join(results_dir, 'run_loop.out')
+      log_file = options[:log_path] || File.join(results_dir, 'run_loop.out')
 
       discovered_options =
-            {
-                  :udid => udid,
-                  :results_dir_trace => results_dir_trace,
-                  :bundle_dir_or_bundle_id => bundle_dir_or_bundle_id,
-                  :results_dir => results_dir,
-                  :script => script,
-                  :log_file => log_file,
-                  :args => args
-            }
+        {
+          :udid => device.udid,
+          :device => device,
+          :results_dir_trace => results_dir_trace,
+          :bundle_id => app_details[:bundle_id],
+          :app => app_details[:app]  || app_details[:bundle_id],
+          :results_dir => results_dir,
+          :script => script,
+          :log_file => log_file,
+          :args => args
+        }
       merged_options = options.merge(discovered_options)
 
-      if self.simulator_target?(merged_options)
-        self.prepare_simulator(merged_options, sim_control)
+      if device.simulator?
+        self.prepare_simulator(app_details[:app], device, xcode, sim_control, reset_options)
       end
 
       self.log_run_loop_options(merged_options, xcode)
 
       automation_template = automation_template(instruments)
 
-      RunLoop::Logging.log_header(logger, "Starting on #{device_target} App: #{bundle_dir_or_bundle_id}")
+      RunLoop::Logging.log_header(logger, "Starting on #{device.name} App: #{app_details[:bundle_id]}")
 
       pid = instruments.spawn(automation_template, merged_options, log_file)
 
@@ -311,14 +148,16 @@ module RunLoop
         f.write pid
       end
 
-      run_loop = {:pid => pid,
-                  :index => 1,
-                  :uia_strategy => uia_strategy,
-                  :udid => udid,
-                  :app => bundle_dir_or_bundle_id,
-                  :repl_path => repl_path,
-                  :log_file => log_file,
-                  :results_dir => results_dir}
+      run_loop = {
+        :pid => pid,
+        :index => 1,
+        :uia_strategy => uia_strategy,
+        :udid => device.udid,
+        :app => app_details[:bundle_id],
+        :repl_path => repl_path,
+        :log_file => log_file,
+        :results_dir => results_dir
+      }
 
       uia_timeout = options[:uia_timeout] || RunLoop::Environment.uia_timeout || 10
 
@@ -326,8 +165,10 @@ module RunLoop
 
       before_instruments_launch = Time.now
 
-       fifo_retry_on = [RunLoop::Fifo::NoReaderConfiguredError,
-                        RunLoop::Fifo::WriteTimedOut]
+      fifo_retry_on = [
+        RunLoop::Fifo::NoReaderConfiguredError,
+        RunLoop::Fifo::WriteTimedOut
+      ]
 
       begin
 
@@ -364,9 +205,9 @@ module RunLoop
 
 Logfile: #{log_file}
 
-#{File.read(log_file)}
+        #{File.read(log_file)}
 
-)
+        )
         raise RunLoop::TimeoutError, message
       end
 
@@ -375,8 +216,11 @@ Logfile: #{log_file}
       dylib_path = self.dylib_path_from_options(merged_options)
 
       if dylib_path
-        RunLoop::LLDB.kill_lldb_processes
-        app = RunLoop::App.new(options[:app])
+        if device.physical_device?
+          raise RuntimeError, "Injecting a dylib is not supported when targeting a device"
+        end
+
+        app = app_details[:app]
         lldb = RunLoop::DylibInjector.new(app.executable_name, dylib_path)
         lldb.retriable_inject_dylib
       end
@@ -395,7 +239,7 @@ Logfile: #{log_file}
     def self.include_calabash_script?(options)
 
       if (options[:include_calabash_script] == false) || options[:dismiss_immediate_dialogs]
-         return false
+        return false
       end
       if Core.script_for_key(:run_loop_basic) == options[:script]
         return options[:include_calabash_script]
@@ -403,164 +247,71 @@ Logfile: #{log_file}
       true
     end
 
-    # @!visibility private
-    # Are we targeting a simulator?
-    #
-    # @note  The behavior of this method is different than the corresponding
-    #   method in Calabash::Cucumber::Launcher method.  If
-    #   `:device_target => {nil | ''}`, then the calabash-ios method returns
-    #   _false_.  I am basing run-loop's behavior off the behavior in
-    #   `self.udid_and_bundle_for_launcher`
+    # Extracts the value of :inject_dylib from options Hash.
+    # @param options [Hash] arguments passed to {RunLoop.run}
+    # @return [String, nil] If the options contains :inject_dylibs and it is a
+    #  path to a dylib that exists, return the path.  Otherwise return nil or
+    #  raise an error.
+    # @raise [RuntimeError] If :inject_dylib points to a path that does not exist.
+    # @raise [ArgumentError] If :inject_dylib is not a String.
+    def self.dylib_path_from_options(options)
+      inject_dylib = options.fetch(:inject_dylib, nil)
+      return nil if inject_dylib.nil?
+      unless inject_dylib.is_a? String
+        raise ArgumentError, "Expected :inject_dylib to be a path to a dylib, but found '#{inject_dylib}'"
+      end
+      dylib_path = File.expand_path(inject_dylib)
+      unless File.exist?(dylib_path)
+        raise "Cannot load dylib.  The file '#{dylib_path}' does not exist."
+      end
+      dylib_path
+    end
+
+    # Returns the a default simulator to target.  This default needs to be one
+    # that installed by default in the current Xcode version.
     #
-    # @see {Core::RunLoop.udid_and_bundle_for_launcher}
+    # For historical reasons, the most recent non-64b SDK should be used.
     #
-    # @todo sim_control argument is no longer necessary and can be removed.
-    def self.simulator_target?(run_options, sim_control=nil)
-      value = run_options[:device_target]
-
-      # Match the behavior of udid_and_bundle_for_launcher.
-      return true if value.nil? or value == ''
-
-      # 5.1 <= Xcode < 7.0
-      return true if value.downcase.include?('simulator')
-
-      # Not a physical device.
-      return false if value[DEVICE_UDID_REGEX, 0] != nil
-
-      # Check for named simulators and Xcode >= 7.0 simulators.
-      sim_control = run_options[:sim_control] || RunLoop::SimControl.new
-      xcode = sim_control.xcode
-      if xcode.version_gte_6?
-        simulator = sim_control.simulators.find do |sim|
-          [
-                sim.instruments_identifier(xcode) == value,
-                sim.udid == value,
-                sim.name == value
-          ].any?
-        end
-        !simulator.nil?
+    # @param [RunLoop::Xcode] xcode Used to detect the current xcode
+    #  version.
+    def self.default_simulator(xcode=RunLoop::Xcode.new)
+
+      if xcode.version_gte_73?
+        "iPhone 6s (9.3)"
+      elsif xcode.version_gte_72?
+        "iPhone 6s (9.2)"
+      elsif xcode.version_gte_71?
+        "iPhone 6s (9.1)"
+      elsif xcode.version_gte_7?
+        "iPhone 5s (9.0)"
+      elsif xcode.version_gte_64?
+        "iPhone 5s (8.4 Simulator)"
+      elsif xcode.version_gte_63?
+        "iPhone 5s (8.3 Simulator)"
+      elsif xcode.version_gte_62?
+        "iPhone 5s (8.2 Simulator)"
+      elsif xcode.version_gte_61?
+        "iPhone 5s (8.1 Simulator)"
       else
-        false
+        "iPhone 5s (8.0 Simulator)"
       end
     end
 
 
-  # Extracts the value of :inject_dylib from options Hash.
-  # @param options [Hash] arguments passed to {RunLoop.run}
-  # @return [String, nil] If the options contains :inject_dylibs and it is a
-  #  path to a dylib that exists, return the path.  Otherwise return nil or
-  #  raise an error.
-  # @raise [RuntimeError] If :inject_dylib points to a path that does not exist.
-  # @raise [ArgumentError] If :inject_dylib is not a String.
-  def self.dylib_path_from_options(options)
-    inject_dylib = options.fetch(:inject_dylib, nil)
-    return nil if inject_dylib.nil?
-    unless inject_dylib.is_a? String
-      raise ArgumentError, "Expected :inject_dylib to be a path to a dylib, but found '#{inject_dylib}'"
-    end
-    dylib_path = File.expand_path(inject_dylib)
-    unless File.exist?(dylib_path)
-      raise "Cannot load dylib.  The file '#{dylib_path}' does not exist."
-    end
-    dylib_path
-  end
-
-  # Returns the a default simulator to target.  This default needs to be one
-  # that installed by default in the current Xcode version.
-  #
-  # For historical reasons, the most recent non-64b SDK should be used.
-  #
-  # @param [RunLoop::Xcode] xcode Used to detect the current xcode
-  #  version.
-  def self.default_simulator(xcode=RunLoop::Xcode.new)
-
-    if xcode.version_gte_73?
-      "iPhone 6s (9.3)"
-    elsif xcode.version_gte_72?
-      "iPhone 6s (9.2)"
-    elsif xcode.version_gte_71?
-      "iPhone 6s (9.1)"
-    elsif xcode.version_gte_7?
-      "iPhone 5s (9.0)"
-    elsif xcode.version_gte_64?
-      "iPhone 5s (8.4 Simulator)"
-    elsif xcode.version_gte_63?
-      "iPhone 5s (8.3 Simulator)"
-    elsif xcode.version_gte_62?
-      "iPhone 5s (8.2 Simulator)"
-    elsif xcode.version_gte_61?
-      "iPhone 5s (8.1 Simulator)"
-    elsif xcode.version_gte_6?
-      "iPhone 5s (8.0 Simulator)"
-    else
-      "iPhone Retina (4-inch) - Simulator - iOS 7.1"
-    end
-  end
-
-  def self.udid_and_bundle_for_launcher(device_target, options, sim_control=RunLoop::SimControl.new)
-    xcode = sim_control.xcode
-
-    bundle_dir_or_bundle_id = options[:app] || RunLoop::Environment.bundle_id || RunLoop::Environment.path_to_app_bundle
-
-    unless bundle_dir_or_bundle_id
-      raise 'key :app or environment variable APP_BUNDLE_PATH, BUNDLE_ID or APP must be specified as path to app bundle (simulator) or bundle id (device)'
-    end
-
-    udid = nil
-
-    if xcode.version_gte_51?
-      if device_target.nil? || device_target.empty? || device_target == 'simulator'
-        device_target = self.default_simulator(xcode)
-      end
-      udid = device_target
-
-      unless self.simulator_target?(options)
-        bundle_dir_or_bundle_id = options[:bundle_id] if options[:bundle_id]
-      end
-    else
-      #TODO: this can be removed - Xcode < 5.1.1 not supported.
-      if device_target == 'simulator'
-
-        unless File.exist?(bundle_dir_or_bundle_id)
-          raise "Unable to find app in directory #{bundle_dir_or_bundle_id} when trying to launch simulator"
-        end
-
-
-        device = options[:device] || :iphone
-        device = device && device.to_sym
-
-        plistbuddy='/usr/libexec/PlistBuddy'
-        plistfile="#{bundle_dir_or_bundle_id}/Info.plist"
-        if device == :iphone
-          uidevicefamily=1
-        else
-          uidevicefamily=2
-        end
-        system("#{plistbuddy} -c 'Delete :UIDeviceFamily' '#{plistfile}'")
-        system("#{plistbuddy} -c 'Add :UIDeviceFamily array' '#{plistfile}'")
-        system("#{plistbuddy} -c 'Add :UIDeviceFamily:0 integer #{uidevicefamily}' '#{plistfile}'")
-      else
-        udid = device_target
-        bundle_dir_or_bundle_id = options[:bundle_id] if options[:bundle_id]
-      end
-    end
-    return udid, bundle_dir_or_bundle_id
-  end
-
-  def self.create_uia_pipe(repl_path)
-    begin
-      Timeout::timeout(5, RunLoop::TimeoutError) do
-        loop do
-          begin
-            FileUtils.rm_f(repl_path)
-            return repl_path if system(%Q[mkfifo "#{repl_path}"])
-          rescue Errno::EINTR => e
-            #retry
-            sleep(0.1)
+    def self.create_uia_pipe(repl_path)
+      begin
+        Timeout::timeout(5, RunLoop::TimeoutError) do
+          loop do
+            begin
+              FileUtils.rm_f(repl_path)
+              return repl_path if system(%Q[mkfifo "#{repl_path}"])
+            rescue Errno::EINTR => e
+              #retry
+              sleep(0.1)
+            end
           end
         end
-      end
-    rescue RunLoop::TimeoutError => _
+      rescue RunLoop::TimeoutError => _
         raise RunLoop::TimeoutError, 'Unable to create pipe (mkfifo failed)'
       end
     end
@@ -581,7 +332,7 @@ Logfile: #{log_file}
           RunLoop::Fifo.write(repl_path, cmd_str)
           write_succeeded = validate_index_written(run_loop, index, logger)
         rescue RunLoop::Fifo::NoReaderConfiguredError,
-               RunLoop::Fifo::WriteTimedOut => e
+          RunLoop::Fifo::WriteTimedOut => e
           RunLoop::Logging.log_debug(logger, "Error while writing command (retry count #{i}). #{e}")
         end
         break if write_succeeded
@@ -744,13 +495,91 @@ Logfile: #{log_file}
       end
 
       message = ['Expected instruments to report an Automation tracetemplate.',
-              'Please report this as bug:  https://github.com/calabash/run_loop/issues',
-              "In the bug report, include the output of:\n",
-              '$ xcrun xcodebuild -version',
-              "$ xcrun instruments -s templates\n"]
+                 'Please report this as bug:  https://github.com/calabash/run_loop/issues',
+                 "In the bug report, include the output of:\n",
+                 '$ xcrun xcodebuild -version',
+                 "$ xcrun instruments -s templates\n"]
       raise message.join("\n")
     end
 
+    # @deprecated 2.1.0
+    # Replaced with Device.detect_physical_device_on_usb
+    def self.detect_connected_device
+      begin
+        Timeout::timeout(1, RunLoop::TimeoutError) do
+          return `#{File.join(scripts_path, 'udidetect')}`.chomp
+        end
+      rescue RunLoop::TimeoutError => _
+        `killall udidetect &> /dev/null`
+      end
+      nil
+    end
+
+    # @deprecated 2.1.0
+    # @!visibility private
+    # Are we targeting a simulator?
+    #
+    # @note  The behavior of this method is different than the corresponding
+    #   method in Calabash::Cucumber::Launcher method.  If
+    #   `:device_target => {nil | ''}`, then the calabash-ios method returns
+    #   _false_.  I am basing run-loop's behavior off the behavior in
+    #   `self.udid_and_bundle_for_launcher`
+    #
+    # @see {Core::RunLoop.udid_and_bundle_for_launcher}
+    #
+    # @todo sim_control argument is no longer necessary and can be removed.
+    def self.simulator_target?(run_options, sim_control=nil)
+      # TODO Enable deprecation warning
+      # RunLoop.deprecated("2.1.0", "No replacement")
+      value = run_options[:device_target]
+
+      # Match the behavior of udid_and_bundle_for_launcher.
+      return true if value.nil? or value == ''
+
+      # 5.1 <= Xcode < 7.0
+      return true if value.downcase.include?('simulator')
+
+      # Not a physical device.
+      return false if value[DEVICE_UDID_REGEX, 0] != nil
+
+      # Check for named simulators and Xcode >= 7.0 simulators.
+      sim_control = run_options[:sim_control] || RunLoop::SimControl.new
+      xcode = sim_control.xcode
+      simulator = sim_control.simulators.find do |sim|
+        [
+          sim.instruments_identifier(xcode) == value,
+          sim.udid == value,
+          sim.name == value
+        ].any?
+      end
+      !simulator.nil?
+    end
+
+    # @!visibility private
+    # @deprecated 2.1.0
+    #
+    # Do not call this method.
+    def self.udid_and_bundle_for_launcher(device_target, options, sim_control=RunLoop::SimControl.new)
+      RunLoop.deprecated("2.1.0", "No replacement")
+      xcode = sim_control.xcode
+
+      bundle_dir_or_bundle_id = options[:app] || RunLoop::Environment.bundle_id || RunLoop::Environment.path_to_app_bundle
+
+      unless bundle_dir_or_bundle_id
+        raise 'key :app or environment variable APP_BUNDLE_PATH, BUNDLE_ID or APP must be specified as path to app bundle (simulator) or bundle id (device)'
+      end
+
+      if device_target.nil? || device_target.empty? || device_target == 'simulator'
+        device_target = self.default_simulator(xcode)
+      end
+      udid = device_target
+
+      unless self.simulator_target?(options)
+        bundle_dir_or_bundle_id = options[:bundle_id] if options[:bundle_id]
+      end
+      return udid, bundle_dir_or_bundle_id
+    end
+
     # @deprecated 1.0.5
     def self.ensure_instruments_not_running!
       RunLoop::Instruments.new.kill_instruments
@@ -794,10 +623,106 @@ Logfile: #{log_file}
 
     private
 
+    # @!visibility private
+    #
+    # @param [Hash] options The launch options passed to .run_with_options
     def self.prepare(run_options)
       RunLoop::DotDir.rotate_result_directories
       RunLoop::Instruments.rotate_cache_directories
       true
     end
+
+    # @!visibility private
+    #
+    # @param [RunLoop::Device] device The device under test.
+    # @param [RunLoop::Xcode] xcode The active Xcode
+    def self.default_uia_strategy(device, xcode)
+      if xcode.version_gte_7?
+        :host
+      elsif device.physical_device? && device.version >= RunLoop::Version.new("8.0")
+        :host
+      else
+        :preferences
+      end
+    end
+
+    # @!visibility private
+    #
+    # @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.
+    def self.detect_uia_strategy(options, device, xcode)
+      strategy = options[:uia_strategy] || self.default_uia_strategy(device, xcode)
+
+      if ![:host, :preferences, :shared_element].include?(strategy)
+        raise ArgumentError,
+              "Invalid strategy: expected '#{strategy}' to be :host, :preferences, or :shared_element"
+      end
+      strategy
+    end
+
+    # @!visibility private
+    #
+    # @param [Hash] options The launch options passed to .run_with_options
+    def self.detect_reset_options(options)
+      return options[:reset] if options.has_key?(:reset)
+
+      return options[:reset_app_sandbox] if options.has_key?(:reset_app_sandbox)
+
+      RunLoop::Environment.reset_between_scenarios?
+    end
+
+    # Prepares the simulator for running.
+    #
+    # 1. enabling accessibility and software keyboard
+    # 2. installing / uninstalling apps
+    def self.prepare_simulator(app, device, xcode, simctl, reset_options)
+
+      # Validate the architecture.
+      self.expect_simulator_compatible_arch(device, app)
+
+      # Quits the simulator.
+      core_sim = RunLoop::CoreSimulator.new(device, app, :xcode => xcode)
+
+      # Calabash 0.x can only reset the app sandbox (true/false).
+      # Calabash 2.x has advanced reset options.
+      if reset_options
+        core_sim.reset_app_sandbox
+      end
+
+      # Will quit the simulator if it is running.
+      # @todo fix accessibility_enabled? so we don't have to quit the sim
+      # SimControl#accessibility_enabled? is always false during Core#prepare_simulator
+      # https://github.com/calabash/run_loop/issues/167
+      simctl.ensure_accessibility(device)
+
+      # Will quit the simulator if it is running.
+      # @todo fix software_keyboard_enabled? so we don't have to quit the sim
+      # SimControl#software_keyboard_enabled? is always false during Core#prepare_simulator
+      # https://github.com/calabash/run_loop/issues/168
+      simctl.ensure_software_keyboard(device)
+
+      # Launches the simulator if the app is not installed.
+      core_sim.install
+
+      # If CoreSimulator has already launched the simulator, it will not launch it again.
+      core_sim.launch_simulator
+    end
+
+    # @!visibility private
+    # Raise an error if the application binary is not compatible with the
+    # target simulator.
+    #
+    # @param [RunLoop::Device] device The device to install on.
+    # @param [RunLoop::App] app The app to install.
+    #
+    # @raise [RunLoop::IncompatibleArchitecture] Raises an error if the
+    #  application binary is not compatible with the target simulator.
+    def self.expect_simulator_compatible_arch(device, app)
+      lipo = RunLoop::Lipo.new(app.path)
+      lipo.expect_compatible_arch(device)
+
+      RunLoop.log_debug("Simulator instruction set '#{device.instruction_set}' is compatible with '#{lipo.info}'")
+    end
   end
 end

data/lib/run_loop/core_simulator.rb

@@ -508,11 +508,9 @@ $ bundle exec run-loop simctl manage-processes
   def sim_name
     @sim_name ||= lambda {
       if xcode.version_gte_7?
-        'Simulator'
-      elsif xcode.version_gte_6?
-        'iOS Simulator'
+        "Simulator"
       else
-        'iPhone Simulator'
+        "iOS Simulator"
       end
     }.call
   end
@@ -527,10 +525,8 @@ $ bundle exec run-loop simctl manage-processes
       dev_dir = xcode.developer_dir
       if xcode.version_gte_7?
         "#{dev_dir}/Applications/Simulator.app"
-      elsif xcode.version_gte_6?
-        "#{dev_dir}/Applications/iOS Simulator.app"
       else
-        "#{dev_dir}/Platforms/iPhoneSimulator.platform/Developer/Applications/iPhone Simulator.app"
+        "#{dev_dir}/Applications/iOS Simulator.app"
       end
     }.call
   end

data/lib/run_loop/detect_aut/detect.rb

@@ -3,6 +3,24 @@ module RunLoop
   # @!visibility private
   module DetectAUT
 
+    # @!visibility private
+    def self.detect_app_under_test(options)
+      app = self.detect_app(options)
+      if app.is_a?(RunLoop::App) || app.is_a?(RunLoop::Ipa)
+        {
+          :app => app,
+          :bundle_id => app.bundle_identifier,
+          :is_ipa => app.is_a?(RunLoop::Ipa)
+        }
+      else
+        {
+          :app => nil,
+          :bundle_id => app,
+          :is_ipa => false
+        }
+      end
+    end
+
     # @!visibility private
     class Detect
       include RunLoop::DetectAUT::Errors
@@ -103,5 +121,59 @@ module RunLoop
         end
       end
     end
+
+    private
+
+    # @!visibility private
+    def self.app_from_options(options)
+      options[:app] || options[:bundle_id]
+    end
+
+    # @!visibility private
+    def self.app_from_environment
+      RunLoop::Environment.path_to_app_bundle ||
+        RunLoop::Environment.bundle_id
+    end
+
+    # @!visibility private
+    def self.app_from_constant
+      (defined?(APP_BUNDLE_PATH) && APP_BUNDLE_PATH) ||
+        (defined?(APP) && APP)
+    end
+
+    # @!visibility private
+    def self.app_from_opts_or_env_or_constant(options)
+       self.app_from_options(options) ||
+         self.app_from_environment ||
+         self.app_from_constant
+    end
+
+    # @!visibility private
+    def self.detector
+      RunLoop::DetectAUT::Detect.new
+    end
+
+    # @!visibility private
+    def self.detect_app(options)
+      app = self.app_from_opts_or_env_or_constant(options)
+
+      # Options or constant defined an instance of App or Ipa
+      return app if app && (app.is_a?(RunLoop::App) || app.is_a?(RunLoop::Ipa))
+
+      # User provided no information, so we attempt to auto detect
+      if app.nil? || app == ""
+        return self.detector.app_for_simulator
+      end
+
+      extension = File.extname(app)
+      if extension == ".ipa" && File.exist?(app)
+        RunLoop::Ipa.new(app)
+      elsif extension == ".app" && File.exist?(app)
+        RunLoop::App.new(app)
+      else
+        # Probably a bundle identifier.
+        app
+      end
+    end
   end
 end

data/lib/run_loop/device.rb

@@ -128,6 +128,41 @@ Please update your sources.))
       raise ArgumentError, "Could not find a device with a UDID or name matching '#{udid_or_name}'"
     end
 
+    # @!visibility private
+    #
+    # Please don't call this method.  It is for internal use only.  The behavior
+    # may change at any time!  You have been warned.
+    #
+    # @param [Hash] options The launch options passed to RunLoop::Core
+    # @param [RunLoop::Xcode] xcode An Xcode instance
+    # @param [RunLoop::SimControl] simctl A SimControl instance
+    # @param [RunLoop::Instruments] instruments An Instruments instance
+    #
+    # @raise [ArgumentError] If "device" is detected as the device target and
+    #  there is no matching device.
+    # @raise [ArgumentError] If DEVICE_TARGET or options specify an identifier
+    #  that does not match an iOS Simulator or phyiscal device.
+    def self.detect_device(options, xcode, simctl, instruments)
+      device = self.device_from_opts_or_env(options)
+
+      # Passed an instance of RunLoop::Device
+      return device if device && device.is_a?(RunLoop::Device)
+
+      # Need to infer what what the user wants from the environment and options.
+      if device == "device"
+        identifier = self.detect_physical_device_on_usb
+        self.ensure_physical_device_connected(identifier, options)
+      elsif device.nil? || device == "" || device == "simulator"
+        identifier = RunLoop::Core.default_simulator(xcode)
+      else
+        identifier = device
+      end
+
+      # Raises ArgumentError if no matching device can be found.
+      self.device_with_identifier(identifier, sim_control: simctl,
+                                  instruments: instruments)
+    end
+
     # @!visibility private
     def to_s
       if simulator?
@@ -162,10 +197,8 @@ Please update your sources.))
 
         if xcode.version_gte_7?
           "#{name} (#{version_part})"
-        elsif xcode.version_gte_6?
-          "#{name} (#{version_part} Simulator)"
         else
-          udid
+          "#{name} (#{version_part} Simulator)"
         end
       end
     end
@@ -173,13 +206,13 @@ Please update your sources.))
     # Is this a physical device?
     # @return [Boolean] Returns true if this is a device.
     def physical_device?
-      not udid[DEVICE_UDID_REGEX, 0].nil?
+      !udid[DEVICE_UDID_REGEX, 0].nil?
     end
 
     # Is this a simulator?
     # @return [Boolean] Returns true if this is a simulator.
     def simulator?
-      not physical_device?
+      !physical_device?
     end
 
     # Return the instruction set for this device.
@@ -572,5 +605,78 @@ Please update your sources.))
 
     # TODO Is this a good idea?  It speeds up rspec tests by a factor of ~2x...
     SIM_CONTROL = RunLoop::SimControl.new
+
+    # @!visibility private
+    def self.device_from_options(options)
+      options[:device] || options[:device_target] || options[:udid]
+    end
+
+    # @!visibility private
+    def self.device_from_environment
+      RunLoop::Environment.device_target
+    end
+
+    # @!visibility private
+    def self.device_from_opts_or_env(options)
+      self.device_from_options(options) || self.device_from_environment
+    end
+
+    # @!visibility private
+    UDID_DETECT = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", 'scripts', "udidetect"))
+
+    # @!visibility private
+    def self.detect_physical_device_on_usb
+      require "command_runner"
+
+      udid = nil
+      begin
+        hash = CommandRunner.run([UDID_DETECT], timeout: 1)
+        udid = hash[:out].chomp
+        if udid == ""
+          udid = nil
+        end
+      rescue => e
+        RunLoop.log_debug("Running `udidetect` raised: #{e}")
+      ensure
+        `killall udidetect &> /dev/null`
+      end
+      udid
+    end
+
+    # @!visibility private
+    def self.ensure_physical_device_connected(identifier, options)
+      if identifier.nil?
+        env = self.device_from_environment
+        if env == "device"
+          message = "DEVICE_TARGET=device means that you want to test on physical device"
+        elsif env && env[DEVICE_UDID_REGEX, 0]
+          message = "DEVICE_TARGET=#{env} did not match any connected device"
+        else
+          if options[:device]
+            key = ":device"
+          elsif options[:device_target]
+            key = ":device_target"
+          else
+            key = ":udid"
+          end
+          message = "#{key} => \"device\" means that you want to test on a physical device"
+        end
+
+        raise ArgumentError, %Q[Expected a physical device to be connected via USB.
+
+#{message}
+
+1. Is your device connected?
+2. Does your device appear in the output of `xcrun instruments -s devices`?
+3. Does your device appear in Xcode > Windows > Devices without a warning message?
+
+Please see the documentation about testing on physical devices.
+
+https://github.com/calabash/calabash-ios/wiki/Testing-on-Physical-Devices
+]
+      end
+      true
+    end
   end
 end
+

data/lib/run_loop/environment.rb

@@ -48,6 +48,11 @@ module RunLoop
       end
     end
 
+    # Should the app data be reset between Scenarios?
+    def self.reset_between_scenarios?
+      ENV["RESET_BETWEEN_SCENARIOS"] == "1"
+    end
+
     # Returns the value of XCODEPROJ which can be used to specify an Xcode
     # project directory (my.xcodeproj).
     #

data/lib/run_loop/instruments.rb

@@ -198,20 +198,14 @@ module RunLoop
       @instruments_templates ||= lambda do
         args = ['instruments', '-s', 'templates']
         hash = xcrun.exec(args, log_cmd: true)
-        if xcode.version_gte_6?
-          hash[:out].chomp.split("\n").map do |elm|
-            stripped = elm.strip.tr('"', '')
-            if stripped == '' || stripped == 'Known Templates:'
-              nil
-            else
-              stripped
-            end
-          end.compact
-        else
-          hash[:out].strip.split("\n").delete_if do |path|
-            not path =~ /tracetemplate/
-          end.map { |elm| elm.strip }
-        end
+        hash[:out].chomp.split("\n").map do |elm|
+          stripped = elm.strip.tr('"', '')
+          if stripped == '' || stripped == 'Known Templates:'
+            nil
+          else
+            stripped
+          end
+        end.compact
       end.call
     end
 
@@ -306,29 +300,7 @@ module RunLoop
       array = ['instruments']
       array << '-w'
 
-      # Xcode 7 simulators must be launched with UDID to avoid
-      # Ambiguous device name/identifier errors (from instruments)
-      if xcode.version_gte_7?
-        udid = options[:udid]
-
-        if udid[DEVICE_UDID_REGEX, 0]
-          array << udid
-        else
-          match = simulators.find do |simulator|
-            [simulator.name == udid,
-             simulator.udid == udid,
-             simulator.instruments_identifier(xcode) == udid].any?
-          end
-
-          if match
-            array << match.udid
-          else
-            array << udid
-          end
-        end
-      else
-        array << options[:udid]
-      end
+      array << options[:udid]
 
       trace = options[:results_dir_trace]
       if trace
@@ -339,7 +311,7 @@ module RunLoop
       array << '-t'
       array << automation_template
 
-      array << options[:bundle_dir_or_bundle_id]
+      array << options[:bundle_id]
 
       {
             'UIARESULTSPATH' => options[:results_dir],

data/lib/run_loop/l10n.rb

@@ -70,31 +70,7 @@ module RunLoop
     end
 
     def uikit_bundle_l10n_path
-      developer_dir = xcode.developer_dir
-      if !developer_dir
-        nil
-      else
-        if xcode.version_gte_6?
-          File.join(developer_dir, UIKIT_AXBUNDLE_PATH_CORE_SIM)
-        else
-          ['7.1', '7.0', '6.1'].map do |sdk|
-            path = axbundle_path_for_sdk(developer_dir, sdk)
-            if File.exist?(path)
-              path
-            else
-              nil
-            end
-          end.compact.first
-        end
-      end
-    end
-
-    # Xcode 5.1.1 path.
-    def axbundle_path_for_sdk(developer_dir, sdk)
-      File.join(developer_dir,
-                'Platforms/iPhoneSimulator.platform/Developer/SDKs',
-                "iPhoneSimulator#{sdk}.sdk",
-                'System/Library/AccessibilityBundles/UIKit.axbundle')
+      File.join(xcode.developer_dir, UIKIT_AXBUNDLE_PATH_CORE_SIM)
     end
 
     def is_full_name?(two_letter_country_code)

data/lib/run_loop/logging.rb

@@ -62,7 +62,7 @@ module RunLoop
   # .log_info is already taken by the XTC logger. (>_O)
   # green
   def self.log_info2(msg)
-    puts self.green(" INFO: #{msg}") if msg
+    puts self.green("INFO: #{msg}") if msg
   end
 
   # red

data/lib/run_loop/sim_control.rb

@@ -37,7 +37,9 @@ module RunLoop
     end
 
     # @!visibility private
+    # @deprecated 2.1.0
     def xcode_version_gte_51?
+      RunLoop.deprecated("2.1.0", "No replacement.")
       xcode.version_gte_51?
     end
 
@@ -401,10 +403,6 @@ module RunLoop
     end
 
     def software_keyboard_enabled?(device)
-      unless xcode_version_gte_51?
-        raise RuntimeError, 'Keyboard enabling is only available on Xcode >= 6'
-      end
-
       plist = device.simulator_preferences_plist_path
       return false unless File.exist?(plist)
 

data/lib/run_loop/version.rb

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

data/lib/run_loop/xcode.rb

@@ -175,10 +175,12 @@ module RunLoop
       version >= v60
     end
 
+    # @deprecated 2.1.0
     # Is the active Xcode version 5.1 or above?
     #
     # @return [Boolean] `true` if the current Xcode version is >= 5.1
     def version_gte_51?
+      RunLoop.deprecated("2.1.0", "No replacement")
       version >= v51
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: run_loop
 version: !ruby/object:Gem::Version
-  version: 2.0.10.pre1
+  version: 2.1.0.pre1
 platform: ruby
 authors:
 - Karl Krukow
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-17 00:00:00.000000000 Z
+date: 2016-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json