run_loop 1.5.5 → 1.5.6.pre1

data/lib/run_loop/version.rb

@@ -1,5 +1,5 @@
 module RunLoop
-  VERSION = '1.5.5'
+  VERSION = '1.5.6.pre1'
 
   # A model of a software release version that can be used to compare two versions.
   #
@@ -44,7 +44,7 @@ module RunLoop
     #  version.minor       => 10
     #  version.patch       => 1
     #  version.pre         => false
-    #  version.pre_release => nil
+    #  version.pre_version => nil
     #
     # @example
     #  version = Version.new(1.6.3.pre5)
@@ -52,7 +52,7 @@ module RunLoop
     #  version.minor       => 6
     #  version.patch       => 3
     #  version.pre         => true
-    #  version.pre_release => 5
+    #  version.pre_version => 5
     #
     # @param [String] version the version string to parse.
     # @raise [ArgumentError] if version is not in the form 5, 6.1, 7.1.2, 8.2.3.pre1
@@ -88,6 +88,18 @@ module RunLoop
       "#<Version #{to_s}>"
     end
 
+    # Compare this version to another for _object_ equality.  This allows
+    # Version instances to be used as Hash keys.
+    # @param [Version] other the version to compare against.
+    def eql?(other)
+      hash == other.hash
+    end
+
+    # The hash method for this instance.
+    def hash
+      to_s.hash
+    end
+
     # Compare this version to another for equality.
     # @param [Version] other the version to compare against
     # @return [Boolean] true if this Version is the same as `other`

data/lib/run_loop.rb

@@ -2,6 +2,7 @@ require 'run_loop/regex'
 require 'run_loop/directory'
 require 'run_loop/environment'
 require 'run_loop/logging'
+require 'run_loop/dot_dir'
 require 'run_loop/xcrun'
 require 'run_loop/xcode'
 require 'run_loop/l10n'
@@ -24,9 +25,7 @@ require 'run_loop/cache/cache'
 require 'run_loop/host_cache'
 require 'run_loop/patches/awesome_print'
 require 'run_loop/patches/retriable'
-require 'run_loop/life_cycle/simulator'
-require 'run_loop/life_cycle/core_simulator'
-require 'run_loop/simctl/bridge'
+require 'run_loop/core_simulator'
 require 'run_loop/simctl/plists'
 
 module RunLoop
@@ -59,13 +58,13 @@ module RunLoop
   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")
+      raise %q(The Instruments.app is open.
+
+If the Instruments.app is open, the instruments command line tool cannot take
+control of your application.
+
+Please quit the Instruments.app and try again.)
+
     end
 
     uia_strategy = options[:uia_strategy]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: run_loop
 version: !ruby/object:Gem::Version
-  version: 1.5.5
+  version: 1.5.6.pre1
 platform: ruby
 authors:
 - Karl Krukow
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-25 00:00:00.000000000 Z
+date: 2015-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -290,8 +290,10 @@ files:
 - lib/run_loop/cli/instruments.rb
 - lib/run_loop/cli/simctl.rb
 - lib/run_loop/core.rb
+- lib/run_loop/core_simulator.rb
 - lib/run_loop/device.rb
 - lib/run_loop/directory.rb
+- lib/run_loop/dot_dir.rb
 - lib/run_loop/dylib_injector.rb
 - lib/run_loop/environment.rb
 - lib/run_loop/fifo.rb
@@ -299,8 +301,6 @@ files:
 - lib/run_loop/instruments.rb
 - lib/run_loop/ipa.rb
 - lib/run_loop/l10n.rb
-- lib/run_loop/life_cycle/core_simulator.rb
-- lib/run_loop/life_cycle/simulator.rb
 - lib/run_loop/lipo.rb
 - lib/run_loop/lldb.rb
 - lib/run_loop/logging.rb
@@ -311,7 +311,6 @@ files:
 - lib/run_loop/process_waiter.rb
 - lib/run_loop/regex.rb
 - lib/run_loop/sim_control.rb
-- lib/run_loop/simctl/bridge.rb
 - lib/run_loop/simctl/plists.rb
 - lib/run_loop/version.rb
 - lib/run_loop/xcode.rb
@@ -345,9 +344,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '1.9'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.8

data/lib/run_loop/life_cycle/core_simulator.rb

@@ -1,515 +0,0 @@
-module RunLoop
-  module LifeCycle
-
-    class CoreSimulator < Simulator
-
-      require 'securerandom'
-
-      # @!visibility private
-      METADATA_PLIST = '.com.apple.mobile_container_manager.metadata.plist'
-
-      # @!visibility private
-      CORE_SIMULATOR_DEVICE_DIR = File.expand_path('~/Library/Developer/CoreSimulator/Devices')
-
-      # @!visibility private
-      # How long to wait after the simulator has launched.
-      SIM_POST_LAUNCH_WAIT = RunLoop::Environment.sim_post_launch_wait || 1.0
-
-      # @!visibility private
-      # How long to wait for for a device to reach a state.
-      WAIT_FOR_DEVICE_STATE_OPTS =
-            {
-                  interval: 0.1,
-                  timeout: 5
-            }
-
-      # @!visibility private
-      # How long to wait for the CoreSimulator processes to start.
-      WAIT_FOR_SIMULATOR_PROCESSES_OPTS =
-            {
-                  timeout: 5,
-                  raise_on_timeout: true
-            }
-
-      attr_reader :app
-      attr_reader :device
-      attr_reader :sim_control
-      attr_reader :pbuddy
-
-      # @param [RunLoop::App] app The application.
-      # @param [RunLoop::Device] device The device.
-      def initialize(app, device, sim_control=RunLoop::SimControl.new)
-        @app = app
-        @device = device
-        @sim_control = sim_control
-
-        # In order to manage the app on the device, we need to manage the
-        # CoreSimulator processes.
-        RunLoop::SimControl.terminate_all_sims
-        terminate_core_simulator_processes
-      end
-
-      # Launch simulator without specifying an app.
-      def launch_simulator
-        sim_path = sim_control.send(:sim_app_path)
-        args = ['open', '-g', '-a', sim_path, '--args', '-CurrentDeviceUDID', device.udid]
-
-        RunLoop.log_debug("Launching #{device} with:")
-        RunLoop.log_unix_cmd("xcrun #{args.join(' ')}")
-
-        start_time = Time.now
-
-        pid = spawn('xcrun', *args)
-        Process.detach(pid)
-
-        sim_name = sim_control.send(:sim_name)
-
-        RunLoop::ProcessWaiter.new(sim_name, WAIT_FOR_SIMULATOR_PROCESSES_OPTS).wait_for_any
-
-        device.simulator_wait_for_stable_state
-
-        elapsed = Time.now - start_time
-        RunLoop.log_debug("Took #{elapsed} seconds to launch the simulator")
-
-        true
-      end
-
-      # @!visibility private
-      def pbuddy
-        @pbuddy ||= RunLoop::PlistBuddy.new
-      end
-
-      # @!visibility private
-      def sdk_gte_8?
-        device.version >= RunLoop::Version.new('8.0')
-      end
-
-      # The data directory for the the device.
-      #
-      # ~/Library/Developer/CoreSimulator/Devices/<UDID>/data
-      def device_data_dir
-        @device_data_dir ||= File.join(CORE_SIMULATOR_DEVICE_DIR, device.udid, 'data')
-      end
-
-      # The applications directory for the device.
-      #
-      # ~/Library/Developer/CoreSimulator/Devices/<UDID>/Containers/Bundle/Application
-      def device_applications_dir
-        @device_app_dir ||= lambda do
-          if sdk_gte_8?
-            File.join(device_data_dir, 'Containers', 'Bundle', 'Application')
-          else
-            File.join(device_data_dir, 'Applications')
-          end
-        end.call
-      end
-
-      # The sandbox directory for the app.
-      #
-      # ~/Library/Developer/CoreSimulator/Devices/<UDID>/Containers/Data/Application
-      #
-      # Contains Library, Documents, and tmp directories.
-      def app_sandbox_dir
-        app_install_dir = installed_app_bundle_dir
-        return nil if app_install_dir.nil?
-        if sdk_gte_8?
-          app_sandbox_dir_sdk_gte_8
-        else
-          app_install_dir
-        end
-      end
-
-      # The Library directory in the sandbox.
-      def app_library_dir
-        base_dir = app_sandbox_dir
-        if base_dir.nil?
-          nil
-        else
-          File.join(base_dir, 'Library')
-        end
-      end
-
-      # The Library/Preferences directory in the sandbox.
-      def app_library_preferences_dir
-        base_dir = app_library_dir
-        if base_dir.nil?
-          nil
-        else
-          File.join(base_dir, 'Preferences')
-        end
-      end
-
-      # The Documents directory in the sandbox.
-      def app_documents_dir
-        base_dir = app_sandbox_dir
-        if base_dir.nil?
-          nil
-        else
-          File.join(base_dir, 'Documents')
-        end
-      end
-
-      # The tmp directory in the sandbox.
-      def app_tmp_dir
-        base_dir = app_sandbox_dir
-        if base_dir.nil?
-          nil
-        else
-          File.join(base_dir, 'tmp')
-        end
-      end
-
-      # Is this app installed?
-      def app_is_installed?
-        !installed_app_bundle_dir.nil?
-      end
-
-      # The sha1 of the installed app.
-      def installed_app_sha1
-        installed_bundle = installed_app_bundle_dir
-        if installed_bundle
-          RunLoop::Directory.directory_digest(installed_bundle)
-        else
-          nil
-        end
-      end
-
-      # Is the app that is install the same as the one we have in hand?
-      def same_sha1_as_installed?
-        app.sha1 == installed_app_sha1
-      end
-
-      # @!visibility private
-      #
-      # Returns the path to the installed app bundle directory (.app).
-      #
-      # If this method returns nil, the app is not installed.
-      def installed_app_bundle_dir
-        sim_app_dir = device_applications_dir
-        return nil if !File.exist?(sim_app_dir)
-        Dir.glob("#{sim_app_dir}/**/*.app").find do |path|
-          RunLoop::App.new(path).bundle_identifier == app.bundle_identifier
-        end
-      end
-
-      # Uninstall the app on the device.
-      def uninstall
-        installed_app_bundle = installed_app_bundle_dir
-        if installed_app_bundle
-          uninstall_app_and_sandbox(installed_app_bundle)
-          :uninstalled
-        else
-          RunLoop.log_debug('App was not installed.  Nothing to do')
-          :not_installed
-        end
-      end
-
-      # Install the app on the device.
-      def install
-        installed_app_bundle = installed_app_bundle_dir
-
-        # App is not installed.
-        return install_new_app if installed_app_bundle.nil?
-
-        # App is installed but sha1 is different.
-        if !same_sha1_as_installed?
-          return reinstall_existing_app_and_clear_sandbox(installed_app_bundle)
-        end
-
-        RunLoop.log_debug('The installed app is the same as the app we are trying to install; skipping installation')
-        installed_app_bundle
-      end
-
-      # @!visibility private
-      #
-      # 1. Does nothing if the app is not installed.
-      # 2. Does nothing if the app the same as the app that is installed
-      # 3. Installs app if it is different from the installed app
-      #
-      # TODO needs unit tests and a better name?
-      def ensure_app_same
-        installed_app_bundle = installed_app_bundle_dir
-
-        if !installed_app_bundle
-          RunLoop.log_debug("App: #{app} is not installed")
-          return true
-        end
-
-        installed_sha = installed_app_sha1
-        app_sha = app.sha1
-
-        if installed_sha == app_sha
-          RunLoop.log_debug("Installed app is the same as #{app}")
-          return true
-        end
-
-        RunLoop.log_debug("The app you are trying to launch is not the same as the app that is installed.")
-        RunLoop.log_debug("  Installed app SHA: #{installed_sha}")
-        RunLoop.log_debug("  App to launch SHA: #{app_sha}")
-        RunLoop.log_debug("Will install #{app}")
-
-
-        FileUtils.rm_rf installed_app_bundle
-        RunLoop.log_debug('Deleted the existing app')
-
-        directory = File.expand_path(File.join(installed_app_bundle, '..'))
-        bundle_name = File.basename(app.path)
-        target = File.join(directory, bundle_name)
-
-        args = ['ditto', app.path, target]
-        RunLoop::Xcrun.new.exec(args, log_cmd: true)
-
-        RunLoop.log_debug("Installed #{app} on CoreSimulator #{device.udid}")
-
-        clear_device_launch_csstore
-
-        true
-      end
-
-      # Reset app sandbox.
-      def reset_app_sandbox
-        return true if !app_is_installed?
-
-        wait_for_device_state('Shutdown')
-
-        reset_app_sandbox_internal
-      end
-
-      private
-
-      def generate_uuid
-        SecureRandom.uuid.upcase!
-      end
-
-      def existing_app_container_uuids
-        if File.exist?(device_applications_dir)
-          Dir.entries(device_applications_dir)
-        else
-          []
-        end
-      end
-
-      def generate_unique_uuid(existing, timeout=1.0)
-        begin
-          Timeout::timeout(timeout, Timeout::Error) do
-          uuid = generate_uuid
-          loop do
-            break if !existing.include?(uuid)
-            uuid = generate_uuid
-          end
-          uuid
-          end
-        rescue Timeout::Error => _
-          raise RuntimeError,
-                "Expected to be able to generate a unique uuid in #{timeout} seconds"
-        end
-      end
-
-      def install_new_app
-        wait_for_device_state('Shutdown')
-
-        existing = existing_app_container_uuids
-        udid = generate_unique_uuid(existing)
-        directory = File.join(device_applications_dir, udid)
-
-        bundle_name = File.basename(app.path)
-        target = File.join(directory, bundle_name)
-
-        args = ['ditto', app.path, target]
-        RunLoop::Xcrun.new.exec(args, log_cmd: true)
-        target
-      end
-
-      def reinstall_existing_app_and_clear_sandbox(installed_app_bundle)
-        wait_for_device_state('Shutdown')
-
-        reset_app_sandbox_internal
-
-        if File.exist?(installed_app_bundle)
-          FileUtils.rm_rf(installed_app_bundle)
-          RunLoop.log_debug("Deleted app bundle: #{installed_app_bundle}")
-        end
-
-        directory = File.dirname(installed_app_bundle)
-        bundle_name = File.basename(app.path)
-        target = File.join(directory, bundle_name)
-
-        args = ['ditto', app.path, target]
-        RunLoop::Xcrun.new.exec(args, log_cmd: true)
-        installed_app_bundle
-      end
-
-      def uninstall_app_and_sandbox(installed_app_bundle)
-        wait_for_device_state('Shutdown')
-
-        if sdk_gte_8?
-          # Must delete the sandbox first.
-          directory = app_sandbox_dir
-          if File.exist?(directory)
-            FileUtils.rm_rf(directory)
-            RunLoop.log_debug("Deleted app sandbox: #{directory}")
-          end
-
-          directory = File.dirname(installed_app_bundle)
-          if File.exist?(directory)
-            FileUtils.rm_rf(directory)
-            RunLoop.log_debug("Deleted app container: #{directory}")
-          end
-        else
-          # Sandbox _is_ in the container.
-          directory = File.dirname(installed_app_bundle)
-          if File.exist?(directory)
-            FileUtils.rm_rf(directory)
-            RunLoop.log_debug("Deleted app container: #{directory}")
-          end
-        end
-      end
-
-      # @!visibility private
-      def app_sandbox_dir_sdk_gte_8
-        containers_data_dir = File.join(device_data_dir, 'Containers', 'Data', 'Application')
-        apps = Dir.glob("#{containers_data_dir}/**/#{METADATA_PLIST}")
-        match = apps.find do |metadata_plist|
-          pbuddy.plist_read('MCMMetadataIdentifier', metadata_plist) == app.bundle_identifier
-        end
-        if match
-          File.dirname(match)
-        else
-          nil
-        end
-      end
-
-      # @!visibility private
-      def wait_for_device_state(target_state)
-        now = Time.now
-        timeout = WAIT_FOR_DEVICE_STATE_OPTS[:timeout]
-        poll_until = now + timeout
-        delay = WAIT_FOR_DEVICE_STATE_OPTS[:interval]
-        in_state = false
-        while Time.now < poll_until
-          in_state = device.update_simulator_state == target_state
-          break if in_state
-          sleep delay
-        end
-
-        elapsed = Time.now - now
-        RunLoop.log_debug("Waited for #{elapsed} seconds for device to have state: '#{target_state}'.")
-
-        unless in_state
-          raise "Expected '#{target_state} but found '#{device.state}' after waiting."
-        end
-        in_state
-      end
-
-      # @!visibility private
-      def device_caches_dir
-        @device_caches_dir ||= File.join(device_data_dir, 'Library', 'Caches')
-      end
-
-      # @!visibility private
-      def clear_device_launch_csstore
-        glob = File.join(device_caches_dir, "com.apple.LaunchServices-*.csstore")
-        Dir.glob(glob) do | ccstore |
-          FileUtils.rm_f ccstore
-        end
-      end
-
-      # @!visibility private
-      def reset_app_sandbox_internal_shared
-        [app_documents_dir, app_tmp_dir].each do |dir|
-          FileUtils.rm_rf dir
-          FileUtils.mkdir dir
-        end
-      end
-
-      # @!visibility private
-      def reset_app_sandbox_internal_sdk_gte_8
-        lib_dir = app_library_dir
-        RunLoop::Directory.recursive_glob_for_entries(lib_dir).each do |entry|
-          if entry.include?('Preferences')
-            # nop
-          else
-            if File.exist?(entry)
-              FileUtils.rm_rf(entry)
-            end
-          end
-        end
-
-        prefs_dir = app_library_preferences_dir
-        protected = ['com.apple.UIAutomation.plist',
-                     'com.apple.UIAutomationPlugIn.plist']
-        RunLoop::Directory.recursive_glob_for_entries(prefs_dir).each do |entry|
-          unless protected.include?(File.basename(entry))
-            if File.exist?(entry)
-              FileUtils.rm_rf entry
-            end
-          end
-        end
-      end
-
-      # @!visibility private
-      def reset_app_sandbox_internal_sdk_lt_8
-        prefs_dir = app_library_preferences_dir
-        RunLoop::Directory.recursive_glob_for_entries(prefs_dir).each do |entry|
-          if entry.end_with?('.GlobalPreferences.plist') ||
-                entry.end_with?('com.apple.PeoplePicker.plist')
-            # nop
-          else
-            if File.exist?(entry)
-              FileUtils.rm_rf entry
-            end
-          end
-        end
-
-        # app preferences lives in device Library/Preferences
-        device_prefs_dir = File.join(app_sandbox_dir, 'Library', 'Preferences')
-        app_prefs_plist = File.join(device_prefs_dir, "#{app.bundle_identifier}.plist")
-        if File.exist?(app_prefs_plist)
-          FileUtils.rm_rf(app_prefs_plist)
-        end
-      end
-
-      # @!visibility private
-      def reset_app_sandbox_internal
-        reset_app_sandbox_internal_shared
-
-        if sdk_gte_8?
-          reset_app_sandbox_internal_sdk_gte_8
-        else
-          reset_app_sandbox_internal_sdk_lt_8
-        end
-      end
-
-      # @!visibility private
-      # For testing.
-      def launch
-
-        launch_simulator
-
-        args = ['simctl', 'install', device.udid, app.path]
-        RunLoop::Xcrun.new.exec(args, log_cmd: true, timeout: 10)
-
-        device.simulator_wait_for_stable_state
-
-        args = ['simctl', 'launch', device.udid, app.bundle_identifier]
-        hash = RunLoop::Xcrun.new.exec(args, log_cmd: true, timeout: 20)
-
-        exit_status = hash[:exit_status]
-
-        if exit_status != 0
-          err = hash[:err]
-          RunLoop.log_error(err)
-          raise RuntimeError, "Could not launch #{app.bundle_identifier} on #{device}"
-        end
-
-        RunLoop::ProcessWaiter.new(app.executable_name, {:timeout => 10,
-                                                         :raise_on_timeout => true}).wait_for_any
-
-
-        device.simulator_wait_for_stable_state
-
-        true
-      end
-    end
-  end
-end