run_loop_tcc 2.1.3

data/lib/run_loop/cli/instruments.rb

@@ -0,0 +1,160 @@
+require 'thor'
+require 'run_loop'
+require 'run_loop/cli/errors'
+
+module RunLoop
+  module CLI
+    class Instruments < Thor
+
+      attr_accessor :signal
+
+      desc 'quit', 'Send a kill signal to all instruments processes.'
+
+      method_option 'signal',
+                    :desc => 'The kill signal to send.',
+                    :aliases => '-s',
+                    :required => false,
+                    :default => 'TERM',
+                    :type => :string
+
+      method_option 'debug',
+                    :desc => 'Enable debug logging.',
+                    :aliases => '-v',
+                    :required => false,
+                    :default => false,
+                    :type => :boolean
+
+
+      def quit
+        signal = options[:signal]
+        ENV['DEBUG'] = '1' if options[:debug]
+        instruments = RunLoop::Instruments.new
+        instruments.instruments_pids.each do |pid|
+          terminator = RunLoop::ProcessTerminator.new(pid, signal, 'instruments')
+          unless terminator.kill_process
+            terminator = RunLoop::ProcessTerminator.new(pid, 'KILL', 'instruments')
+            terminator.kill_process
+          end
+        end
+      end
+
+
+      desc 'launch [--app | [--ipa | --bundle-id]] [OPTIONS]', 'Launch an app with instruments.'
+
+# This is the description we want, but Thor doesn't handle newlines well(?).
+# long_desc <<EOF
+# # Launch App.app on a simulator.
+# $ be run-loop instruments launch --app /path/to/App.app
+#
+# # Launch App.ipa on a device; bundle id will be extracted.
+# $ be run-loop instruments launch --ipa /path/to/App.ipa
+#
+# # Launch the app with bundle id on a device.
+# $ be run-loop instruments launch --bundle-id com.example.MyApp-cal
+#
+# You can pass arguments to application as a comma separated list.
+# --args -NSShowNonLocalizedStrings,YES,-AppleLanguages,(de)
+# --args -com.apple.CoreData.SQLDebug,3'
+# EOF
+
+      method_option 'device',
+                    :desc => 'The device UDID or simulator identifier.',
+                    :aliases => '-d',
+                    :required => false,
+                    :type => :string
+
+      method_option 'app',
+                    :desc => 'Path to a .app bundle to launch on simulator.',
+                    :aliases => '-a',
+                    :required => false,
+                    :type => :string
+
+      method_option 'bundle-id',
+                    :desc => 'Bundle id of app to launch on device.',
+                    :aliases => '-b',
+                    :required => false,
+                    :type => :string
+
+      method_option 'template',
+                    :desc => 'Path to an automation template.',
+                    :aliases => '-t',
+                    :required => false,
+                    :type => :string
+
+      method_option 'args',
+                    :desc => 'Arguments to pass to the app.',
+                    :required => false,
+                    :type => :string
+
+      method_option 'debug',
+                    :desc => 'Enable debug logging.',
+                    :aliases => '-v',
+                    :required => false,
+                    :default => false,
+                    :type => :boolean
+
+      def launch
+
+        debug = options[:debug]
+        original_value = ENV['DEBUG']
+
+        ENV['DEBUG'] = '1' if debug
+
+        begin
+          launch_options = {
+                :args => parse_app_launch_args(options),
+                :udid => detect_device_udid_from_options(options),
+                :app => detect_bundle_id_or_bundle_path(options)
+          }
+          run_loop = RunLoop.run(launch_options)
+          puts JSON.generate(run_loop)
+        ensure
+          ENV['DEBUG'] = original_value if debug
+        end
+      end
+
+      no_commands do
+        def parse_app_launch_args(options)
+          args = options[:args]
+          if args.nil?
+            []
+          else
+            args.split(',')
+          end
+        end
+
+        def detect_bundle_id_or_bundle_path(options)
+          app = options[:app]
+          ipa = options[:ipa]
+          bundle_id = options[:bundle_id]
+
+          if app && ipa
+            raise RunLoop::CLI::ValidationError,
+                  "--app #{app} and --ipa #{ipa} are mutually exclusive arguments.  Pass one or the other, not both."
+          end
+
+          if app && bundle_id
+            raise RunLoop::CLI::ValidationError,
+                  "--app #{app} and --bundle-id #{bundle_id} are mutually exclusive arguments. Pass one or the other, not both."
+          end
+
+          if ipa && bundle_id
+            raise RunLoop::CLI::ValidationError,
+                  "--ipa #{ipa} and --bundle-id #{bundle_id} are mutually exclusive arguments. Pass one or the other, not both."
+          end
+          app || bundle_id
+        end
+
+        def detect_device_udid_from_options(options)
+          device = options[:device]
+          app = options[:app]
+          if app && !device
+            RunLoop::Core.default_simulator
+          else
+            device
+          end
+        end
+      end
+    end
+  end
+end

data/lib/run_loop/cli/locale.rb

@@ -0,0 +1,31 @@
+require "thor"
+require "run_loop"
+require "run_loop/cli/errors"
+
+module RunLoop
+  module CLI
+    class Locale < Thor
+
+      desc "print-alert-regexes", "Print privacy alert regular expressions"
+
+      def print_alert_regexes
+        dir = File.expand_path(File.dirname(__FILE__))
+        scripts_dir = File.join(dir, "..", "..", "..", "scripts")
+        on_alert = File.join(scripts_dir, "lib", "on_alert.js")
+
+        lines = []
+        File.read(on_alert).force_encoding("UTF-8").split($-0).each do |line|
+          if line[/\[\".+\", \/.+\/\]/, 0]
+            line.chomp!
+            if line[-1,1] == ","
+              line = line[0, line.length - 1]
+            end
+            lines << line
+          end
+        end
+
+        puts lines.join(",#{$-0}")
+      end
+    end
+  end
+end

data/lib/run_loop/cli/simctl.rb

@@ -0,0 +1,257 @@
+require 'thor'
+require 'run_loop'
+require 'run_loop/cli/errors'
+
+module RunLoop
+  module CLI
+    class Simctl < Thor
+
+      attr_reader :simctl
+
+      desc 'tail', 'Tail the log file of the booted simulator'
+      def tail
+        tail_booted
+      end
+
+      no_commands do
+        def tail_booted
+          device = booted_device
+          if device.nil?
+            version = xcode.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
+
+      desc 'booted', 'Prints details about the booted simulator'
+      def booted
+        device = booted_device
+        if device.nil?
+          version = xcode.version
+          puts "No simulator for active Xcode (version #{version}) is booted."
+        else
+          puts device
+        end
+      end
+
+      desc 'doctor', 'EXPERIMENTAL: Prepare the CoreSimulator environment for testing'
+
+      method_option 'debug',
+                    :desc => 'Enable debug logging.',
+                    :aliases => '-v',
+                    :required => false,
+                    :default => false,
+                    :type => :boolean
+
+      method_option 'device',
+                    :desc => 'The simulator UDID or name.',
+                    :aliases => '-d',
+                    :required => false,
+                    :type => :string
+
+      def doctor
+        debug = options[:debug]
+        device = options[:device]
+
+        manage_processes
+
+        if device
+          RunLoop::Environment.with_debugging(debug) do
+            RunLoop::CoreSimulator.erase(device)
+            launch_simulator(device, xcode)
+          end
+        else
+          RunLoop::Environment.with_debugging(debug) do
+            erase_and_launch_each_simulator
+          end
+        end
+
+      end
+
+      no_commands do
+        def erase_and_launch_each_simulator
+          simctl.simulators.each do |simulator|
+            RunLoop::CoreSimulator.erase(simulator)
+            launch_simulator(simulator, xcode)
+          end
+        end
+
+        def launch_simulator(simulator, xcode)
+          core_sim = RunLoop::CoreSimulator.new(simulator, nil,
+                                                {:xcode => xcode})
+          core_sim.launch_simulator
+        end
+      end
+
+      desc 'manage-processes', 'Manage CoreSimulator processes by quiting stale processes'
+
+      method_option 'debug',
+                    :desc => 'Enable debug logging.',
+                    :aliases => '-v',
+                    :required => false,
+                    :default => false,
+                    :type => :boolean
+
+      def manage_processes
+        debug = options[:debug]
+        original_value = ENV['DEBUG']
+
+        ENV['DEBUG'] = '1' if debug
+
+        begin
+          RunLoop::CoreSimulator.terminate_core_simulator_processes
+          process_name = "com.apple.CoreSimulator.CoreSimulatorService"
+          RunLoop::ProcessWaiter.new(process_name).pids.each do |pid|
+            kill_options = { :timeout => 0.5 }
+            RunLoop::ProcessTerminator.new(pid, 'KILL', process_name, kill_options)
+          end
+        ensure
+          ENV['DEBUG'] = original_value if debug
+        end
+      end
+
+      no_commands do
+        def simctl
+          @simctl ||= RunLoop::Simctl.new
+        end
+
+        def xcode
+          @xcode ||= RunLoop::Xcode.new
+        end
+
+        def xcrun
+          @xcrun ||= RunLoop::Xcrun.new
+        end
+
+        def booted_device
+          simctl.simulators.detect(nil) do |device|
+            device.state == 'Booted'
+          end
+        end
+      end
+
+      desc 'install --app [OPTIONS]', 'Installs an app on a device.'
+
+      method_option 'app',
+                    :desc => 'Path to a .app bundle to launch on simulator.',
+                    :aliases => '-a',
+                    :required => true,
+                    :type => :string
+
+      method_option 'device',
+                    :desc => 'The simulator UDID or name.',
+                    :aliases => '-d',
+                    :required => false,
+                    :type => :string
+
+      method_option 'debug',
+                    :desc => 'Enable debug logging.',
+                    :aliases => '-v',
+                    :required => false,
+                    :default => false,
+                    :type => :boolean
+
+      method_option 'reset-app-sandbox',
+                    :desc => 'If the app is already installed, erase the app data.',
+                    :aliases => '-r',
+                    :default => false,
+                    :type => :boolean
+
+      method_option 'force',
+                    :desc => 'Force a re-install the existing app. Deprecated 1.5.6.',
+                    :aliases => '-f',
+                    :required => false,
+                    :default => false,
+                    :type => :boolean
+
+      def install
+        debug = options[:debug]
+
+        device = expect_device(options)
+        app = expect_app(options, device)
+
+        core_sim = RunLoop::CoreSimulator.new(device, app)
+
+        RunLoop::Environment.with_debugging(debug) do
+          if options['reset-app-sandbox']
+
+            if core_sim.app_is_installed?
+              RunLoop.log_debug('Resetting the app sandbox')
+              core_sim.uninstall_app_and_sandbox
+            else
+              RunLoop.log_debug('App is not installed; skipping sandbox reset')
+            end
+          end
+          core_sim.install
+        end
+      end
+
+      no_commands do
+        def expect_device(options)
+          device_from_options = options[:device]
+          simulators = simctl.simulators
+          if device_from_options.nil?
+            default_name = RunLoop::Core.default_simulator
+            device = simulators.find do |sim|
+              sim.instruments_identifier(xcode) == default_name
+            end
+
+            if device.nil?
+              raise RunLoop::CLI::ValidationError,
+                    "Could not find a simulator with name that matches '#{device_from_options}'"
+            end
+          else
+            device = simulators.find do |sim|
+              sim.udid == device_from_options ||
+                    sim.instruments_identifier(xcode) == device_from_options
+            end
+
+            if device.nil?
+              raise RunLoop::CLI::ValidationError,
+                    "Could not find a simulator with name or UDID that matches '#{device_from_options}'"
+            end
+          end
+          device
+        end
+
+        def expect_app(options, device_obj)
+          app_bundle_path = options[:app]
+          unless File.exist?(app_bundle_path)
+            raise RunLoop::CLI::ValidationError, "Expected '#{app_bundle_path}' to exist."
+          end
+
+          unless File.directory?(app_bundle_path)
+            raise RunLoop::CLI::ValidationError,
+                  "Expected '#{app_bundle_path}' to be a directory."
+          end
+
+          unless File.extname(app_bundle_path) == '.app'
+            raise RunLoop::CLI::ValidationError,
+                  "Expected '#{app_bundle_path}' to end in .app."
+          end
+
+          app = RunLoop::App.new(app_bundle_path)
+
+          begin
+            app.bundle_identifier
+            app.executable_name
+          rescue RuntimeError => e
+            raise RunLoop::CLI::ValidationError, e.message
+          end
+
+          lipo = RunLoop::Lipo.new(app.path)
+          begin
+            lipo.expect_compatible_arch(device_obj)
+          rescue RunLoop::IncompatibleArchitecture => e
+            raise RunLoop::CLI::ValidationError, e.message
+          end
+
+          app
+        end
+      end
+    end
+  end
+end

data/lib/run_loop/cli/tcc.rb

@@ -0,0 +1,139 @@
+require "thor"
+require "run_loop"
+require "run_loop/cli/errors"
+
+module RunLoop
+  module CLI
+    class TCC < Thor
+
+      desc "services", "Print known services"
+
+      def services
+        RunLoop::TCC::PRIVACY_SERVICES.each do |key, _|
+          puts key
+        end
+      end
+
+      desc "open", "Open the TCC.db of a device in an editor EXPERIMENTAL"
+
+      method_option "device",
+        :desc => "Device name or identifier.",
+        :aliases => "-d",
+        :required => true,
+        :type => :string
+
+      def open
+        device = expect_device(options)
+
+        tcc_db = device.simulator_tcc_db
+
+        return false if tcc_db.nil?
+
+        args = ['open', tcc_db]
+
+        pid = Process.spawn(*args)
+        Process.detach(pid)
+        pid
+      end
+
+      desc "allow", "Prevent a Privacy Alert from appearing (Sim only)"
+
+      method_option "device",
+        :desc => "Device name or identifier. If undefined, operation will be on all devices",
+        :aliases => "-d",
+        :required => false,
+        :type => :string
+
+      method_option "app",
+        :desc => "App bundle id to allow service on",
+        :aliases => "-a",
+        :required => true,
+        :type => :string
+
+      method_option "service",
+        :desc => "Service to allow.  If undefined, all known services will be allowed",
+        :aliases => "-s",
+        :required => false,
+        :type => :string
+
+      method_option 'debug',
+        :desc => 'Enable debug logging.',
+        :aliases => '-v',
+        :required => false,
+        :default => false,
+        :type => :boolean
+
+      def allow
+        debug = options[:debug]
+
+        device = options[:device]
+        if device
+          devices = [expect_device(options)]
+        else
+          devices = sim_control.simulators
+        end
+
+        service = options[:service]
+
+        if service
+          services = [service]
+        else
+         services = RunLoop::TCC::PRIVACY_SERVICES.map do |key, _|
+          key
+         end
+        end
+
+        app = options[:app]
+
+        RunLoop::Environment.with_debugging(debug) do
+          devices.each do |_device|
+            tcc = RunLoop::TCC.new(_device, app)
+            services.each do |_service|
+              tcc.allow_service(_service)
+            end
+          end
+        end
+        true
+      end
+
+      no_commands do
+        def expect_device(options)
+          device_from_options = options[:device]
+          simulators = sim_control.simulators
+          if device_from_options.nil?
+            default_name = RunLoop::Core.default_simulator
+            device = simulators.find do |sim|
+              sim.instruments_identifier(xcode) == default_name
+            end
+
+            if device.nil?
+              raise RunLoop::CLI::ValidationError,
+                    "Could not find a simulator with name that matches '#{device_from_options}'"
+            end
+          else
+            device = simulators.find do |sim|
+              sim.udid == device_from_options ||
+                    sim.instruments_identifier(xcode) == device_from_options
+            end
+
+            if device.nil?
+              raise RunLoop::CLI::ValidationError,
+                    "Could not find a simulator with name or UDID that matches '#{device_from_options}'"
+            end
+          end
+          device
+        end
+
+        def sim_control
+          @sim_control ||= RunLoop::SimControl.new
+        end
+
+        def xcode
+          @xcode ||= RunLoop::Xcode.new
+        end
+      end
+
+    end
+  end
+end
+

data/lib/run_loop/codesign.rb

@@ -0,0 +1,76 @@
+module RunLoop
+  # @!visibility private
+  # A wrapper around codesign command line tool
+  class Codesign
+
+    # @!visibility private
+    DEV_REGEX = /Authority=iPhone Developer:/
+
+    # @!visibility private
+    APP_STORE_REGEX = /Authority=Apple iPhone OS Application Signing/
+
+    # @!visibility private
+    DISTR_REGEX = /Authority=iPhone Distribution:/
+
+    # @!visibility private
+    NOT_SIGNED_REGEX = /code object is not signed at all/
+
+    # @!visibility private
+    def self.info(path)
+      self.expect_path_exists(path)
+      self.run_codesign_command(["--display", "--verbose=4", path])
+    end
+
+    # @!visibility private
+    #
+    # True if the asset is signed.
+    def self.signed?(path)
+      info = self.info(path)
+      info[NOT_SIGNED_REGEX, 0] == nil
+    end
+
+    # @!visibility private
+    #
+    # True if the asset is signed with anything other than a dev cert.
+    def self.distribution?(path)
+      info = self.info(path)
+
+      info[NOT_SIGNED_REGEX, 0] == nil &&
+        info[DEV_REGEX, 0] == nil
+    end
+
+    # @!visibility private
+    #
+    # True if the asset is signed with a dev cert
+    def self.developer?(path)
+      info = self.info(path)
+      info[DEV_REGEX, 0] != nil
+    end
+
+    private
+
+    def self.expect_path_exists(path)
+      if !File.exist?(path)
+        raise ArgumentError,
+%Q{There is no file or directory at path:
+
+#{path}
+}
+      end
+    end
+
+    def self.run_codesign_command(args)
+      if !args.is_a?(Array)
+        raise ArgumentError, "Expected args: '#{args}' to be an Array"
+      end
+
+      xcrun = RunLoop::Xcrun.new
+      cmd = ["codesign"] + args
+      options = {:log_cmd => true}
+      hash = xcrun.run_command_in_context(cmd, options)
+
+      hash[:out]
+    end
+  end
+end
+