simctl 1.6.2 → 1.6.3

data/fastlane-plugin-simctl/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gemspec
+
+plugins_path = File.join(File.dirname(__FILE__), 'fastlane', 'Pluginfile')
+eval_gemfile(plugins_path) if File.exist?(plugins_path)

data/fastlane-plugin-simctl/README.md

@@ -0,0 +1,46 @@
+# fastlane-plugin-simctl
+
+## Getting Started
+
+This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-simctl`, add it to your project by running:
+
+```bash
+fastlane add_plugin simctl
+```
+
+## About fastlane-plugin-simctl
+
+Fastlane plugin to interact with xcrun simctl. Manage your iOS Simulators directly from your Fastfile.
+
+## Example
+
+Check out the [example `Fastfile`](fastlane/Fastfile) to see how to use this plugin. Try it by cloning the repo, running `fastlane install_plugins` and `bundle exec fastlane test`.
+
+## Run tests for this plugin
+
+To run both the tests, and code style validation, run
+
+```
+rake
+```
+
+To automatically fix many of the styling issues, use
+```
+rubocop -a
+```
+
+## Issues and Feedback
+
+For any other issues and feedback about this plugin, please submit it to this repository.
+
+## Troubleshooting
+
+If you have trouble using plugins, check out the [Plugins Troubleshooting](https://docs.fastlane.tools/plugins/plugins-troubleshooting/) guide.
+
+## Using _fastlane_ Plugins
+
+For more information about how the `fastlane` plugin system works, check out the [Plugins documentation](https://docs.fastlane.tools/plugins/create-plugin/).
+
+## About _fastlane_
+
+_fastlane_ is the easiest way to automate beta deployments and releases for your iOS and Android apps. To learn more, check out [fastlane.tools](https://fastlane.tools).

data/fastlane-plugin-simctl/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new(:rubocop)
+
+task default: [:spec, :rubocop]

data/fastlane-plugin-simctl/fastlane-plugin-simctl.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fastlane/plugin/simctl/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'fastlane-plugin-simctl'
+  spec.version       = Fastlane::Simctl::VERSION
+  spec.author        = 'Renzo Crisostomo'
+  spec.email         = 'renzo.crisostomo@me.com'
+
+  spec.summary       = 'Fastlane plugin to interact with xcrun simctl'
+  spec.license       = "MIT"
+
+  spec.files         = Dir["lib/**/*"] + %w(README.md)
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'simctl', '~> 1.6.2'
+
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'fastlane', '>= 2.53.1'
+end

data/fastlane-plugin-simctl/fastlane/Fastfile

@@ -0,0 +1,9 @@
+lane :test do
+  simctl(block: lambda { |other_action, device|
+    other_action.scan(workspace: "#{Dir.pwd}/AwesomeApp.xcworkspace",
+                      scheme: 'AwesomeApp',
+                      device: device.name,
+                      derived_data_path: derived_data_path)
+  })
+  trainer(output_directory: ".")
+end

data/fastlane-plugin-simctl/fastlane/Pluginfile

@@ -0,0 +1 @@
+# Autogenerated by fastlane

data/fastlane-plugin-simctl/lib/fastlane/plugin/simctl.rb

@@ -0,0 +1,16 @@
+require 'fastlane/plugin/simctl/version'
+
+module Fastlane
+  module Simctl
+    # Return all .rb files inside the "actions" and "helper" directory
+    def self.all_classes
+      Dir[File.expand_path('**/{actions,helper}/*.rb', File.dirname(__FILE__))]
+    end
+  end
+end
+
+# By default we want to import all available actions and helpers
+# A plugin can contain any number of actions and plugins
+Fastlane::Simctl.all_classes.each do |current|
+  require current
+end

data/fastlane-plugin-simctl/lib/fastlane/plugin/simctl/actions/simctl_action.rb

@@ -0,0 +1,51 @@
+require 'simctl'
+
+module Fastlane
+  module Actions
+    class SimctlAction < Action
+      def self.run(params)
+        Helper::SimctlHelper.execute_with_simulator_ready(self, params[:block], params[:runtime], params[:type], params[:name])
+      end
+
+      def self.description
+        "Fastlane plugin to interact with xcrun simctl."
+      end
+
+      def self.authors
+        ["Renzo Crisostomo"]
+      end
+
+      def self.details
+        "Fastlane plugin to interact with xcrun simctl. Manage your iOS Simulators directly from your Fastfile."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :block,
+                               description: "A Ruby block given to execute in the context of a Simulator ready",
+                                  optional: false,
+                                      type: Proc),
+          FastlaneCore::ConfigItem.new(key: :runtime,
+                               description: "iOS Runtime used to create the simulator",
+                                  optional: true,
+                                      type: String,
+                             default_value: 'latest'),
+          FastlaneCore::ConfigItem.new(key: :type,
+                               description: "iOS device type used to create the simulator",
+                                  optional: true,
+                                      type: String,
+                             default_value: 'iPhone 6'),
+          FastlaneCore::ConfigItem.new(key: :name,
+                               description: "String used to set the name to the simulator",
+                                  optional: true,
+                                      type: String,
+                             default_value: nil)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        [:ios].include?(platform)
+      end
+    end
+  end
+end

data/fastlane-plugin-simctl/lib/fastlane/plugin/simctl/helper/simctl_helper.rb

@@ -0,0 +1,52 @@
+module Fastlane
+  module Helper
+    class SimctlHelper
+      def self.execute_with_simulator_ready(action, block, runtime, type, name)
+        device = create_device(runtime, type, name)
+        device.launch
+        device.wait(90) do |d|
+          Fastlane::UI.message("Waiting for simulator `#{d.name}` to be ready")
+          d.state == :booted && d.ready?
+        end
+        begin
+          block.call(action.other_action, device)
+        rescue StandardError => error
+          throw error
+        ensure
+          delete_device(device)
+        end
+      end
+
+      def self.create_device(runtime, type, name)
+        runtime = if runtime.eql? 'latest'
+                    SimCtl::Runtime.latest('ios')
+                  else
+                    SimCtl.runtime(name: runtime)
+                  end
+        device_type = SimCtl.devicetype(name: type)
+        device_name = name
+        device_name ||= type.to_s.instance_eval do |obj|
+          obj += "-#{ENV['JOB_NAME']}" if ENV['JOB_NAME']
+          obj += "@#{ENV['BUILD_NUMBER']}" if ENV['BUILD_NUMBER']
+          obj
+        end
+        Fastlane::UI.message("Starting simulator with runtime: `#{runtime.name}`, device type: `#{device_type.name}`"\
+          " and device name: `#{device_name}`")
+        SimCtl.reset_device(device_name, device_type, runtime)
+      end
+
+      def self.delete_device(device)
+        if device.state != :shutdown
+          device.shutdown
+          device.kill
+          device.wait do |d|
+            Fastlane::UI.message("Waiting for simulator `#{d.name}` to be shutdown")
+            d.state == :shutdown
+          end
+        end
+        Fastlane::UI.message("Deleting simulator `#{device.name}`")
+        device.delete
+      end
+    end
+  end
+end

data/fastlane-plugin-simctl/lib/fastlane/plugin/simctl/version.rb

@@ -0,0 +1,5 @@
+module Fastlane
+  module Simctl
+    VERSION = "0.2.0"
+  end
+end

data/fastlane-plugin-simctl/spec/simctl_action_spec.rb

@@ -0,0 +1,4 @@
+describe Fastlane::Actions::SimctlAction do
+  describe '#run' do
+  end
+end

data/fastlane-plugin-simctl/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'simplecov'
+
+# SimpleCov.minimum_coverage 95
+SimpleCov.start
+
+# This module is only used to check the environment is currently a testing env
+module SpecHelper
+end
+
+require 'fastlane' # to import the Action super class
+require 'fastlane/plugin/simctl' # import the actual plugin
+
+Fastlane.load_actions # load other actions (in case your plugin calls other actions or shared values)

data/lib/simctl.rb

@@ -30,7 +30,7 @@ module SimCtl
 
     private
 
-    def respond_to_missing?(method_name, include_private=false)
+    def respond_to_missing?(method_name, include_private = false)
       command.respond_to?(method_name, include_private)
     end
 

data/lib/simctl/command/create.rb

@@ -14,10 +14,11 @@ module SimCtl
         devicetype = devicetype(name: devicetype) unless devicetype.is_a?(DeviceType)
         raise "Invalid runtime: #{runtime}" unless runtime.is_a?(Runtime)
         raise "Invalid devicetype: #{devicetype}" unless devicetype.is_a?(DeviceType)
-        device = Executor.execute(command_for('create', Shellwords.shellescape(name), devicetype.identifier, runtime.identifier)) do |identifier|
+        command = command_for('create', Shellwords.shellescape(name), devicetype.identifier, runtime.identifier)
+        device = Executor.execute(command) do |identifier|
           device(udid: identifier)
         end
-        device.wait {|d| d.state == :shutdown && File.exists?(d.path.device_plist)}
+        device.wait { |d| d.state == :shutdown && File.exist?(d.path.device_plist) }
         device
       end
     end

data/lib/simctl/command/delete.rb

@@ -16,7 +16,7 @@ module SimCtl
         list_devices.each do |device|
           device.kill
           device.shutdown if device.state != :shutdown
-          device.wait {|d| d.state == :shutdown}
+          device.wait { |d| d.state == :shutdown }
           device.delete
         end
       end

data/lib/simctl/command/erase.rb

@@ -11,5 +11,3 @@ module SimCtl
     end
   end
 end
-
-

data/lib/simctl/command/io.rb

@@ -11,11 +11,11 @@ module SimCtl
       # * type: Can be png, tiff, bmp, gif, jpeg (default is png)
       # * display: Can be main or tv for iOS, tv for tvOS and main for watchOS
       # @return [void]
-      def screenshot(device, file, opts={})
+      def screenshot(device, file, opts = {})
         unless Xcode::Version.gte? '8.2'
-          raise UnsupportedCommandError.new('Needs at least Xcode 8.2')
+          raise UnsupportedCommandError, 'Needs at least Xcode 8.2'
         end
-        optional_args = opts.map {|k,v| "--#{k}=#{Shellwords.shellescape(v)}"}
+        optional_args = opts.map { |k, v| "--#{k}=#{Shellwords.shellescape(v)}" }
         Executor.execute(command_for('io', device.udid, 'screenshot', *optional_args, Shellwords.shellescape(file)))
       end
     end

data/lib/simctl/command/launch.rb

@@ -3,13 +3,13 @@ require 'shellwords'
 module SimCtl
   class Command
     module Launch
-      SUPPORTED_SCALE = [1.0, 0.75, 0.5, 0.25]
+      SUPPORTED_SCALE = [1.0, 0.75, 0.5, 0.25].freeze
 
       # Launches a Simulator instance with the given device
       #
       # @param device [SimCtl::Device] the device to launch
       # @return [void]
-      def launch_device(device, scale=1.0, opts={})
+      def launch_device(device, scale = 1.0, opts = {})
         raise "unsupported scale '#{scale}' (supported: #{SUPPORTED_SCALE.join(', ')})" unless SUPPORTED_SCALE.include?(scale)
         # Launching the same device twice does not work.
         # Simulator.app would just hang. Solution: Kill first.
@@ -17,9 +17,9 @@ module SimCtl
         args = {
           '-ConnectHardwareKeyboard' => 1,
           '-CurrentDeviceUDID' => device.udid,
-          "-SimulatorWindowLastScale-#{device.devicetype.identifier}" => scale,
+          "-SimulatorWindowLastScale-#{device.devicetype.identifier}" => scale
         }
-        args.merge!({ '-DeviceSetPath' => Shellwords.shellescape(SimCtl.device_set_path) }) unless SimCtl.device_set_path.nil?
+        args['-DeviceSetPath'] = Shellwords.shellescape(SimCtl.device_set_path) unless SimCtl.device_set_path.nil?
         args = args.merge(opts).zip.flatten.join(' ')
         command = "open -Fgn #{Xcode::Path.home}/Applications/Simulator.app --args #{args}"
         system command
@@ -32,8 +32,8 @@ module SimCtl
       # @param identifier [String] the app identifier
       # @param args [Array] optional launch arguments
       # @return [void]
-      def launch_app(device, identifier, args=[], opts={})
-        launch_args = args.map {|arg| Shellwords.shellescape arg}
+      def launch_app(device, identifier, args = [], opts = {})
+        launch_args = args.map { |arg| Shellwords.shellescape arg }
         launch_opts = opts[:wait_for_debugger] ? '-w' : ''
         Executor.execute(command_for('launch', launch_opts, device.udid, identifier, launch_args))
       end

data/lib/simctl/command/list.rb

@@ -15,7 +15,8 @@ module SimCtl
       # @return [SimCtl::DeviceType] the device type matching the given filter
       # @raise [DeviceTypeNotFound] if the device type could not be found
       def devicetype(filter)
-        list_devicetypes.where(filter).first or raise DeviceTypeNotFound.new("Could not find a device type matching #{filter.inspect}")
+        device_type = list_devicetypes.where(filter).first
+        device_type || raise(DeviceTypeNotFound, "Could not find a device type matching #{filter.inspect}")
       end
 
       # List all devices
@@ -23,7 +24,8 @@ module SimCtl
       # @return [SimCtl::List] a list of SimCtl::Device objects
       def list_devices
         Executor.execute(command_for('list', '-j', 'devices')) do |json|
-          SimCtl::List.new(json['devices'].map {|os, devices| devices.map {|device| Device.new(device.merge(os: os))}}.flatten)
+          devices = json['devices'].map { |os, devs| devs.map { |device| Device.new(device.merge(os: os)) } }
+          SimCtl::List.new(devices.flatten)
         end
       end
 
@@ -32,7 +34,7 @@ module SimCtl
       # @return [SimCtl::List] a list of SimCtl::DeviceType objects
       def list_devicetypes
         Executor.execute(command_for('list', '-j', 'devicetypes')) do |json|
-          SimCtl::List.new(json['devicetypes'].map {|devicetype| DeviceType.new(devicetype)})
+          SimCtl::List.new(json['devicetypes'].map { |devicetype| DeviceType.new(devicetype) })
         end
       end
 
@@ -41,7 +43,7 @@ module SimCtl
       # @return [SimCtl::List] a list of SimCtl::Runtime objects
       def list_runtimes
         Executor.execute(command_for('list', '-j', 'runtimes')) do |json|
-          SimCtl::List.new(json['runtimes'].map {|runtime| Runtime.new(runtime)})
+          SimCtl::List.new(json['runtimes'].map { |runtime| Runtime.new(runtime) })
         end
       end
 
@@ -51,9 +53,9 @@ module SimCtl
       # @return [SimCtl::Runtime] the runtime matching the given filter
       # @raise [RuntimeNotFound] if the runtime could not be found
       def runtime(filter)
-        list_runtimes.where(filter).first or raise RuntimeNotFound.new("Could not find a runtime matching #{filter.inspect}")
+        runtime = list_runtimes.where(filter).first
+        runtime || raise(RuntimeNotFound, "Could not find a runtime matching #{filter.inspect}")
       end
-
     end
   end
 end

data/lib/simctl/command/reset.rb

@@ -13,14 +13,14 @@ module SimCtl
           list_devices.where(name: name, os: runtime.name).each do |device|
             device.kill
             device.shutdown if device.state != :shutdown
-            device.wait {|d| d.state == :shutdown}
+            device.wait { |d| d.state == :shutdown }
             device.delete
           end
         rescue Exception => exception
           yield exception if block_given?
         end
         device = create_device name, device_type, runtime
-        device.wait {|d| d.state == :shutdown}
+        device.wait { |d| d.state == :shutdown }
         device
       end
     end

data/lib/simctl/command/spawn.rb

@@ -9,8 +9,10 @@ module SimCtl
       # @param path [String] path to executable
       # @param args [Array] arguments for the executable
       # @return [String] standard output the spawned process generated
-      def spawn(device, path, args=[], opts={})
-        Executor.execute(command_for('spawn', device.udid, Shellwords.shellescape(path), *args.map{|a| Shellwords.shellwords(a)})) do |output|
+      def spawn(device, path, args = [], _opts = {})
+        escaped_path = Shellwords.shellescape(path)
+        command = command_for('spawn', device.udid, escaped_path, *args.map { |a| Shellwords.shellwords(a) })
+        Executor.execute(command) do |output|
           output
         end
       end

data/lib/simctl/command/terminate.rb

@@ -9,13 +9,13 @@ module SimCtl
       # @param identifier [String] the app identifier
       # @param args [Array] optional terminate arguments
       # @return [void]
-      def terminate_app(device, identifier, args=[])
+      def terminate_app(device, identifier, args = [])
         unless Xcode::Version.gte? '8.2'
-          raise UnsupportedCommandError.new('Needs at least Xcode 8.2')
+          raise UnsupportedCommandError, 'Needs at least Xcode 8.2'
         end
-        terminate_args = args.map {|arg| Shellwords.shellescape arg}
+        terminate_args = args.map { |arg| Shellwords.shellescape arg }
         Executor.execute(command_for('terminate', terminate_args, device.udid, identifier))
       end
     end
   end
-end
+end