run_loop 1.2.7 → 1.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2654e1672654ee6ae0af23cb582fec43864992df
-  data.tar.gz: d481bf34a098f76d83d94826575b021ace8232ca
+  metadata.gz: 253c24d7121ffc84824a1d3e7a5e3c79d14dfcd8
+  data.tar.gz: d22bc4efbace3cbcd82e3ab023515984beff9618
 SHA512:
-  metadata.gz: db03ba41012e7bf8f5d4cefa4833a36c478d16f9359339e415eae29dfa4faf62e6fb3491ad301d872941bcb30a1ebb71c1aabd55f95ceb01210119f2f57f00ff
-  data.tar.gz: 30e5ec4733c0ef6da15aa590c9390c46e3a9a6fa5ddb08f4e609602ace3a05579ea76d538a132f4667708ea1d4cf83307aeb243573b90635cbd6609c8b0e21d3
+  metadata.gz: 716a2225ff8d2ff978b28852d803c84ba97ac05a75a0ce74a714f910ef35317f9322f4818c8812f88b72bafcda6542e3df1a82c87dfe73137e8737a687aeb61f
+  data.tar.gz: 2750db0951ae73dd859fac716b138ffd02972e42f2e1aec600f9faf4bb10addf7e19d334488fed3f59f3476aacbbb87f080bf8eca81a4263166fa2f3c58262e6

data/lib/run_loop.rb

@@ -1,8 +1,10 @@
 require 'run_loop/environment'
+require 'run_loop/logging'
 require 'run_loop/process_terminator'
 require 'run_loop/process_waiter'
 require 'run_loop/lldb'
 require 'run_loop/dylib_injector'
+require 'run_loop/fifo'
 require 'run_loop/core'
 require 'run_loop/version'
 require 'run_loop/xctools'
@@ -15,3 +17,174 @@ require 'run_loop/lipo'
 require 'run_loop/host_cache'
 require 'run_loop/monkey_patch'
 require 'run_loop/simctl/bridge'
+
+module RunLoop
+
+  class TimeoutError < RuntimeError
+  end
+
+  class WriteFailedError < RuntimeError
+  end
+
+  def self.run(options={})
+
+    if RunLoop::Instruments.new.instruments_app_running?
+      msg =
+          [
+              "Please quit the Instruments.app.",
+              "If Instruments.app is open, the instruments command line",
+              "tool cannot take control of your application."
+          ]
+      raise msg.join("\n")
+    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
+
+    options[:script] = script
+    options[:uia_strategy] = uia_strategy
+
+    Core.run_with_options(options)
+  end
+
+  def self.send_command(run_loop, cmd, options={timeout: 60}, num_retries=0, last_error=nil)
+    if num_retries > 3
+      if last_error
+        raise last_error
+      else
+        raise "Max retries exceeded #{num_retries} > 3. No error recorded."
+      end
+    end
+
+    if options.is_a?(Numeric)
+      options = {timeout: options}
+    end
+
+    if not cmd.is_a?(String)
+      raise "Illegal command #{cmd} (must be a string)"
+    end
+
+    if not options.is_a?(Hash)
+      raise "Illegal options #{options} (must be a Hash (or number for compatibility))"
+    end
+
+    timeout = options[:timeout] || 60
+    logger = options[:logger]
+    interrupt_retry_timeout = options[:interrupt_retry_timeout] || 25
+
+    expected_index = run_loop[:index]
+    result = nil
+    begin
+      expected_index = Core.write_request(run_loop, cmd, logger)
+    rescue RunLoop::WriteFailedError, Errno::EINTR => write_error
+      # Attempt recover from interrupt by attempting to read result (assuming write went OK)
+      # or retry if attempted read result fails
+      run_loop[:index] = expected_index # restore expected index in case it changed
+      log_info(logger, "Core.write_request failed: #{write_error}. Attempting recovery...")
+      log_info(logger, "Attempting read in case the request was received... Please wait (#{interrupt_retry_timeout})...")
+      begin
+        Timeout::timeout(interrupt_retry_timeout, TimeoutError) do
+          result = Core.read_response(run_loop, expected_index)
+        end
+        # Update run_loop expected index since we succeeded in reading the index
+        run_loop[:index] = expected_index + 1
+        log_info(logger, "Did read response for interrupted request of index #{expected_index}... Proceeding.")
+        return result
+      rescue TimeoutError => _
+        log_info(logger, "Read did not result in a response for index #{expected_index}... Retrying send_command...")
+        return send_command(run_loop, cmd, options, num_retries+1, write_error)
+      end
+    end
+
+
+    begin
+      Timeout::timeout(timeout, TimeoutError) do
+        result = Core.read_response(run_loop, expected_index)
+      end
+    rescue TimeoutError => _
+      raise TimeoutError, "Time out waiting for UIAutomation run-loop for command #{cmd}. Waiting for index:#{expected_index}"
+    end
+
+    result
+  end
+
+  def self.stop(run_loop, out=Dir.pwd)
+    return if run_loop.nil?
+    results_dir = run_loop[:results_dir]
+    dest = out
+
+    RunLoop::Instruments.new.kill_instruments
+
+    FileUtils.mkdir_p(dest)
+    if results_dir
+      pngs = Dir.glob(File.join(results_dir, 'Run 1', '*.png'))
+    else
+      pngs = []
+    end
+    FileUtils.cp(pngs, dest) if pngs and pngs.length > 0
+  end
+
+  def self.default_script_for_uia_strategy(uia_strategy)
+    case uia_strategy
+      when :preferences
+        Core.script_for_key(:run_loop_fast_uia)
+      when :host
+        Core.script_for_key(:run_loop_host)
+      when :shared_element
+        Core.script_for_key(:run_loop_shared_element)
+      else
+        Core.script_for_key(:run_loop_basic)
+    end
+  end
+
+  def self.validate_script(script)
+    if script.is_a?(String)
+      unless File.exist?(script)
+        raise "Unable to find file: #{script}"
+      end
+    elsif script.is_a?(Symbol)
+      script = Core.script_for_key(script)
+      unless script
+        raise "Unknown script for symbol: #{script}. Options: #{Core::SCRIPTS.keys.join(', ')}"
+      end
+    else
+      raise "Script must be a symbol or path: #{script}"
+    end
+    script
+  end
+
+  def self.log_info(*args)
+    RunLoop::Logging.log_info(*args)
+  end
+
+end

data/lib/run_loop/core.rb

@@ -8,12 +8,6 @@ require 'ap'
 
 module RunLoop
 
-  class TimeoutError < RuntimeError
-  end
-
-  class WriteFailedError < RuntimeError
-  end
-
   module Core
 
     START_DELIMITER = "OUTPUT_JSON:\n"
@@ -36,7 +30,7 @@ module RunLoop
     end
 
     def self.log_run_loop_options(options, xctools)
-      return unless ENV['DEBUG'] == '1'
+      return unless RunLoop::Environment.debug?
       # Ignore :sim_control b/c it is a ruby object; printing is not useful.
       ignored_keys = [:sim_control]
       options_to_log = {}
@@ -49,7 +43,9 @@ module RunLoop
       # RunLoop::Version overrides '=='
       options_to_log[:xcode] = xctools.xcode_version.to_s
       options_to_log[:xcode_path] = xctools.xcode_developer_dir
-      ap(options_to_log, {:sort_keys => true})
+      message = options_to_log.ai({:sort_keys => true})
+      logger = options[:logger]
+      RunLoop::Logging.log_debug(logger, "\n" + message)
     end
 
     # @deprecated since 1.0.0
@@ -78,10 +74,10 @@ module RunLoop
 
     def self.detect_connected_device
       begin
-        Timeout::timeout(1, TimeoutError) do
+        Timeout::timeout(1, RunLoop::TimeoutError) do
           return `#{File.join(scripts_path, 'udidetect')}`.chomp
         end
-      rescue TimeoutError => _
+      rescue RunLoop::TimeoutError => _
         `killall udidetect &> /dev/null`
       end
       nil
@@ -104,6 +100,7 @@ module RunLoop
     # @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)
+      logger = launch_options[:logger]
       if sim_control.xcode_version_gte_6?
         sim_identifier = launch_options[:udid]
         simulator = sim_control.simulators.find do |simulator|
@@ -117,14 +114,10 @@ module RunLoop
 
         lipo = RunLoop::Lipo.new(launch_options[:bundle_dir_or_bundle_id])
         lipo.expect_compatible_arch(simulator)
-        if ENV['DEBUG'] == '1'
-          puts "Simulator instruction set '#{simulator.instruction_set}' is compatible with #{lipo.info}"
-        end
+        RunLoop::Logging.log_debug(logger, "Simulator instruction set '#{simulator.instruction_set}' is compatible with #{lipo.info}")
         true
       else
-        if ENV['DEBUG'] == '1'
-          puts "Xcode #{sim_control.xctools.xcode_version} detected; skipping simulator architecture check."
-        end
+        RunLoop::Logging.log_debug(logger, "Xcode #{sim_control.xctools.xcode_version} detected; skipping simulator architecture check.")
         false
       end
     end
@@ -132,6 +125,7 @@ module RunLoop
     def self.run_with_options(options)
       before = Time.now
 
+      logger = options[:logger]
       sim_control ||= options[:sim_control] || RunLoop::SimControl.new
       xctools ||= options[:xctools] || sim_control.xctools
 
@@ -170,7 +164,9 @@ module RunLoop
       uia_strategy = options[:uia_strategy]
       if uia_strategy == :host
         create_uia_pipe(repl_path)
-        RunLoop::HostCache.default.clear
+        RunLoop::HostCache.default.clear unless RunLoop::Environment.xtc?
+      else
+        FileUtils.touch repl_path
       end
 
       cal_script = File.join(SCRIPTS_PATH, 'calabash_script_uia.js')
@@ -189,9 +185,7 @@ module RunLoop
       log_file ||= File.join(results_dir, 'run_loop.out')
 
       after = Time.now
-      if ENV['DEBUG'] == '1'
-        puts "Preparation took #{after-before} seconds"
-      end
+      RunLoop::Logging.log_debug(logger, "Preparation took #{after-before} seconds")
 
       discovered_options =
             {
@@ -215,7 +209,7 @@ module RunLoop
 
       automation_template = automation_template(xctools)
 
-      log_header("Starting on #{device_target} App: #{bundle_dir_or_bundle_id}")
+      RunLoop::Logging.log_header(logger, "Starting on #{device_target} App: #{bundle_dir_or_bundle_id}")
 
       pid = instruments.spawn(automation_template, merged_options, log_file)
 
@@ -241,22 +235,24 @@ module RunLoop
           options[:validate_channel].call(run_loop, 0, uia_timeout)
         else
           cmd = "UIALogger.logMessage('Listening for run loop commands')"
-          File.open(repl_path, 'w') { |file| file.puts "0:#{cmd}" }
-          Timeout::timeout(timeout, TimeoutError) do
+          begin
+            fifo_timeout = options[:fifo_timeout] || 30
+            RunLoop::Fifo.write(repl_path, "0:#{cmd}", timeout: fifo_timeout)
+          rescue RunLoop::Fifo::NoReaderConfiguredError,
+              RunLoop::Fifo::WriteTimedOut => e
+            RunLoop::Logging.log_debug(logger, "Error while writing to fifo. #{e}")
+            raise RunLoop::TimeoutError.new("Error while writing to fifo. #{e}")
+          end
+          Timeout::timeout(timeout, RunLoop::TimeoutError) do
             read_response(run_loop, 0, uia_timeout)
           end
         end
-      rescue TimeoutError => e
-        if ENV['DEBUG'] == '1'
-          puts "Failed to launch."
-          puts "#{e}: #{e && e.message}"
-        end
-        raise TimeoutError, "Time out waiting for UIAutomation run-loop to Start. \n Logfile #{log_file} \n\n #{File.read(log_file)}\n"
+      rescue RunLoop::TimeoutError => e
+        RunLoop::Logging.log_debug(logger, "Failed to launch. #{e}: #{e && e.message}")
+        raise RunLoop::TimeoutError, "Time out waiting for UIAutomation run-loop #{e}. \n Logfile #{log_file} \n\n #{File.read(log_file)}\n"
       end
 
-      if ENV['DEBUG']=='1'
-        puts "Launching took #{Time.now-before} seconds"
-      end
+      RunLoop::Logging.log_debug(logger, "Launching took #{Time.now-before} seconds")
 
       dylib_path = self.dylib_path_from_options(merged_options)
 
@@ -413,7 +409,7 @@ module RunLoop
 
     def self.create_uia_pipe(repl_path)
       begin
-        Timeout::timeout(5, TimeoutError) do
+        Timeout::timeout(5, RunLoop::TimeoutError) do
           loop do
             begin
               FileUtils.rm_f(repl_path)
@@ -424,8 +420,8 @@ module RunLoop
             end
           end
         end
-      rescue TimeoutError => _
-        raise TimeoutError, 'Unable to create pipe (mkfifo failed)'
+      rescue RunLoop::TimeoutError => _
+        raise RunLoop::TimeoutError, 'Unable to create pipe (mkfifo failed)'
       end
     end
 
@@ -437,33 +433,37 @@ module RunLoop
       repl_path = run_loop[:repl_path]
       index = run_loop[:index]
       cmd_str = "#{index}:#{escape_host_command(cmd)}"
-      should_log = (ENV['DEBUG'] == '1')
-      RunLoop.log_info(logger, cmd_str) if should_log
+      RunLoop::Logging.log_debug(logger, cmd_str)
       write_succeeded = false
       2.times do |i|
-        RunLoop.log_info(logger, "Trying write of command #{cmd_str} at index #{index}") if should_log
-        File.open(repl_path, 'w') { |f| f.puts(cmd_str) }
-        write_succeeded = validate_index_written(run_loop, index, logger)
+        RunLoop::Logging.log_debug(logger, "Trying write of command #{cmd_str} at index #{index}")
+        begin
+          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::Logging.log_debug(logger, "Error while writing command (retry count #{i}). #{e}")
+        end
         break if write_succeeded
       end
       unless write_succeeded
-        RunLoop.log_info(logger, 'Failing...Raising RunLoop::WriteFailedError') if should_log
+        RunLoop::Logging.log_debug(logger, 'Failing...Raising RunLoop::WriteFailedError')
         raise RunLoop::WriteFailedError.new("Trying write of command #{cmd_str} at index #{index}")
       end
       run_loop[:index] = index + 1
-      RunLoop::HostCache.default.write(run_loop)
+      RunLoop::HostCache.default.write(run_loop) unless RunLoop::Environment.xtc?
       index
     end
 
     def self.validate_index_written(run_loop, index, logger)
       begin
-        Timeout::timeout(10, TimeoutError) do
+        Timeout::timeout(10, RunLoop::TimeoutError) do
           Core.read_response(run_loop, index, 10, 'last_index')
         end
-        RunLoop.log_info(logger, "validate index written for index #{index} ok")
+        RunLoop::Logging.log_debug(logger, "validate index written for index #{index} ok")
         return true
-      rescue TimeoutError => _
-        RunLoop.log_info(logger, "validate index written for index #{index} failed. Retrying.")
+      rescue RunLoop::TimeoutError => _
+        RunLoop::Logging.log_debug(logger, "validate index written for index #{index} failed. Retrying.")
         return false
       end
     end
@@ -485,9 +485,7 @@ module RunLoop
           next
         end
 
-
         size = File.size(log_file)
-
         output = File.read(log_file, size-offset, offset)
 
         if /AXError: Could not auto-register for pid status change/.match(output)
@@ -495,10 +493,10 @@ module RunLoop
             $stderr.puts "\n\n****** Accessibility is not enabled on device/simulator, please enable it *** \n\n"
             $stderr.flush
           end
-          raise TimeoutError.new('AXError: Could not auto-register for pid status change')
+          raise RunLoop::TimeoutError.new('AXError: Could not auto-register for pid status change')
         end
         if /Automation Instrument ran into an exception/.match(output)
-          raise TimeoutError.new('Exception while running script')
+          raise RunLoop::TimeoutError.new('Exception while running script')
         end
         index_if_found = output.index(START_DELIMITER)
         if ENV['DEBUG_READ']=='1'
@@ -545,7 +543,7 @@ module RunLoop
       end
 
       run_loop[:initial_offset] = offset
-      RunLoop::HostCache.default.write(run_loop)
+      RunLoop::HostCache.default.write(run_loop) unless RunLoop::Environment.xtc?
       result
     end
 
@@ -588,20 +586,6 @@ module RunLoop
       raise msgs.join("\n")
     end
 
-    def self.log(message)
-      if ENV['DEBUG']=='1'
-        puts "#{Time.now } #{message}"
-        $stdout.flush
-      end
-    end
-
-    def self.log_header(message)
-      if ENV['DEBUG']=='1'
-        puts "\n\e[#{35}m### #{message} ###\e[0m"
-        $stdout.flush
-      end
-    end
-
     # @deprecated 1.0.5
     def self.ensure_instruments_not_running!
       RunLoop::Instruments.new.kill_instruments
@@ -617,170 +601,4 @@ module RunLoop
     end
   end
 
-  def self.default_script_for_uia_strategy(uia_strategy)
-    case uia_strategy
-      when :preferences
-        Core.script_for_key(:run_loop_fast_uia)
-      when :host
-        Core.script_for_key(:run_loop_host)
-      when :shared_element
-        Core.script_for_key(:run_loop_shared_element)
-      else
-        Core.script_for_key(:run_loop_basic)
-    end
-  end
-
-  def self.run(options={})
-
-    if RunLoop::Instruments.new.instruments_app_running?
-      msg =
-            [
-                  "Please quit the Instruments.app.",
-                  "If Instruments.app is open, the instruments command line",
-                  "tool cannot take control of your application."
-            ]
-      raise msg.join("\n")
-    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
-
-    options[:script] = script
-    options[:uia_strategy] = uia_strategy
-
-    Core.run_with_options(options)
-  end
-
-  def self.send_command(run_loop, cmd, options={timeout: 60}, num_retries=0, last_error=nil)
-    if num_retries > 3
-      if last_error
-        raise last_error
-      else
-        raise "Max retries exceeded #{num_retries} > 3. No error recorded."
-      end
-    end
-
-    if options.is_a?(Numeric)
-      options = {timeout: options}
-    end
-
-    if not cmd.is_a?(String)
-      raise "Illegal command #{cmd} (must be a string)"
-    end
-
-    if not options.is_a?(Hash)
-      raise "Illegal options #{options} (must be a Hash (or number for compatibility))"
-    end
-
-    timeout = options[:timeout] || 60
-    logger = options[:logger]
-    interrupt_retry_timeout = options[:interrupt_retry_timeout] || 25
-
-    expected_index = run_loop[:index]
-    result = nil
-    begin
-      expected_index = Core.write_request(run_loop, cmd, logger)
-    rescue RunLoop::WriteFailedError, Errno::EINTR => write_error
-      # Attempt recover from interrupt by attempting to read result (assuming write went OK)
-      # or retry if attempted read result fails
-      run_loop[:index] = expected_index # restore expected index in case it changed
-      log_info(logger, "Core.write_request failed: #{write_error}. Attempting recovery...")
-      log_info(logger, "Attempting read in case the request was received... Please wait (#{interrupt_retry_timeout})...")
-      begin
-        Timeout::timeout(interrupt_retry_timeout, TimeoutError) do
-          result = Core.read_response(run_loop, expected_index)
-        end
-        # Update run_loop expected index since we succeeded in reading the index
-        run_loop[:index] = expected_index + 1
-        log_info(logger, "Did read response for interrupted request of index #{expected_index}... Proceeding.")
-        return result
-      rescue TimeoutError => _
-        log_info(logger, "Read did not result in a response for index #{expected_index}... Retrying send_command...")
-        return send_command(run_loop, cmd, options, num_retries+1, write_error)
-      end
-    end
-
-
-    begin
-      Timeout::timeout(timeout, TimeoutError) do
-        result = Core.read_response(run_loop, expected_index)
-      end
-    rescue TimeoutError => _
-      raise TimeoutError, "Time out waiting for UIAutomation run-loop for command #{cmd}. Waiting for index:#{expected_index}"
-    end
-
-    result
-  end
-
-  def self.stop(run_loop, out=Dir.pwd)
-    return if run_loop.nil?
-    results_dir = run_loop[:results_dir]
-    dest = out
-
-    RunLoop::Instruments.new.kill_instruments
-
-    FileUtils.mkdir_p(dest)
-    if results_dir
-      pngs = Dir.glob(File.join(results_dir, 'Run 1', '*.png'))
-    else
-      pngs = []
-    end
-    FileUtils.cp(pngs, dest) if pngs and pngs.length > 0
-  end
-
-
-  def self.validate_script(script)
-    if script.is_a?(String)
-      unless File.exist?(script)
-        raise "Unable to find file: #{script}"
-      end
-    elsif script.is_a?(Symbol)
-      script = Core.script_for_key(script)
-      unless script
-        raise "Unknown script for symbol: #{script}. Options: #{Core::SCRIPTS.keys.join(', ')}"
-      end
-    else
-      raise "Script must be a symbol or path: #{script}"
-    end
-    script
-  end
-
-  def self.log_info(logger, message)
-    msg = "#{Time.now}: #{message}"
-    if logger && logger.respond_to?(:info)
-      logger.info(msg)
-    else
-      puts msg if ENV['DEBUG'] == '1'
-    end
-  end
 end

data/lib/run_loop/environment.rb

@@ -11,5 +11,9 @@ module RunLoop
     def self.debug?
       ENV['DEBUG'] == '1'
     end
+
+    def self.xtc?
+      ENV['XAMARIN_TEST_CLOUD'] == '1'
+    end
   end
 end

data/lib/run_loop/fifo.rb

@@ -0,0 +1,40 @@
+require 'timeout'
+module RunLoop
+  module Fifo
+    BUFFER_SIZE = 4096
+
+    class NoReaderConfiguredError < RuntimeError
+    end
+
+    class WriteTimedOut < RuntimeError
+    end
+
+    def self.write(pipe, msg, options={})
+      msg = "#{msg}\n"
+      timeout = options[:timeout] || 10
+      begin_at = Time.now
+      begin
+        open(pipe, File::WRONLY | File::NONBLOCK) do |pipe_io|
+          bytes_written = 0
+          bytes_to_write = msg.length
+          until bytes_written >= bytes_to_write do
+            begin
+              wrote = pipe_io.write_nonblock msg
+              bytes_written += wrote
+              msg = msg[wrote..-1]
+            rescue IO::WaitWritable, Errno::EINTR
+              timeout_left = timeout - (Time.now - begin_at)
+              raise WriteTimedOut if timeout_left <= 0
+              IO.select nil, [pipe_io], nil, timeout_left
+            end
+          end
+        end
+      rescue Errno::ENXIO
+        sleep(0.5)
+        timeout_left = timeout - (Time.now - begin_at)
+        raise NoReaderConfiguredError if timeout_left <= 0
+        retry
+      end
+    end
+  end
+end

data/lib/run_loop/instruments.rb

@@ -70,10 +70,8 @@ module RunLoop
     # @todo Is this jruby compatible?
     def spawn(automation_template, options, log_file)
       splat_args = spawn_arguments(automation_template, options)
-      if ENV['DEBUG'] == '1'
-        puts  "#{Time.now} xcrun #{splat_args.join(' ')} >& #{log_file}"
-        $stdout.flush
-      end
+      logger = options[:logger]
+      RunLoop::Logging.log_debug(logger, "xcrun #{splat_args.join(' ')} >& #{log_file}")
       pid = Process.spawn('xcrun', *splat_args, {:out => log_file, :err => log_file})
       Process.detach(pid)
       pid.to_i

data/lib/run_loop/lldb.rb

@@ -34,9 +34,7 @@ module RunLoop
     def self.kill_lldb_processes
       self.lldb_pids.each do |pid|
         unless self.kill_with_signal(pid, 'TERM')
-          unless self.kill_with_signal(pid, 'QUIT')
-            self.kill_with_signal(pid, 'KILL')
-          end
+          self.kill_with_signal(pid, 'KILL')
         end
       end
     end

data/lib/run_loop/logging.rb

@@ -0,0 +1,36 @@
+module RunLoop
+  class Logging
+
+    def self.log_info(logger, message)
+      log_level :info, logger, message
+    end
+
+    def self.log_debug(logger, message)
+      log_level :debug, logger, message
+    end
+
+    def self.log_header(logger, message)
+      msg = "\n\e[#{35}m### #{message} ###\e[0m"
+      if logger.respond_to?(:debug)
+        logger.debug(msg)
+      else
+        debug_puts(msg)
+      end
+    end
+
+    def self.log_level(level, logger, message)
+      level = level.to_sym
+      msg = "#{Time.now} [RunLoop:#{level}]: #{message}"
+      if logger.respond_to?(level)
+        logger.send(level, msg)
+      else
+        debug_puts(msg)
+      end
+    end
+
+    def self.debug_puts(msg)
+      puts msg if RunLoop::Environment.debug?
+    end
+
+  end
+end

data/lib/run_loop/process_waiter.rb

@@ -23,6 +23,44 @@ module RunLoop
       !pids.empty?
     end
 
+    # Wait for a number of process to start.
+    # @param [Integer] n The number of processes to wait for.
+    # @raise [ArgumentError] If n < 0
+    # @raise [ArgumentError] If n is not an Integer
+    def wait_for_n(n)
+      unless n.is_a?(Integer)
+        raise ArgumentError, "Expected #{n.class} to be #{1.class}"
+      end
+
+      unless n > 0
+        raise ArgumentError, "Expected #{n} to be > 0"
+      end
+
+      return true if pids.count == n
+
+      now = Time.now
+      poll_until = now + @options[:timeout]
+      delay = @options[:interval]
+      there_are_n = false
+      while Time.now < poll_until
+        there_are_n = pids.count == n
+        break if there_are_n
+        sleep delay
+      end
+
+      if RunLoop::Environment.debug?
+        plural = n > 1 ? "es" : ''
+        puts "Waited for #{Time.now - now} seconds for #{n} '#{process_name}' process#{plural} to start."
+      end
+
+      if @options[:raise_on_timeout] and !there_are_n
+        plural = n > 1 ? "es" : ''
+        raise "Waited #{@options[:timeout]} seconds for #{n} '#{process_name}' process#{plural} to start."
+      end
+      there_are_n
+    end
+
+
     # Wait for `process_name` to start.
     def wait_for_any
       return true if running_process?

data/lib/run_loop/sim_control.rb

@@ -762,6 +762,7 @@ module RunLoop
     #  updated or if the directory was skipped (see code comments).
     # @raise [RuntimeError] If called when Xcode 6 is _not_ the active Xcode version.
     def enable_keyboard_in_sim_data_dir(sim_data_dir, sim_details_keyed_with_udid, opts={})
+
       unless xcode_version_gte_6?
         raise RuntimeError, 'it is illegal to call this method when the Xcode < 6 is the current Xcode version'
       end

data/lib/run_loop/version.rb

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

data/scripts/calabash-uia-min.js

@@ -0,0 +1,7 @@
+(function(){function m(){return h.frontMostApp()}function r(){return m().mainWindow()}function s(){return m().windows().toArray()}function n(){return m().keyboard()}function l(a,c){this.reason=a;this.a=c||"";this.message=this.toString()}function k(a){return!a||a instanceof UIAElementNil}function t(a,c){var b=c||[],e,d;if(k(a))return b;e=a.elements();for(var f=0,g=e.length;f<g;f+=1)d=e[f],b.push(d),t(d,b);return b}function q(a,c){for(var b=0,e=c.length;b<e;b+=1)a.push(c[b])}function u(a,c){var b=[];
+if(k(c))return b;c instanceof this[a]&&b.push(c);for(var e=c.elements(),d=0,f=e.length;d<f;d+=1)q(b,u(a,e[d]));return b}function x(a,c){var b=null;if(a instanceof Array){if(3===a.length){var e=a[0],b=a[1],d=a[2];if("string"==typeof d)if(-1==d.indexOf("'"))d="'"+d+"'";else if(-1==d.indexOf('"'))d='"'+d+'"';else throw new l("Escaping for filters not supported yet.");b=c.withPredicate(e+" "+b+" "+d);return!k(b)}return!1}for(e in a)if(a.hasOwnProperty(e))if(b=a[e],"marked"==e){if(c.name()!=b&&c.label()!=
+b&&(!c.value||c.value!=b))return!1}else if(b=c.withValueForKey(b,e),k(b))return!1;return!0}function v(a,c){if(c(a))return a;var b,e;if(k(a))return null;b=a.elements();for(var d=0,f=b.length;d<f;d+=1)if(e=b[d],v(e,c))return e;return null}function w(a){h.delay(a);return h}var g={},h=UIATarget.localTarget();h.setTimeout(0);l.prototype=error();l.prototype.toString=function(){var a="UIAutomationError[reason="+this.reason;0<this.a.length&&(a+=", details="+this.a);return a+"]"};g.sleep=w;g.query=function(a,
+c){if(!c)return g.query(a,s());c instanceof UIAElement&&(c=[c]);var b=c,e=null,d=null,f=[],p,h,k,l;p=0;for(k=a.length;p<k;p+=1){e=a[p];h=0;for(l=b.length;h<l;h+=1)d=b[h],"string"===typeof e?"*"===e||"view"==e||"UIAElement"===e?q(f,t(d,[d])):q(f,u(e,d)):x(e,d)&&f.push(d);b=f;f=[]}return b};g.keyboard_visible=function(){return!k(n())};g.keyboard_enter_text=function(a,c){if(!g.keyboard_visible())throw new l("Keyboard not visible");c=c||{};if(c.unsafe)return n().typeString(a),!0;var b=v(r(),function(a){return 1==
+a.hasKeyboardFocus()});if(k(b))return n().typeString(a),!0;var e=c.initial_text||"",d=new Date,f=c.timeout||60,h=n();do try{return h.typeString(a),!0}catch(m){UIALogger.logMessage("keyboard_enter_text failed: "+m),UIALogger.logMessage("keyboard_enter_text retrying with restore to: "+e),b.setValue(e)}while(!(new Date-d>=1E3*f));throw new l("Unable to enter text","text: "+a+" failed after retrying for "+f);};g.deactivate=function(a){h.deactivateAppForDuration(a)};g.tap_offset=function(a,c,b){b=b||{};
+return b.unsafe?function(){return c.apply(this,arguments)}:function(){var e=new Date,d=b.timeout||60,f=b.frequency||.1;do try{return c.apply(this,arguments)}catch(g){UIALogger.logMessage(a+"Error: "+g+". Arguments: "+arguments[0]+", "+arguments[1]),w(f)}while(!(new Date-e>=1E3*d));throw new l(a,"Arguments: "+arguments[0]+", "+arguments[1]);}}("tap_offset failed",function(a,c){h.tapWithOptions(a,c||{})},{timeout:60,frequency:.5});this.target=h;this.uia=g;g.app=m;g.window=r;g.windows=s;g.keyboard=n;
+g.alert=function(){return m().alert()}})();

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: run_loop
 version: !ruby/object:Gem::Version
-  version: 1.2.7
+  version: 1.2.8
 platform: ruby
 authors:
 - Karl Krukow
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-26 00:00:00.000000000 Z
+date: 2015-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -241,10 +241,12 @@ files:
 - lib/run_loop/device.rb
 - lib/run_loop/dylib_injector.rb
 - lib/run_loop/environment.rb
+- lib/run_loop/fifo.rb
 - lib/run_loop/host_cache.rb
 - lib/run_loop/instruments.rb
 - lib/run_loop/lipo.rb
 - lib/run_loop/lldb.rb
+- lib/run_loop/logging.rb
 - lib/run_loop/monkey_patch.rb
 - lib/run_loop/plist_buddy.rb
 - lib/run_loop/process_terminator.rb
@@ -253,6 +255,7 @@ files:
 - lib/run_loop/simctl/bridge.rb
 - lib/run_loop/version.rb
 - lib/run_loop/xctools.rb
+- scripts/calabash-uia-min.js
 - scripts/calabash.lldb.erb
 - scripts/calabash_script_uia.js
 - scripts/json2-min.js
@@ -285,7 +288,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Tools related to running Calabash iOS tests