run_loop 1.4.1 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: add525f78c7ac99df59033028904b5c6cdfab2c2
-  data.tar.gz: 92408bd01935a5444d9ef268d36843d273567381
+  metadata.gz: 2b7bf28b320d229c203aba840fd310fa5d218969
+  data.tar.gz: df2729c85b406bac18cf9dbf82e44cdfa3fdcd48
 SHA512:
-  metadata.gz: c4ad4e7a0d55f171dfc3a6448d5401db1b8823a05bd9b83878b08b0eee79b2118c3775bd5319ee9bd3b2bfd6e3946b335de8d08496f9e10249840ed6bdf7efb4
-  data.tar.gz: fdc0619781bce185692842c1aad8bcd1fb3a23224f6d916e7a84198224315e52bb2bfb6caba3c1c2632c9fc80d5dd203b43e12e38da9a15a54de5a6e75da30a3
+  metadata.gz: 4ca074c5fa9370f9085758386a987fbeef3a534820cae5c7d41b1b0ab9c7a49c16df455684ebcbb323819dc987a46e5c63b6ba2abfa776ef280a48a57a31f180
+  data.tar.gz: 9b2ac244bc05587ecc7393a80c9eeb3c016fc623cbdbb8deafe0d72d1a059217daecbf99c829bbbb5247a41284b20028b06b23edf118f5b43ff9bfb66ae3d7d4

data/lib/run_loop/app.rb

@@ -16,6 +16,16 @@ module RunLoop
       @path = File.expand_path(app_bundle_path)
     end
 
+    # @!visibility private
+    def to_s
+      "#<APP: #{path}>"
+    end
+
+    # @!visibility private
+    def inspect
+      to_s
+    end
+
     # Is this a valid app?
     def valid?
       [File.exist?(path),

data/lib/run_loop/cli/simctl.rb

@@ -16,8 +16,13 @@ module RunLoop
       no_commands do
         def tail_booted
           device = booted_device
-          log_file = device.simulator_log_file_path
-          exec('tail', *['-F', log_file])
+          if device.nil?
+            version = Xcode.new.version
+            puts "No simulator for active Xcode (version #{version}) is booted."
+          else
+            log_file = device.simulator_log_file_path
+            exec('tail', *['-F', log_file])
+          end
         end
       end
 
@@ -25,7 +30,8 @@ module RunLoop
       def booted
         device = booted_device
         if device.nil?
-          puts 'No simulator is booted.'
+          version = Xcode.new.version
+          puts "No simulator for active Xcode (version #{version}) is booted."
         else
           puts device
         end

data/lib/run_loop/core.rb

@@ -29,7 +29,7 @@ module RunLoop
       SCRIPTS_PATH
     end
 
-    def self.log_run_loop_options(options, xctools)
+    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.
       ignored_keys = [:sim_control]
@@ -41,8 +41,8 @@ module RunLoop
       # Objects that override '==' cannot be printed by awesome_print
       # https://github.com/michaeldv/awesome_print/issues/154
       # RunLoop::Version overrides '=='
-      options_to_log[:xcode] = xctools.xcode_version.to_s
-      options_to_log[:xcode_path] = xctools.xcode_developer_dir
+      options_to_log[:xcode] = xcode.version.to_s
+      options_to_log[:xcode_path] = xcode.developer_dir
       message = options_to_log.ai({:sort_keys => true})
       logger = options[:logger]
       RunLoop::Logging.log_debug(logger, "\n" + message)
@@ -87,7 +87,7 @@ module RunLoop
       if sim_control.xcode_version_gte_6?
         sim_identifier = launch_options[:udid]
         simulator = sim_control.simulators.find do |simulator|
-          [simulator.instruments_identifier(sim_control.xctools),
+          [simulator.instruments_identifier(sim_control.xcode),
            simulator.udid].include?(sim_identifier)
         end
 
@@ -100,7 +100,7 @@ module RunLoop
         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.xctools.xcode_version} detected; skipping simulator architecture check.")
+        RunLoop::Logging.log_debug(logger, "Xcode #{sim_control.xcode_version} detected; skipping simulator architecture check.")
         false
       end
     end
@@ -124,7 +124,7 @@ module RunLoop
         sim_control.quit_sim
       end
 
-      if !sim_control.xctools.xcode_version_gte_6?
+      if !sim_control.xcode_version_gte_6?
         # Xcode 5.1.1
 
         # Will quit the simulator!
@@ -134,8 +134,10 @@ module RunLoop
         # CoreSimulator
 
         udid = launch_options[:udid]
+        xcode = sim_control.xcode
+
         device = sim_control.simulators.detect do |sim|
-          sim.udid == udid || sim.instruments_identifier == udid
+          sim.udid == udid || sim.instruments_identifier(xcode) == udid
         end
 
         if device.nil?
@@ -156,7 +158,7 @@ module RunLoop
 
         # Xcode 6.3 instruments cannot launch an app that is already installed on
         # iOS 8.3 Simulators. See: https://github.com/calabash/calabash-ios/issues/744
-        if sim_control.xctools.xcode_version_gte_63?
+        if sim_control.xcode.version_gte_63?
           app_bundle_path = launch_options[:bundle_dir_or_bundle_id]
           bridge = RunLoop::Simctl::Bridge.new(device, app_bundle_path)
 
@@ -172,10 +174,18 @@ module RunLoop
 
       logger = options[:logger]
       sim_control ||= options[:sim_control] || RunLoop::SimControl.new
-      xctools ||= options[:xctools] || sim_control.xctools
+
+      if options[:xctools]
+        RunLoop.deprecated('1.5.0', %q(
+RunLoop::XCTools has been replaced with RunLoop::Xcode.
+The :xctools key will be ignored.  It has been replaced by the :xcode key.
+Please update your sources to pass an instance of RunLoop::Xcode))
+      end
+
+      xcode ||= options[:xcode] || sim_control.xcode
 
       instruments = RunLoop::Instruments.new
-      instruments.kill_instruments
+      instruments.kill_instruments(xcode)
 
       device_target = options[:udid] || options[:device_target] || detect_connected_device || 'simulator'
       if device_target && device_target.to_s.downcase == 'device'
@@ -251,9 +261,9 @@ module RunLoop
         self.prepare_simulator(merged_options, sim_control)
       end
 
-      self.log_run_loop_options(merged_options, xctools)
+      self.log_run_loop_options(merged_options, xcode)
 
-      automation_template = automation_template(xctools)
+      automation_template = automation_template(instruments)
 
       RunLoop::Logging.log_header(logger, "Starting on #{device_target} App: #{bundle_dir_or_bundle_id}")
 
@@ -388,20 +398,27 @@ module RunLoop
     #
     # For historical reasons, the most recent non-64b SDK should be used.
     #
-    # @param [RunLoop::XCTools] xcode_tools Used to detect the current xcode
+    # @param [RunLoop::XCTools, RunLoop::XCode] xcode Used to detect the current xcode
     #  version.
-    def self.default_simulator(xcode_tools=RunLoop::XCTools.new)
-      if xcode_tools.xcode_version_gte_7?
-        'iPhone 5s (9.0 Simulator)'
-      elsif xcode_tools.xcode_version_gte_64?
+    def self.default_simulator(xcode=RunLoop::Xcode.new)
+      if xcode.is_a?(RunLoop::XCTools)
+        RunLoop.deprecated('1.5.0',
+                           %q(
+RunLoop::XCTools has been replaced with RunLoop::Xcode.
+Please update your sources to pass an instance of RunLoop::Xcode))
+      end
+
+      if xcode.version_gte_7?
+        'iPhone 5s (9.0)'
+      elsif xcode.version_gte_64?
         'iPhone 5s (8.4 Simulator)'
-      elsif xcode_tools.xcode_version_gte_63?
+      elsif xcode.version_gte_63?
         'iPhone 5s (8.3 Simulator)'
-      elsif xcode_tools.xcode_version_gte_62?
+      elsif xcode.version_gte_62?
         'iPhone 5s (8.2 Simulator)'
-      elsif xcode_tools.xcode_version_gte_61?
+      elsif xcode.version_gte_61?
         'iPhone 5s (8.1 Simulator)'
-      elsif xcode_tools.xcode_version_gte_6?
+      elsif xcode.version_gte_6?
         'iPhone 5s (8.0 Simulator)'
       else
         'iPhone Retina (4-inch) - Simulator - iOS 7.1'
@@ -409,7 +426,7 @@ module RunLoop
     end
 
     def self.udid_and_bundle_for_launcher(device_target, options, sim_control=RunLoop::SimControl.new)
-      xctools = sim_control.xctools
+      xcode = sim_control.xcode
 
       bundle_dir_or_bundle_id = options[:app] || RunLoop::Environment.bundle_id || RunLoop::Environment.path_to_app_bundle
 
@@ -419,9 +436,9 @@ module RunLoop
 
       udid = nil
 
-      if xctools.xcode_version_gte_51?
+      if xcode.version_gte_51?
         if device_target.nil? || device_target.empty? || device_target == 'simulator'
-          device_target = self.default_simulator(xctools)
+          device_target = self.default_simulator(xcode)
         end
         udid = device_target
 
@@ -429,6 +446,7 @@ module RunLoop
           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)
@@ -621,15 +639,25 @@ module RunLoop
       result
     end
 
-    def self.automation_template(xctools, candidate = RunLoop::Environment.trace_template)
+    def self.automation_template(instruments, candidate=RunLoop::Environment.trace_template)
       unless candidate && File.exist?(candidate)
-        candidate = default_tracetemplate xctools
+        candidate = default_tracetemplate(instruments)
       end
       candidate
     end
 
-    def self.default_tracetemplate(xctools=RunLoop::XCTools.new)
-      templates = xctools.instruments :templates
+    def self.default_tracetemplate(instruments_arg=RunLoop::Instruments.new)
+      if instruments_arg.is_a?(RunLoop::XCTools)
+        RunLoop.deprecated('1.5.0',
+                           %q(
+RunLoop::XCTools has been replaced with RunLoop::Xcode.
+Please update your sources to pass an instance of RunLoop::Instruments))
+        instruments = RunLoop::Instruments.new
+      else
+        instruments = instruments_arg
+      end
+
+      templates = instruments.templates
 
       # xcrun instruments -s templates
       # Xcode >= 6 will return known, Apple defined tracetemplates as names
@@ -641,23 +669,23 @@ module RunLoop
       # behavior when GM is released.
       #
       # Xcode 7 Beta versions appear to behavior like Xcode 6 Beta versions.
-      res = templates.select { |name| name == 'Automation' }.first
-      return res if res
+      template = templates.find { |name| name == 'Automation' }
+      return template if template
 
-      candidate = templates.select do |path|
+      candidate = templates.find do |path|
         path =~ /\/Automation.tracetemplate/ and path =~ /Xcode/
       end
 
-      if !candidate.empty? && !candidate.first.nil?
-        return candidate.first.tr("\"", '').strip
+      if !candidate.nil?
+        return candidate.tr("\"", '').strip
       end
 
-      msgs = ['Expected instruments to report an Automation tracetemplate.',
+      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"]
-      raise msgs.join("\n")
+      raise message.join("\n")
     end
 
     # @deprecated 1.0.5
@@ -675,8 +703,8 @@ module RunLoop
     end
 
     # @deprecated 1.0.0 replaced with Xctools#version
-    def self.xcode_version(xctools=RunLoop::XCTools.new)
-      xctools.xcode_version.to_s
+    def self.xcode_version(xcode=RunLoop::Xcode.new)
+      xcode.version
     end
 
     # @deprecated since 1.0.0

data/lib/run_loop/device.rb

@@ -1,6 +1,8 @@
 module RunLoop
   class Device
 
+    include RunLoop::Regex
+
     attr_reader :name
     attr_reader :version
     attr_reader :udid
@@ -40,7 +42,7 @@ module RunLoop
     # passed to instruments.
     #
     # @example
-    #  RunLoop::Device.device_with_identifier('iPhone 4s (8.3 Simulator')
+    #  RunLoop::Device.device_with_identifier('iPhone 4s (8.3 Simulator'))
     #  RunLoop::Device.device_with_identifier('6E43E3CF-25F5-41CC-A833-588F043AE749')
     #  RunLoop::Device.device_with_identifier('denis') # Simulator or device named 'denis'
     #  RunLoop::Device.device_with_identifier('893688959205dc7eb48d603c558ede919ad8dd0c')
@@ -50,20 +52,45 @@ module RunLoop
     #
     # @param [String] udid_or_name A name or udid that identifies the device you
     #  are looking for.
-    # @param [RunLoop::SimControl] sim_control An instance of SimControl that
-    #  can be used for looking of simulators and providing an XCTools instance.
-    #  Users should never need to provide this.
+    # @param [Hash] options Allows callers to pass runtime models that might
+    #  optimize performance (via memoization).
+    # @option options [RunLoop::SimControl] :sim_control An instance of
+    #  SimControl.
+    # @option options [RunLoop::Instruments] :instruments An instance of
+    #  Instruments.
+    #
     # @return [RunLoop::Device] A device that matches `udid_or_name`.
     # @raise [ArgumentError] If no matching device can be found.
-    def self.device_with_identifier(udid_or_name, sim_control=RunLoop::SimControl.new)
+    def self.device_with_identifier(udid_or_name, options={})
+      if options.is_a?(RunLoop::SimControl)
+        RunLoop.deprecated('1.5.0', %q(
+The 'sim_control' argument has been deprecated.  It has been replaced by an
+options hash with two keys: :sim_control and :instruments.
+Please update your sources.))
+        merged_options = {
+              :sim_control => options,
+              :instruments => RunLoop::Instruments.new
+        }
+      else
+        default_options = {
+              :sim_control => RunLoop::SimControl.new,
+              :instruments => RunLoop::Instruments.new
+        }
+        merged_options = default_options.merge(options)
+      end
+
+      instruments = merged_options[:instruments]
+      sim_control = merged_options[:sim_control]
+
+      xcode = sim_control.xcode
       simulator = sim_control.simulators.detect do |sim|
-        sim.instruments_identifier == udid_or_name ||
+        sim.instruments_identifier(xcode) == udid_or_name ||
               sim.udid == udid_or_name
       end
 
       return simulator if !simulator.nil?
 
-      physical_device = sim_control.xctools.instruments(:devices).detect do |device|
+      physical_device = instruments.physical_devices.detect do |device|
         device.name == udid_or_name ||
               device.udid == udid_or_name
       end
@@ -73,46 +100,68 @@ module RunLoop
       raise ArgumentError, "Could not find a device with a UDID or name matching '#{udid_or_name}'"
     end
 
+    # @!visibility private
     def to_s
       if simulator?
-        "#<Simulator: #{instruments_identifier} #{udid} #{instruction_set}>"
+        "#<Simulator: #{name} #{udid} #{instruction_set}>"
       else
         "#<Device: #{name} #{udid}>"
       end
     end
 
+    # @!visibility private
+    def inspect
+      to_s
+    end
+
     # Returns and instruments-ready device identifier that is a suitable value
     # for DEVICE_TARGET environment variable.
     #
+    # @note As of 1.5.0, the XCTools optional argument has become a non-optional
+    #  Xcode argument.
+    #
+    # @param [RunLoop::Xcode, RunLoop::XCTools] xcode The version of the active
+    #  Xcode.
     # @return [String] An instruments-ready device identifier.
     # @raise [RuntimeError] If trying to obtain a instruments-ready identifier
     #  for a simulator when Xcode < 6.
-    def instruments_identifier(xcode_tools=RunLoop::XCTools.new)
+    def instruments_identifier(xcode=SIM_CONTROL.xcode)
+      if xcode.is_a?(RunLoop::XCTools)
+        RunLoop.deprecated('1.5.0',
+                           %q(
+RunLoop::XCTools has been replaced with a non-optional RunLoop::Xcode argument.
+Please update your sources to pass an instance of RunLoop::Xcode))
+      end
+
       if physical_device?
-        self.udid
+        udid
       else
-        unless xcode_tools.xcode_version_gte_6?
-          raise "Expected Xcode >= 6, but found version #{xcode_tools.xcode_version} - cannot create an identifier"
+        if version == RunLoop::Version.new('7.0.3')
+          version_part = version.to_s
+        else
+          version_part = "#{version.major}.#{version.minor}"
         end
-        if self.version == RunLoop::Version.new('7.0.3')
-          version_part = self.version.to_s
+
+        if xcode.version_gte_7?
+          "#{name} (#{version_part})"
+        elsif xcode.version_gte_6?
+          "#{name} (#{version_part} Simulator)"
         else
-          version_part = "#{self.version.major}.#{self.version.minor}"
+          udid
         end
-        "#{self.name} (#{version_part} Simulator)"
       end
     end
 
     # Is this a physical device?
     # @return [Boolean] Returns true if this is a device.
     def physical_device?
-      not self.udid[/[a-f0-9]{40}/, 0].nil?
+      not udid[DEVICE_UDID_REGEX, 0].nil?
     end
 
     # Is this a simulator?
     # @return [Boolean] Returns true if this is a simulator.
     def simulator?
-      not self.physical_device?
+      not physical_device?
     end
 
     # Return the instruction set for this device.
@@ -128,7 +177,7 @@ module RunLoop
     # @raise [RuntimeError] Raises an error if this device is a physical device.
     # @return [String] An instruction set.
     def instruction_set
-      if self.simulator?
+      if simulator?
         if ['iPhone 4s', 'iPhone 5', 'iPad 2', 'iPad Retina'].include?(self.name)
           'i386'
         else
@@ -171,5 +220,8 @@ module RunLoop
 
     CORE_SIMULATOR_DEVICE_DIR = File.expand_path('~/Library/Developer/CoreSimulator/Devices')
     CORE_SIMULATOR_LOGS_DIR = File.expand_path('~/Library/Logs/CoreSimulator')
+
+    # TODO Is this a good idea?  It speeds up rspec tests by a factor of ~2x...
+    SIM_CONTROL = RunLoop::SimControl.new
   end
 end

data/lib/run_loop/host_cache.rb

@@ -64,6 +64,16 @@ module RunLoop
       end
     end
 
+    # @!visibility private
+    def to_s
+      "#<HostCache #{path}>"
+    end
+
+    # @!visibility private
+    def inspect
+      to_s
+    end
+
     # Reads the current cache.
     # @return [Hash] A hash representation of the current state of the run-loop.
     def read