fastlane-plugin-create_simulator_devices 0.0.11 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97c45d507e589509620dd5bfc35a27ae50948ebcba6c886b056b940b3da84a4a
-  data.tar.gz: cc4c4d2c65c49341a01f28c36df7c99713b78c493ad66272fad69570feaf2b7d
+  metadata.gz: fbcf5d008c0e2e248db6b53d80c89c681cd516837439e1da34e95375c135e934
+  data.tar.gz: adc56432be831c59c299204092d96392f3a9483d08ae625a6c5d31695d58a3f0
 SHA512:
-  metadata.gz: bf6e1da7e6f5a89b38f0ae6a180e2a1d9cda9c5bbf7fcdb1bc1bad8e98e947acf7bff35818ec5eb435e676fe486efa5b28ffa6e6c9dd8c1cb59dea8184c1a907
-  data.tar.gz: c0ad977064e5be87a3d0003db5de5ff10592fe40792c1c718209dd61f9df0498a7ac2eda1ed659f5529ebcfa619a04891608c3cab90072f64e43f91a01e71eba
+  metadata.gz: ded9ef76090109dd7f69d96384625e3899bed635d8d59aee8213954cfe33003be2874de36b0b8aae3bf16cf7e10a27bd59adfd51a9cd4d7d3a2600061bf39d8e
+  data.tar.gz: 02cf2720d898e0cb315bb37d13eb1d86a9b10815635def22781465a3a268e1119b836bf39da22793b4c07d317565f67f118a329511035d478865ab3b3accf285

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

@@ -4,6 +4,7 @@ require 'fastlane'
 require 'spaceship'
 require_relative '../helpers/create_simulator_devices/runner'
 require_relative '../helpers/create_simulator_devices/models'
+require_relative '../helpers/create_simulator_devices/models/device_naming_style'
 
 module Fastlane
   module Actions
@@ -22,12 +23,15 @@ module Fastlane
         UI.user_error!('No devices specified') if required_devices.nil? || required_devices.empty?
 
         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:)
+        runtime_helper = CreateSimulatorDevices::RuntimeHelper.new(cache_dir: params[:cache_dir], shell_helper: shell_helper, verbose: verbose)
 
         runner = CreateSimulatorDevices::Runner.new(
           runtime_helper: runtime_helper,
           shell_helper: shell_helper,
-          verbose: verbose
+          verbose: verbose,
+          can_rename_devices: params[:rename_devices],
+          can_delete_duplicate_devices: params[:delete_duplicate_devices],
+          device_naming_style: params[:device_naming_style].to_sym
         )
 
         runner.run(required_devices)
@@ -52,7 +56,7 @@ module Fastlane
         )"
       end
 
-      def self.available_options
+      def self.available_options # rubocop:disable Metrics/MethodLength
         [
           ::FastlaneCore::ConfigItem.new(key: :devices,
                                          env_name: 'SCAN_DEVICES',
@@ -80,7 +84,29 @@ module Fastlane
                                          description: 'Print xcrun simctl commands output',
                                          type: Boolean,
                                          optional: true,
-                                         default_value: false)
+                                         default_value: false),
+          ::FastlaneCore::ConfigItem.new(key: :rename_devices,
+                                         env_name: 'CREATE_SIMULATOR_DEVICES_RENAME_DEVICES',
+                                         description: 'Rename devices if needed',
+                                         type: Boolean,
+                                         optional: true,
+                                         default_value: false),
+          ::FastlaneCore::ConfigItem.new(key: :delete_duplicate_devices,
+                                         env_name: 'CREATE_SIMULATOR_DEVICES_DELETE_DUPLICATE_DEVICES',
+                                         description: 'Delete duplicate devices',
+                                         type: Boolean,
+                                         optional: true,
+                                         default_value: false),
+          ::FastlaneCore::ConfigItem.new(key: :device_naming_style,
+                                         env_name: 'CREATE_SIMULATOR_DEVICES_DEVICE_NAMING_STYLE',
+                                         description: 'Device naming style',
+                                         type: String,
+                                         optional: true,
+                                         default_value: CreateSimulatorDevices::DeviceNamingStyle::SCAN.to_s,
+                                         verify_block: proc do |value|
+                                           allowed_values = CreateSimulatorDevices::DeviceNamingStyle::ALL
+                                           UI.user_error!("Invalid device naming style: #{value}. Allowed values: #{allowed_values.map(&:to_s).join(', ')}") unless allowed_values.include?(value.to_sym)
+                                         end)
         ]
       end
 

data/lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models/apple_build_version.rb

@@ -58,11 +58,19 @@ module Fastlane
         return self == other unless lhs_is_beta && rhs_is_beta && @build_version.length == rhs_build_version.to_s.length
 
         # Take only leading chars up to the first letter included e.g. 22C146 -> 22C
-        minor_version == rhs_build_version.minor_version
+        major == rhs_build_version.major && minor == rhs_build_version.minor && patch == rhs_build_version.patch
       end
 
-      def minor_version
-        AppleBuildVersion.new(@build_version.match(/^[0-9]+[A-Z]+/)[0])
+      def major
+        @build_version.match(/^([0-9]+)([A-Z][0-9]{2,3})([0-9]+)/)[1]
+      end
+
+      def minor
+        @build_version.match(/^([0-9]+)([A-Z][0-9]{2,3})([0-9]+)/)[2]
+      end
+
+      def patch
+        @build_version.match(/^([0-9]+)([A-Z][0-9]{2,3})([0-9]+)/)[3]
       end
 
       def <(other)

data/lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models/device_naming_style.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Fastlane
+  module CreateSimulatorDevices
+    class DeviceNamingStyle
+      SCAN = :scan
+      RUN_TESTS = :run_tests
+      SNAPSHOT = :snapshot
+      CAPTURE_IOS_SCREENSHOTS = :capture_ios_screenshots
+
+      ALL = [SCAN, RUN_TESTS, SNAPSHOT, CAPTURE_IOS_SCREENSHOTS].freeze
+    end
+  end
+end

data/lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models/required_device.rb

@@ -4,14 +4,14 @@ module Fastlane
   module CreateSimulatorDevices
     # Represents a required runtime.
     class RequiredDevice
-      attr_accessor :device_type, :os_name, :required_runtime, :available_runtime, :available_device
+      attr_accessor :device_type, :os_name, :required_runtime, :simctl_runtime, :simctl_device
 
-      def initialize(device_type:, os_name:, required_runtime:, available_runtime:, available_device:)
+      def initialize(device_type:, os_name:, required_runtime:, simctl_runtime:, simctl_device:)
         self.device_type = device_type
         self.os_name = os_name
         self.required_runtime = required_runtime
-        self.available_runtime = available_runtime
-        self.available_device = available_device
+        self.simctl_runtime = simctl_runtime
+        self.simctl_device = simctl_device
       end
 
       def description

data/lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models.rb

@@ -8,6 +8,7 @@ require_relative 'models/xcodebuild/sdk'
 require_relative 'models/required_device'
 require_relative 'models/required_runtime'
 require_relative 'models/apple_build_version'
+require_relative 'models/device_naming_style'
 require 'fastlane'
 
 module Fastlane

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

@@ -3,20 +3,24 @@
 require_relative 'runtime_helper'
 require 'fastlane'
 require_relative 'shared_values'
+require_relative 'models/device_naming_style'
 
 module Fastlane
   # Create simulator devices.
   module CreateSimulatorDevices
     # Does all the work to create simulator devices.
-    class Runner
+    class Runner # rubocop:disable Metrics/ClassLength
       UI = ::Fastlane::UI unless defined?(UI)
 
-      attr_accessor :shell_helper, :verbose, :runtime_helper
+      attr_accessor :shell_helper, :verbose, :runtime_helper, :can_rename_devices, :can_delete_duplicate_devices, :device_naming_style
 
-      def initialize(runtime_helper:, shell_helper:, verbose:)
+      def initialize(runtime_helper:, shell_helper:, verbose:, can_rename_devices:, can_delete_duplicate_devices:, device_naming_style:) # rubocop:disable Metrics/ParameterLists
         self.shell_helper = shell_helper
         self.verbose = verbose
         self.runtime_helper = runtime_helper
+        self.can_rename_devices = can_rename_devices
+        self.can_delete_duplicate_devices = can_delete_duplicate_devices
+        self.device_naming_style = device_naming_style
       end
 
       def run(devices)
@@ -46,14 +50,16 @@ module Fastlane
 
         # Return distinct matched devices strings
         matched_devices = required_devices
-          .reject { |required_device| required_device.available_device.nil? }
+          .reject { |required_device| required_device.simctl_device.nil? }
 
         log_matched_devices(matched_devices: matched_devices)
 
-        available_simulator_devices = matched_devices.map(&:available_device)
-        Actions.lane_context[Actions::SharedValues::AVAILABLE_SIMULATOR_DEVICES] = available_simulator_devices
+        matched_devices_names = matched_devices.map { |matched_device| returning_device_name_for_required_device(matched_device) }
+        UI.message("Available simulator devices: #{matched_devices_names.join(', ')}")
 
-        matched_devices.map(&:description)
+        Actions.lane_context[Actions::SharedValues::AVAILABLE_SIMULATOR_DEVICES] = matched_devices_names
+
+        matched_devices_names
       end
 
       def log_matched_devices(matched_devices:)
@@ -63,46 +69,118 @@ module Fastlane
         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 = shell_helper.device_info_by_udid(matched_device.simctl_device.udid)
             device_info = "\n#{device_info}"
           end
-          UI.message("  #{matched_device.description}: #{matched_device.available_device.description}#{device_info}")
+          UI.message("  #{matched_device.description}: #{matched_device.simctl_device.description}#{device_info}")
         end
-
-        matched_devices_names = matched_devices
-          .map { |matched_device| matched_device.available_device.name }
-          .join(', ')
-        UI.message("Available simulator devices: #{matched_devices_names}")
       end
 
       def delete_unavailable_devices
-        return unless shell_helper.available_devices_for_runtimes.values.flatten.any?(&:available?)
+        return unless shell_helper.simctl_devices_for_runtimes.values.flatten.any?(&:available?)
 
         shell_helper.delete_unavailable_devices
 
-        shell_helper.available_devices_for_runtimes(force: true)
+        shell_helper.simctl_devices_for_runtimes(force: true)
       end
 
-      def available_device_for_required_device(required_device)
-        return nil if required_device.available_runtime.nil?
+      def simctl_device_for_required_device(required_device)
+        return nil if required_device.simctl_runtime.nil?
 
-        available_devices = shell_helper.available_devices_for_runtimes[required_device.available_runtime.identifier.to_sym]
+        simctl_devices = shell_helper.simctl_devices_for_runtimes[required_device.simctl_runtime.identifier.to_sym]
 
-        return [] if available_devices.nil?
+        return nil if simctl_devices.nil?
 
         # Find the device with the same name as the required device.
-        devices_with_same_type = available_devices
-          .select { |available_device| available_device.device_type_identifier == required_device.device_type.identifier }
+        devices_with_same_type = simctl_devices
+          .select { |simctl_device| simctl_device.device_type_identifier == required_device.device_type.identifier }
+
+        preferred_device_name = device_name_for_required_device(required_device)
+
+        # Prefer device with the same name that includes the runtime version.
+        matching_device = devices_with_same_type.detect { |simctl_device| simctl_device.name == preferred_device_name }
+
+        if can_rename_devices
+          # Otherwise, if rename is enabled, use the first device with the same type.
+          matching_device ||= devices_with_same_type.first
+          rename_device_if_needed(matching_device, preferred_device_name)
+        end
+
+        delete_duplicate_devices(devices_with_same_type, matching_device) if can_delete_duplicate_devices
+
+        matching_device
+      end
+
+      def rename_device_if_needed(matching_device, preferred_device_name)
+        return if matching_device.nil? || matching_device.name == preferred_device_name
 
-        devices_with_same_type
-          .detect { |available_device| available_device.name == required_device.device_type.name }
+        UI.message("Renaming device #{matching_device.name} (udid: #{matching_device.udid}) to #{preferred_device_name}")
+        shell_helper.rename_device(udid: matching_device.udid, name: preferred_device_name)
+        matching_device.name = preferred_device_name
+      end
+
+      def delete_duplicate_devices(matching_devices, matching_device)
+        return if matching_device.nil?
+
+        matching_devices
+          .reject { |simctl_device| simctl_device.udid == matching_device.udid }
+          .each do |simctl_device|
+            UI.message("Deleting duplicate device #{simctl_device.name} (udid: #{simctl_device.udid})")
+            shell_helper.delete_device(udid: simctl_device.udid)
+          end
+      end
+
+      # Returns the device name for the required device.
+      #
+      # This name is used in the simctl device name.
+      def device_name_for_required_device(required_device)
+        case device_naming_style
+        when DeviceNamingStyle::SCAN, DeviceNamingStyle::RUN_TESTS
+          # scan modifies the device name by removing the runtime version when searching for a passed device name.
+          # E.g.:
+          #   * given "iPhone 15 (17.0)" match will search for simulator named "iPhone 15" with the SDK version 17.0.
+          #   * given "iPhone 15" match will search for simulator named "iPhone 15" with the default SDK version.
+          # So we need to name the device by the device type name for scan to find the correct device.
+          required_device.device_type.name
+        when DeviceNamingStyle::SNAPSHOT, DeviceNamingStyle::CAPTURE_IOS_SCREENSHOTS
+          # snapshot nither does not modify the device name when searching for a passed device name nor extracts the runtime version from the device name.
+          # E.g.:
+          #   * given "iPhone 15 (17.0)" match will search for device named exactly "iPhone 15 (17.0)".
+          #   * given "iPhone 15" match will search for device named exactly "iPhone 15".
+          # So we need to return the full device name for the required device for snapshot to find the correct device.
+          runtime_build = required_device.simctl_runtime.build_version
+          build_suffix = runtime_build.beta? ? "-#{runtime_build}" : ''
+          "#{required_device.device_type.name} (#{required_device.simctl_runtime.version}#{build_suffix})"
+        end
+      end
+
+      # Returns the device name for the required device.
+      #
+      # This name is used when passing the device name to the scan or snapshot.
+      def returning_device_name_for_required_device(required_device)
+        case device_naming_style
+        when DeviceNamingStyle::SCAN, DeviceNamingStyle::RUN_TESTS
+          # scan respects the runtime version in the devices list, so we need to return the full device name for the required device, otherwise the default SDK version will be used.
+          # E.g.:
+          #   * given "iPhone 15 (17.0)" match will search for simulator named "iPhone 15" with the SDK version 17.0.
+          #   * given "iPhone 15" match will search for simulator named "iPhone 15" with the default SDK version.
+          # So we need to return the device name and the required runtime version for scan to find the correct device.
+          "#{required_device.simctl_device.name} (#{required_device.required_runtime.product_version})"
+        when DeviceNamingStyle::SNAPSHOT, DeviceNamingStyle::CAPTURE_IOS_SCREENSHOTS
+          # snapshot does not modify the device name when searching for a passed device name nor extracts the runtime version from the device name.
+          # E.g.:
+          #   * given "iPhone 15 (17.0)" match will search for device named exactly "iPhone 15 (17.0)".
+          #   * given "iPhone 15" match will search for device named exactly "iPhone 15" .
+          # So we need to return the full device name for the required device for snapshot to find the correct device.
+          required_device.simctl_device.name
+        end
       end
 
       def create_missing_devices(required_devices)
         find_runtime_and_device_for_required_devices(required_devices)
 
         missing_devices = required_devices
-          .select { |required_device| required_device.available_device.nil? }
+          .select { |required_device| required_device.simctl_device.nil? }
 
         if missing_devices.empty?
           UI.message('All required devices are present. Skipping device creation...') if verbose
@@ -112,13 +190,13 @@ module Fastlane
         UI.message('Creating missing devices')
         missing_devices.each do |missing_device|
           shell_helper.create_device(
-            missing_device.device_type.name,
+            device_name_for_required_device(missing_device),
             missing_device.device_type.identifier,
-            missing_device.available_runtime.identifier
+            missing_device.simctl_runtime.identifier
           )
         end
 
-        shell_helper.available_devices_for_runtimes(force: true)
+        shell_helper.simctl_devices_for_runtimes(force: true)
 
         find_runtime_and_device_for_required_devices(missing_devices)
       end
@@ -126,8 +204,8 @@ module Fastlane
       def find_runtime_and_device_for_required_devices(required_devices)
         UI.message('Searching for matching available devices...')
         required_devices.each do |required_device|
-          required_device.available_runtime = runtime_helper.available_runtime_for_required_device(required_device)
-          required_device.available_device = available_device_for_required_device(required_device)
+          required_device.simctl_runtime = runtime_helper.simctl_runtime_for_required_device(required_device)
+          required_device.simctl_device = simctl_device_for_required_device(required_device)
         end
       end
 
@@ -141,17 +219,17 @@ module Fastlane
       }.freeze
 
       def required_device_for_device(device)
-        available_device_types = shell_helper.available_device_types
+        simctl_device_types = shell_helper.simctl_device_types
 
         device_os_version = device[/ \(([\d.]*?)\)$/, 1]
         device_name = device_os_version.nil? ? device : device.delete_suffix(" (#{device_os_version})").strip
 
-        device_type = available_device_types.detect do |available_device_type|
-          device_name == available_device_type.name
+        device_type = simctl_device_types.detect do |simctl_device_type|
+          device_name == simctl_device_type.name
         end
 
         unless device_type
-          UI.important("Device type not found for device #{device}. Available device types: #{available_device_types.map(&:name).join(', ')}.")
+          UI.important("Device type not found for device #{device}. Available device types: #{simctl_device_types.map(&:name).join(', ')}.")
           return nil
         end
 
@@ -170,8 +248,8 @@ module Fastlane
           device_type:,
           os_name:,
           required_runtime: nil,
-          available_runtime: nil,
-          available_device: nil
+          simctl_runtime: nil,
+          simctl_device: nil
         )
 
         required_device.required_runtime = runtime_helper.required_runtime_for_device(required_device, runtime_version)

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

@@ -35,8 +35,8 @@ module Fastlane
           shell_helper.delete_runtime(runtime.identifier)
         end
 
-        shell_helper.available_runtimes(force: true)
-        shell_helper.available_devices_for_runtimes(force: true)
+        shell_helper.simctl_runtimes(force: true)
+        shell_helper.simctl_devices_for_runtimes(force: true)
       end
 
       def install_missing_runtimes(required_devices)
@@ -53,10 +53,10 @@ module Fastlane
           download_and_install_missing_runtime(missing_runtime)
         end
 
-        # Update available_runtimes after installing the runtimes.
+        # Update simctl_runtimes after installing the runtimes.
         shell_helper.installed_runtimes_with_state
-        shell_helper.available_runtimes(force: true)
-        shell_helper.available_devices_for_runtimes(force: true)
+        shell_helper.simctl_runtimes(force: true)
+        shell_helper.simctl_devices_for_runtimes(force: true)
 
         # Check if missing runtimes are available after installing
         missing_runtimes = missing_runtimes(missing_runtimes)
@@ -71,21 +71,21 @@ module Fastlane
       def missing_runtimes(needed_runtimes)
         needed_runtimes.select do |needed_runtime|
           # Check if available runtimes contain the needed runtime.
-          available_runtime_matching_needed_runtime?(needed_runtime).nil?
+          simctl_runtime_matching_needed_runtime?(needed_runtime).nil?
         end
       end
 
-      def available_runtime_matching_needed_runtime?(needed_runtime)
-        matching_runtimes = shell_helper.available_runtimes
-          .select do |available_runtime|
-            next false if needed_runtime.os_name != available_runtime.platform
+      def simctl_runtime_matching_needed_runtime?(needed_runtime)
+        matching_runtimes = shell_helper.simctl_runtimes
+          .select do |simctl_runtime|
+            next false if needed_runtime.os_name != simctl_runtime.platform
 
             # If the product version is not equal, check if the first two segments are equal.
-            is_product_version_equal = if needed_runtime.product_version == available_runtime.version
+            is_product_version_equal = if needed_runtime.product_version == simctl_runtime.version
                                          true
                                        else
                                          lhs_segments = needed_runtime.product_version.segments
-                                         rhs_segments = available_runtime.version.segments
+                                         rhs_segments = simctl_runtime.version.segments
                                          if rhs_segments.size == 3
                                            lhs_segments[0] == rhs_segments[0] && lhs_segments[1] == rhs_segments[1]
                                          else
@@ -95,37 +95,37 @@ module Fastlane
             next false unless is_product_version_equal
 
             # If the product version is not equal, use the available runtime version.
-            needed_runtime.product_version = available_runtime.version
+            needed_runtime.product_version = simctl_runtime.version
 
-            needed_runtime.product_build_version = [needed_runtime.product_build_version, available_runtime.build_version].compact.max
+            needed_runtime.product_build_version = [needed_runtime.product_build_version, simctl_runtime.build_version].compact.max
 
-            needed_runtime.product_build_version.almost_equal?(available_runtime.build_version)
+            needed_runtime.product_build_version.almost_equal?(simctl_runtime.build_version)
           end
 
-        matching_runtimes.max_by { |available_runtime| [available_runtime.version, available_runtime.build_version] }
+        matching_runtimes.max_by { |simctl_runtime| [simctl_runtime.version, simctl_runtime.build_version] }
       end
 
-      def available_runtime_for_required_device(required_device)
-        available_runtime = available_runtime_matching_needed_runtime?(required_device.required_runtime)
+      def simctl_runtime_for_required_device(required_device)
+        simctl_runtime = simctl_runtime_matching_needed_runtime?(required_device.required_runtime)
 
-        if available_runtime.nil?
+        if simctl_runtime.nil?
           UI.important("Runtime #{required_device.required_runtime.description} not found. Skipping simulator creation for #{required_device.description}...")
           return nil
         end
 
         # Check if the runtime supports the device type.
-        if available_runtime.supported_device_types
+        if simctl_runtime.supported_device_types
             .none? { |supported_device_type| supported_device_type.identifier == required_device.device_type.identifier }
-          UI.important("Device type #{required_device.device_type.name} is not supported by runtime #{available_runtime.identifier}. Skipping simulator creation for #{required_device.description}...")
+          UI.important("Device type #{required_device.device_type.name} is not supported by runtime #{simctl_runtime.identifier}. Skipping simulator creation for #{required_device.description}...")
           return nil
         end
 
-        if available_runtime.nil?
+        if simctl_runtime.nil?
           UI.important("Runtime #{required_device.required_runtime.description} not found. Skipping simulator creation for #{required_device.description}...")
           return nil
         end
 
-        available_runtime
+        simctl_runtime
       end
 
       def download_and_install_missing_runtime(missing_runtime)
@@ -161,7 +161,12 @@ module Fastlane
         # shipped with Xcode betas and use the same product version.
         # E.g. Xcode 26.0 Beta 3 has iOS 26.0 (23A5287e) SDK, but
         # xcodebuild downloads iphonesimulator_26.0_23A5287g.dmg as latest.
-        runtime_dmg_search_pattern += missing_runtime.product_build_version.minor_version.to_s if missing_runtime.product_build_version
+        product_build_version = missing_runtime.product_build_version
+        if product_build_version
+          runtime_dmg_search_pattern += product_build_version.major.to_s
+          runtime_dmg_search_pattern += product_build_version.minor.to_s
+          runtime_dmg_search_pattern += product_build_version.patch.to_s
+        end
         runtime_dmg_search_pattern += '*.dmg'
 
         if verbose
@@ -184,7 +189,7 @@ module Fastlane
       end
 
       def required_runtime_for_device(required_device, runtime_version)
-        sdk = max_available_simulator_sdks[required_device.os_name]
+        sdk = max_xcodebuild_simulator_sdks[required_device.os_name]
 
         # If the runtime version is the same as the SDK version, use the SDK build version.
         # This will allow to use different runtimes for the same version but different Xcode beta versions.
@@ -205,10 +210,10 @@ module Fastlane
       end
 
       # Returns a hash where key is platform string and value is sdk version.
-      def max_available_simulator_sdks
-        return @max_available_simulator_sdks unless @max_available_simulator_sdks.nil?
+      def max_xcodebuild_simulator_sdks
+        return @max_xcodebuild_simulator_sdks unless @max_xcodebuild_simulator_sdks.nil?
 
-        @max_available_simulator_sdks = shell_helper.available_sdks
+        @max_xcodebuild_simulator_sdks = shell_helper.xcodebuild_sdks
           # Only simulators
           .filter { |sdk| sdk.platform.include?('simulator') }
           # Calculate max version for each product name
@@ -218,7 +223,7 @@ module Fastlane
             sdk_versions[os_name] = sdk if stored_sdk.nil? || sdk.product_version > stored_sdk.product_version
           end
 
-        @max_available_simulator_sdks
+        @max_xcodebuild_simulator_sdks
       end
     end
   end

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

@@ -53,20 +53,20 @@ module Fastlane
         end
       end
 
-      def available_device_types(force: false)
-        return @available_device_types unless force || @available_device_types.nil?
+      def simctl_device_types(force: false)
+        return @simctl_device_types unless force || @simctl_device_types.nil?
 
         UI.message('Fetching available device types...')
         json = sh(command: 'xcrun simctl list --json --no-escape-slashes devicetypes')
 
-        @available_device_types = JSON
+        @simctl_device_types = JSON
           .parse(json, symbolize_names: true)[:devicetypes]
           .map { |device_type| SimCTL::DeviceType.from_hash(device_type) }
 
-        @available_device_types
+        @simctl_device_types
       end
 
-      def delete_device(udid)
+      def delete_device(udid:)
         UI.message("Deleting device #{udid}...")
         sh(command: "xcrun simctl delete #{udid.shellescape}")
       end
@@ -76,31 +76,31 @@ module Fastlane
         sh(command: 'xcrun simctl delete unavailable')
       end
 
-      def available_devices_for_runtimes(force: false)
-        return @available_devices_for_runtimes unless force || @available_devices_for_runtimes.nil?
+      def simctl_devices_for_runtimes(force: false)
+        return @simctl_devices_for_runtimes unless force || @simctl_devices_for_runtimes.nil?
 
         UI.message('Fetching available devices...')
         json = sh(command: 'xcrun simctl list --json --no-escape-slashes devices')
 
-        @available_devices_for_runtimes = JSON
+        @simctl_devices_for_runtimes = JSON
           .parse(json, symbolize_names: true)[:devices]
           .transform_values { |devices| devices.map { |device| SimCTL::Device.from_hash(device) } }
 
-        @available_devices_for_runtimes
+        @simctl_devices_for_runtimes
       end
 
-      def available_runtimes(force: false)
-        return @available_runtimes unless force || @available_runtimes.nil?
+      def simctl_runtimes(force: false)
+        return @simctl_runtimes unless force || @simctl_runtimes.nil?
 
         UI.message('Fetching available runtimes...')
         json = sh(command: 'xcrun simctl list --json --no-escape-slashes runtimes')
 
-        @available_runtimes = JSON
+        @simctl_runtimes = JSON
           .parse(json, symbolize_names: true)[:runtimes]
           .map { |runtime| SimCTL::Runtime.from_hash(runtime) }
           .select(&:available?)
 
-        @available_runtimes
+        @simctl_runtimes
       end
 
       def installed_runtimes_with_state
@@ -112,17 +112,17 @@ module Fastlane
           .map { |_, runtime| SimCTL::RuntimeWithState.from_hash(runtime) }
       end
 
-      def available_sdks(force: false)
-        return @available_sdks unless force || @available_sdks.nil?
+      def xcodebuild_sdks(force: false)
+        return @xcodebuild_sdks unless force || @xcodebuild_sdks.nil?
 
         UI.message('Fetching available sdks...')
         json = sh(command: 'xcrun xcodebuild -showsdks -json')
 
-        @available_sdks = JSON
+        @xcodebuild_sdks = JSON
           .parse(json, symbolize_names: true)
           .map { |sdk| Xcodebuild::SDK.from_hash(sdk) }
 
-        @available_sdks
+        @xcodebuild_sdks
       end
 
       def create_device(name, device_type_identifier, runtime_identifier)
@@ -130,6 +130,11 @@ module Fastlane
         sh(command: "xcrun simctl create #{name.shellescape} #{device_type_identifier.shellescape} #{runtime_identifier.shellescape}")
       end
 
+      def rename_device(udid:, name:)
+        UI.message("Renaming device with udid #{udid} to #{name}")
+        sh(command: "xcrun simctl rename #{udid.shellescape} #{name.shellescape}")
+      end
+
       def delete_runtime(runtime_identifier)
         UI.message("Deleting runtime #{runtime_identifier}...")
         sh(command: "xcrun simctl runtime delete #{runtime_identifier.shellescape}")
@@ -150,8 +155,12 @@ module Fastlane
           missing_runtime.os_name.shellescape
         ]
 
-        command << '-buildVersion'
-        command << missing_runtime.product_version.to_s.shellescape
+        is_beta = missing_runtime.product_build_version.nil? ? false : missing_runtime.product_build_version.beta?
+
+        unless is_beta
+          command << '-buildVersion'
+          command << missing_runtime.product_version.to_s.shellescape
+        end
 
         sh(command: command.join(' '), print_command: true, print_command_output: true)
       end

data/lib/fastlane/plugin/create_simulator_devices/version.rb

@@ -2,6 +2,6 @@
 
 module Fastlane
   module CreateSimulatorDevices
-    VERSION = '0.0.11'
+    VERSION = '0.0.13'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-create_simulator_devices
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.13
 platform: ruby
 authors:
 - Vitalii Budnik
@@ -22,6 +22,7 @@ files:
 - lib/fastlane/plugin/create_simulator_devices/actions/create_simulator_devices_action.rb
 - lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models.rb
 - lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models/apple_build_version.rb
+- lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models/device_naming_style.rb
 - lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models/required_device.rb
 - lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models/required_runtime.rb
 - lib/fastlane/plugin/create_simulator_devices/helpers/create_simulator_devices/models/simctl/device.rb