fix: device type matching (#20)

Author: nekrich

lib/fastlane/plugin/create_simulator_devices/actions/create_simulator_devices_action.rb

@@ -25,7 +25,7 @@ def self.run(params)
         required_devices = params[:devices]
         UI.user_error!('No devices specified') if required_devices.nil? || required_devices.empty?
 
-        shell_helper = CreateSimulatorDevices::ShellHelper.new(verbose:, action_context: self)
+        shell_helper = CreateSimulatorDevices::ShellHelper.new(print_command: params[:print_command], print_command_output: params[:print_command_output], action_context: self)
         runtime_helper = CreateSimulatorDevices::RuntimeHelper.new(cache_dir: params[:cache_dir], shell_helper:, verbose:)
 
         runner = CreateSimulatorDevices::Runner.new(
@@ -69,16 +69,26 @@ def self.available_options
                                          default_value: 'iPhone 16'),
           ::FastlaneCore::ConfigItem.new(key: :cache_dir,
                                          description: 'The directory to cache the simulator runtimes',
-                                         is_string: true,
+                                         type: String,
                                          optional: true,
                                          default_value: "#{Dir.home}/.cache/create_simulator_devices"),
           ::FastlaneCore::ConfigItem.new(key: :verbose,
                                          env_name: 'VERBOSE',
                                          description: 'Verbose output',
-                                         is_string: false,
+                                         type: Boolean,
                                          optional: true,
                                          default_value: ::FastlaneCore::Globals.verbose?,
-                                         default_value_dynamic: true)
+                                         default_value_dynamic: true),
+          ::FastlaneCore::ConfigItem.new(key: :print_command,
+                                         description: 'Print xcrun simctl commands',
+                                         type: Boolean,
+                                         optional: true,
+                                         default_value: false),
+          ::FastlaneCore::ConfigItem.new(key: :print_command_output,
+                                         description: 'Print xcrun simctl commands output',
+                                         type: Boolean,
+                                         optional: true,
+                                         default_value: false)
         ]
       end
 

lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/runner.rb

@@ -18,6 +18,8 @@ def initialize(runtime_helper:, shell_helper:, verbose:)
       end
 
       def run(devices)
+        UI.message("Simulator devices to create: #{devices.join(', ')}")
+
         shell_helper.stop_core_simulator_services
 
         # Delete unusable runtimes and unavailable devices.
@@ -29,6 +31,11 @@ def run(devices)
           .filter_map { |device| required_device_for_device(device) }
           .uniq { |required_device| [required_device.device_type.name, required_device.required_runtime.product_version] }
 
+        if verbose
+          UI.message('Unique required devices:')
+          UI.message("  #{required_devices.map(&:description).join("\n  ")}")
+        end
+
         # Install missing runtimes if needed.
         runtime_helper.install_missing_runtimes(required_devices)
 
@@ -39,12 +46,7 @@ def run(devices)
         matched_devices = required_devices
           .reject { |required_device| required_device.available_device.nil? }
 
-        if verbose
-          UI.message('Matched devices:')
-          matched_devices.each do |matched_device|
-            UI.message("\t#{matched_device.description}: #{matched_device.available_device.description}")
-          end
-        end
+        log_matched_devices
 
         matched_devices.map!(&:description)
 
@@ -53,6 +55,18 @@ def run(devices)
         matched_devices
       end
 
+      def log_matched_devices
+        UI.message('Matched devices:')
+        matched_devices.each do |matched_device|
+          device_info = ''
+          if verbose
+            device_info = shell_helper.device_info_by_udid(matched_device.available_device.udid)
+            device_info = "\n#{device_info}"
+          end
+          UI.message("  #{matched_device.description}: #{matched_device.available_device.description}#{device_info}")
+        end
+      end
+
       def delete_unavailable_devices
         return unless shell_helper.available_devices_for_runtimes.values.flatten.any?(&:available?)
 
@@ -82,7 +96,10 @@ def create_missing_devices(required_devices)
         missing_devices = required_devices
           .select { |required_device| required_device.available_device.nil? }
 
-        return if missing_devices.empty?
+        if missing_devices.empty?
+          UI.message('All required devices are present. Skipping device creation...') if verbose
+          return
+        end
 
         UI.message('Creating missing devices')
         missing_devices.each do |missing_device|
@@ -118,9 +135,11 @@ def find_runtime_and_device_for_required_devices(required_devices)
       def required_device_for_device(device)
         available_device_types = shell_helper.available_device_types
 
+        device_os_version = device[/ \(([\d.]*?)\)$/, 1]
+        device_name = device.delete_suffix(" (#{device_os_version})").strip unless device_os_version.nil?
+
         device_type = available_device_types.detect do |available_device_type|
-          # Avoid matching "iPhone 16" for the "iPhone 16e" device.
-          "#{device} ".start_with?("#{available_device_type.name} ")
+          device_name == available_device_type.name
         end
 
         unless device_type
@@ -131,8 +150,6 @@ def required_device_for_device(device)
         product_family = device_type.product_family
 
         os_name = PRODUCT_FAMILY_TO_OS_NAME[product_family]
-        device_os_version = device.delete_prefix(device_type.name).strip
-        device_os_version = device_os_version[/\(([\d.]*?)\)/, 1]
 
         runtime_version = nil
         unless device_os_version.nil? || device_os_version.empty?

lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/runtime_helper.rb

@@ -43,7 +43,10 @@ def install_missing_runtimes(required_devices)
 
         missing_runtimes = missing_runtimes(needed_runtimes)
 
-        return if missing_runtimes.empty?
+        if missing_runtimes.empty?
+          UI.message('All required runtimes are present. Skipping runtime installation...') if verbose
+          return
+        end
 
         missing_runtimes.each do |missing_runtime|
           download_and_install_missing_runtime(missing_runtime)

lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/shell_helper.rb

@@ -10,16 +10,17 @@ class ShellHelper
       UI = ::Fastlane::UI unless defined?(UI)
 
       # Proprty verbose
-      attr_accessor :verbose, :action_context
+      attr_accessor :print_command, :print_command_output, :action_context
 
-      def initialize(verbose: false, action_context: nil)
-        self.verbose = verbose
+      def initialize(print_command: false, print_command_output: false, action_context: nil)
+        self.print_command = print_command
+        self.print_command_output = print_command_output
         self.action_context = action_context
       end
 
-      def sh(command:, print_command: verbose, print_command_output: verbose)
+      def sh(command:, print_command: self.print_command, print_command_output: self.print_command_output)
         if action_context
-          action_context.sh(command, print_command:, print_command_output:)
+          action_context.sh(command, print_command: print_command, print_command_output: print_command_output)
         else
           # Fallback for testing or direct usage
           require 'open3'
@@ -163,6 +164,14 @@ def import_runtime(runtime_dmg_filename, runtime_name)
           UI.important("Failed to import runtime #{runtime_name} with '#{import_platform_command}' :\n#{e}")
         end
       end
+
+      def device_info_by_udid(udid)
+        sh(
+          command: "xcrun simctl list devices --json | jq '.devices | to_entries[].value[] | select(.udid==\"#{udid.shellescape}\")'",
+          print_command: false,
+          print_command_output: false
+        )
+      end
     end
   end
 end

spec/create_simulator_devices/shell_helper_spec.rb

@@ -6,7 +6,7 @@
 RSpec.describe Fastlane::CreateSimulatorDevices::ShellHelper do
   AppleBuildVersion = Fastlane::CreateSimulatorDevices::AppleBuildVersion
   RequiredRuntime = Fastlane::CreateSimulatorDevices::RequiredRuntime
-  let(:sut) { described_class.new(verbose: false) }
+  let(:sut) { described_class.new(print_command: false, print_command_output: false) }
   before do
     # Mock the sh method directly on the ShellHelper instance
     allow(sut).to receive(:sh)