fastlane 2.140.0 → 2.141.0

data/gym/lib/gym/module.rb

@@ -24,6 +24,14 @@ module Gym
       # Import all the fixes
       require 'gym/xcodebuild_fixes/generic_archive_fix'
     end
+
+    def building_mac_catalyst_for_ios?
+      Gym.project.supports_mac_catalyst? && Gym.config[:catalyst_platform] == "ios"
+    end
+
+    def building_mac_catalyst_for_mac?
+      Gym.project.supports_mac_catalyst? && Gym.config[:catalyst_platform] == "macos"
+    end
   end
 
   Helper = FastlaneCore::Helper # you gotta love Ruby: Helper.* should use the Helper class contained in FastlaneCore

data/gym/lib/gym/options.rb

@@ -85,6 +85,11 @@ module Gym
                                      description: "Should we skip packaging the ipa?",
                                      type: Boolean,
                                      default_value: false),
+        FastlaneCore::ConfigItem.new(key: :skip_package_pkg,
+                                     env_name: "GYM_SKIP_PACKAGE_PKG",
+                                     description: "Should we skip packaging the pkg?",
+                                     type: Boolean,
+                                     default_value: false),
         FastlaneCore::ConfigItem.new(key: :include_symbols,
                                      short_option: "-m",
                                      env_name: "GYM_INCLUDE_SYMBOLS",
@@ -139,6 +144,20 @@ module Gym
                                      description: "Build without codesigning",
                                      type: Boolean,
                                      optional: true),
+        FastlaneCore::ConfigItem.new(key: :catalyst_platform,
+                                     env_name: "GYM_CATALYST_PLATFORM",
+                                     description: "Platform to build when using a Catalyst enabled app. Valid values are: ios, macos",
+                                     type: String,
+                                     optional: true,
+                                     verify_block: proc do |value|
+                                       av = %w(ios macos)
+                                       UI.user_error!("Unsupported export_method '#{value}', must be: #{av}") unless av.include?(value)
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :installer_cert_name,
+                                     env_name: "GYM_INSTALLER_CERT_NAME",
+                                     description: "Full name of 3rd Party Mac Developer Installer or Deveoper ID Installer certificate. Example: `3rd Party Mac Developer Installer: Your Company (ABC1234XWYZ)`",
+                                     type: String,
+                                     optional: true),
         # Very optional
         FastlaneCore::ConfigItem.new(key: :build_path,
                                      env_name: "GYM_BUILD_PATH",
@@ -255,7 +274,12 @@ module Gym
                                      description: "Do not try to build a profile mapping from the xcodeproj. Match or a manually provided mapping should be used",
                                      optional: true,
                                      type: Boolean,
-                                     default_value: false)
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :cloned_source_packages_path,
+                                     env_name: "GYM_CLONED_SOURCE_PACKAGES_PATH",
+                                     description: "Sets a custom path for Swift Package Manager dependencies",
+                                     type: String,
+                                     optional: true)
       ]
     end
   end

data/gym/lib/gym/runner.rb

@@ -23,7 +23,12 @@ module Gym
 
       FileUtils.mkdir_p(File.expand_path(Gym.config[:output_directory]))
 
-      if Gym.project.ios? || Gym.project.tvos?
+      # Determine platform to archive
+      is_mac = Gym.project.mac? || Gym.building_mac_catalyst_for_mac?
+      is_ios = !is_mac && (Gym.project.ios? || Gym.project.tvos?)
+
+      # Archive
+      if is_ios
         fix_generic_archive # See https://github.com/fastlane/fastlane/pull/4325
         return BuildCommandGenerator.archive_path if Gym.config[:skip_package_ipa]
 
@@ -34,11 +39,15 @@ module Gym
         move_app_thinning
         move_app_thinning_size_report
         move_apps_folder
-      elsif Gym.project.mac?
+      elsif is_mac
         path = File.expand_path(Gym.config[:output_directory])
         compress_and_move_dsym
-        if Gym.project.mac_app?
-          copy_mac_app
+        if Gym.project.mac_app? || Gym.building_mac_catalyst_for_mac?
+          path = copy_mac_app
+          return path if Gym.config[:skip_package_pkg]
+
+          package_app
+          path = move_pkg
           return path
         end
         copy_files_from_path(File.join(BuildCommandGenerator.archive_path, "Products/usr/local/bin/*")) if Gym.project.command_line_tool?
@@ -226,6 +235,17 @@ module Gym
       ipa_path
     end
 
+    # Moves over the binary and dsym file to the output directory
+    # @return (String) The path to the resulting pkg file
+    def move_pkg
+      FileUtils.mv(PackageCommandGenerator.pkg_path, File.expand_path(Gym.config[:output_directory]), force: true)
+      pkg_path = File.expand_path(File.join(Gym.config[:output_directory], File.basename(PackageCommandGenerator.pkg_path)))
+
+      UI.success("Successfully exported and signed the pkg file:")
+      UI.message(pkg_path)
+      pkg_path
+    end
+
     # copys framework from temp folder:
 
     def copy_files_from_path(path)
@@ -248,6 +268,7 @@ module Gym
     def copy_mac_app
       exe_name = Gym.project.build_settings(key: "EXECUTABLE_NAME")
       app_path = File.join(BuildCommandGenerator.archive_path, "Products/Applications/#{exe_name}.app")
+
       UI.crash!("Couldn't find application in '#{BuildCommandGenerator.archive_path}'") unless File.exist?(app_path)
       FileUtils.cp_r(app_path, File.expand_path(Gym.config[:output_directory]), remove_destination: true)
       app_path = File.join(Gym.config[:output_directory], File.basename(app_path))

data/match/lib/match/encryption/openssl.rb

@@ -71,7 +71,7 @@ module Match
       private
 
       def iterate(source_path)
-        Dir[File.join(source_path, "**", "*.{cer,p12,mobileprovision}")].each do |path|
+        Dir[File.join(source_path, "**", "*.{cer,p12,mobileprovision,provisionprofile}")].each do |path|
           next if File.directory?(path)
           yield(path)
         end

data/match/lib/match/generator.rb

@@ -3,14 +3,20 @@ require_relative 'module'
 module Match
   # Generate missing resources
   class Generator
-    def self.generate_certificate(params, cert_type, working_directory)
+    def self.generate_certificate(params, cert_type, working_directory, specific_cert_type: nil)
       require 'cert/runner'
       require 'cert/options'
 
       output_path = File.join(working_directory, "certs", cert_type.to_s)
 
+      # Mapping match option to cert option for "Developer ID Application"
+      if cert_type.to_sym == :developer_id_application
+        specific_cert_type = cert_type.to_s
+      end
+
       arguments = FastlaneCore::Configuration.create(Cert::Options.available_options, {
         development: params[:type] == "development",
+        type: specific_cert_type,
         generate_apple_certs: params[:generate_apple_certs],
         output_path: output_path,
         force: true, # we don't need a certificate without its private key, we only care about a new certificate
@@ -70,8 +76,15 @@ module Match
       }
 
       values[:platform] = params[:platform]
-      values[:adhoc] = true if prov_type == :adhoc
-      values[:development] = true if prov_type == :development
+
+      # These options are all conflicting so can only set one
+      if params[:type] == "developer_id"
+        values[:developer_id] = true
+      elsif prov_type == :adhoc
+        values[:adhoc] = true
+      elsif prov_type == :development
+        values[:development] = true
+      end
 
       arguments = FastlaneCore::Configuration.create(Sigh::Options.available_options, values)
 
@@ -82,6 +95,7 @@ module Match
 
     # @return the name of the provisioning profile type
     def self.profile_type_name(type)
+      return "Direct" if type == :developer_id
       return "Development" if type == :development
       return "AdHoc" if type == :adhoc
       return "AppStore" if type == :appstore

data/match/lib/match/module.rb

@@ -9,7 +9,7 @@ module Match
   DESCRIPTION = "Easily sync your certificates and profiles across your team"
 
   def self.environments
-    return %w(appstore adhoc development enterprise)
+    return %w(appstore adhoc development enterprise developer_id)
   end
 
   def self.storage_modes
@@ -21,6 +21,9 @@ module Match
   end
 
   def self.cert_type_sym(type)
+    return :mac_installer_distribution if type == "mac_installer_distribution"
+    return :developer_id_installer if type == "developer_id_installer"
+    return :developer_id_application if type == "developer_id"
     return :enterprise if type == "enterprise"
     return :development if type == "development"
     return :distribution if ["adhoc", "appstore", "distribution"].include?(type)

data/match/lib/match/nuke.rb

@@ -93,10 +93,11 @@ module Match
     def prepare_list
       UI.message("Fetching certificates and profiles...")
       cert_type = Match.cert_type_sym(type)
+      cert_types = [cert_type]
 
       prov_types = []
       prov_types = [:development] if cert_type == :development
-      prov_types = [:appstore, :adhoc] if cert_type == :distribution
+      prov_types = [:appstore, :adhoc, :developer_id] if cert_type == :distribution
       prov_types = [:enterprise] if cert_type == :enterprise
 
       Spaceship.login(params[:username])
@@ -112,17 +113,39 @@ module Match
         UI.user_error!("Enterprise account nuke cancelled") unless UI.confirm("Do you really want to nuke your Enterprise account?")
       end
 
-      self.certs = certificate_type(cert_type).flat_map(&:all)
+      # Get all iOS and macOS profile
       self.profiles = []
       prov_types.each do |prov_type|
-        self.profiles += profile_type(prov_type).all
+        self.profiles += profile_type(prov_type).all(mac: false)
+        self.profiles += profile_type(prov_type).all(mac: true)
       end
 
-      certs = Dir[File.join(self.storage.working_directory, "**", cert_type.to_s, "*.cer")]
-      keys = Dir[File.join(self.storage.working_directory, "**", cert_type.to_s, "*.p12")]
+      # Gets the main and additional cert types
+      cert_types += (params[:additional_cert_types] || []).map do |ct|
+        Match.cert_type_sym(ct)
+      end
+
+      # Gets all the certs form the cert types
+      self.certs = []
+      self.certs += cert_types.map do |ct|
+        certificate_type(ct).flat_map do |cert|
+          cert.all(mac: false) + cert.all(mac: true)
+        end
+      end.flatten
+
+      # Finds all the .cer and .p12 files in the file storage
+      certs = []
+      keys = []
+      cert_types.each do |ct|
+        certs += Dir[File.join(self.storage.working_directory, "**", ct.to_s, "*.cer")]
+        keys += Dir[File.join(self.storage.working_directory, "**", ct.to_s, "*.p12")]
+      end
+
+      # Finds all the iOS and macOS profofiles in the file storage
       profiles = []
       prov_types.each do |prov_type|
         profiles += Dir[File.join(self.storage.working_directory, "**", prov_type.to_s, "*.mobileprovision")]
+        profiles += Dir[File.join(self.storage.working_directory, "**", prov_type.to_s, "*.provisionprofile")]
       end
 
       self.files = certs + keys + profiles
@@ -240,21 +263,36 @@ module Match
 
     # The kind of certificate we're interested in
     def certificate_type(type)
-      {
-        distribution: [Spaceship.certificate.production, Spaceship.certificate.apple_distribution],
-        development:  [Spaceship.certificate.development, Spaceship.certificate.apple_development],
-        enterprise:   [Spaceship.certificate.in_house]
-      }[type] ||= raise "Unknown type '#{type}'"
+      case type.to_sym
+      when :mac_installer_distribution
+        return [Spaceship.certificate.mac_installer_distribution]
+      when :distribution
+        return [Spaceship.certificate.production, Spaceship.certificate.apple_distribution]
+      when :development
+        return [Spaceship.certificate.development, Spaceship.certificate.apple_development]
+      when :enterprise
+        return [Spaceship.certificate.in_house]
+      else
+        raise "Unknown type '#{type}'"
+      end
     end
 
     # The kind of provisioning profile we're interested in
     def profile_type(prov_type)
-      {
-        appstore:    Spaceship.provisioning_profile.app_store,
-        development: Spaceship.provisioning_profile.development,
-        enterprise:  Spaceship.provisioning_profile.in_house,
-        adhoc:       Spaceship.provisioning_profile.ad_hoc
-      }[prov_type] ||= raise "Unknown provisioning type '#{prov_type}'"
+      case prov_type.to_sym
+      when :appstore
+        return Spaceship.provisioning_profile.app_store
+      when :development
+        return Spaceship.provisioning_profile.development
+      when :enterprise
+        return Spaceship.provisioning_profile.in_house
+      when :adhoc
+        return Spaceship.provisioning_profile.ad_hoc
+      when :developer_id
+        return Spaceship.provisioning_profile.direct
+      else
+        raise "Unknown provisioning type '#{prov_type}'"
+      end
     end
   end
 end

data/match/lib/match/options.rb

@@ -19,7 +19,6 @@ module Match
         FastlaneCore::ConfigItem.new(key: :type,
                                      env_name: "MATCH_TYPE",
                                      description: "Define the profile type, can be #{Match.environments.join(', ')}",
-                                     is_string: true,
                                      short_option: "-y",
                                      default_value: 'development',
                                      verify_block: proc do |value|
@@ -27,10 +26,19 @@ module Match
                                          UI.user_error!("Unsupported environment #{value}, must be in #{Match.environments.join(', ')}")
                                        end
                                      end),
+        FastlaneCore::ConfigItem.new(key: :additional_cert_types,
+                                     env_name: "MATCH_ADDITIONAL_CERT_TYPES",
+                                     description: "Create additional cert types needed for macOS installers (valid values: mac_installer_distribution, developer_id_installer)",
+                                     optional: true,
+                                     type: Array,
+                                     verify_block: proc do |values|
+                                       types = %w(mac_installer_distribution developer_id_installer)
+                                       UI.user_error!("Unsupported types, must be: #{types}") unless (values - types).empty?
+                                     end),
         FastlaneCore::ConfigItem.new(key: :readonly,
                                      env_name: "MATCH_READONLY",
                                      description: "Only fetch existing certificates and profiles, don't generate new ones",
-                                     is_string: false,
+                                     type: Boolean,
                                      default_value: false),
         FastlaneCore::ConfigItem.new(key: :generate_apple_certs,
                                      env_name: "MATCH_GENERATE_APPLE_CERTS",
@@ -41,7 +49,7 @@ module Match
         FastlaneCore::ConfigItem.new(key: :skip_provisioning_profiles,
                                      env_name: "MATCH_SKIP_PROVISIONING_PROFILES",
                                      description: "Skip syncing provisioning profiles",
-                                     is_string: false,
+                                     type: Boolean,
                                      default_value: false),
 
         # app
@@ -49,7 +57,6 @@ module Match
                                      short_option: "-a",
                                      env_name: "MATCH_APP_IDENTIFIER",
                                      description: "The bundle identifier(s) of your app (comma-separated)",
-                                     is_string: false,
                                      type: Array, # we actually allow String and Array here
                                      skip_type_validation: true,
                                      code_gen_sensitive: true,
@@ -82,7 +89,6 @@ module Match
         FastlaneCore::ConfigItem.new(key: :storage_mode,
                                      env_name: "MATCH_STORAGE_MODE",
                                      description: "Define where you want to store your certificates",
-                                     is_string: true,
                                      short_option: "-q",
                                      default_value: 'git',
                                      verify_block: proc do |value|
@@ -114,12 +120,12 @@ module Match
         FastlaneCore::ConfigItem.new(key: :shallow_clone,
                                      env_name: "MATCH_SHALLOW_CLONE",
                                      description: "Make a shallow clone of the repository (truncate the history to 1 revision)",
-                                     is_string: false,
+                                     type: Boolean,
                                      default_value: false),
         FastlaneCore::ConfigItem.new(key: :clone_branch_directly,
                                      env_name: "MATCH_CLONE_BRANCH_DIRECTLY",
                                      description: "Clone just the branch specified, instead of the whole repo. This requires that the branch already exists. Otherwise the command will fail",
-                                     is_string: false,
+                                     type: Boolean,
                                      default_value: false),
         FastlaneCore::ConfigItem.new(key: :git_basic_authorization,
                                      env_name: "MATCH_GIT_BASIC_AUTHORIZATION",
@@ -170,32 +176,31 @@ module Match
         FastlaneCore::ConfigItem.new(key: :force,
                                      env_name: "MATCH_FORCE",
                                      description: "Renew the provisioning profiles every time you run match",
-                                     is_string: false,
+                                     type: Boolean,
                                      default_value: false),
         FastlaneCore::ConfigItem.new(key: :force_for_new_devices,
                                      env_name: "MATCH_FORCE_FOR_NEW_DEVICES",
                                      description: "Renew the provisioning profiles if the device count on the developer portal has changed. Ignored for profile type 'appstore'",
-                                     is_string: false,
+                                     type: Boolean,
                                      default_value: false),
         FastlaneCore::ConfigItem.new(key: :skip_confirmation,
                                      env_name: "MATCH_SKIP_CONFIRMATION",
                                      description: "Disables confirmation prompts during nuke, answering them with yes",
-                                     is_string: false,
+                                     type: Boolean,
                                      default_value: false),
         FastlaneCore::ConfigItem.new(key: :skip_docs,
                                      env_name: "MATCH_SKIP_DOCS",
                                      description: "Skip generation of a README.md for the created git repository",
-                                     is_string: false,
+                                     type: Boolean,
                                      default_value: false),
         FastlaneCore::ConfigItem.new(key: :platform,
                                      short_option: '-o',
                                      env_name: "MATCH_PLATFORM",
-                                     description: "Set the provisioning profile's platform to work with (i.e. ios, tvos)",
-                                     is_string: false,
+                                     description: "Set the provisioning profile's platform to work with (i.e. ios, tvos, macos)",
                                      default_value: "ios",
                                      verify_block: proc do |value|
                                        value = value.to_s
-                                       pt = %w(tvos ios)
+                                       pt = %w(tvos ios macos)
                                        UI.user_error!("Unsupported platform, must be: #{pt}") unless pt.include?(value)
                                      end),
         FastlaneCore::ConfigItem.new(key: :template_name,
@@ -212,7 +217,7 @@ module Match
         FastlaneCore::ConfigItem.new(key: :verbose,
                                      env_name: "MATCH_VERBOSE",
                                      description: "Print out extra information and all commands",
-                                     is_string: false,
+                                     type: Boolean,
                                      default_value: false,
                                      verify_block: proc do |value|
                                        FastlaneCore::Globals.verbose = true if value

data/match/lib/match/runner.rb

@@ -18,6 +18,7 @@ module Match
 
     attr_accessor :storage
 
+    # rubocop:disable Metrics/PerceivedComplexity
     def run(params)
       self.files_to_commit = []
 
@@ -79,13 +80,21 @@ module Match
       # Verify the App ID (as we don't want 'match' to fail at a later point)
       if spaceship
         app_identifiers.each do |app_identifier|
-          spaceship.bundle_identifier_exists(username: params[:username], app_identifier: app_identifier)
+          spaceship.bundle_identifier_exists(username: params[:username], app_identifier: app_identifier, platform: params[:platform])
         end
       end
 
       # Certificate
       cert_id = fetch_certificate(params: params, working_directory: storage.working_directory)
-      spaceship.certificate_exists(username: params[:username], certificate_id: cert_id) if spaceship
+
+      # Mac Installer Distribution Certificate
+      additional_cert_types = params[:additional_cert_types] || []
+      cert_ids = additional_cert_types.map do |additional_cert_type|
+        fetch_certificate(params: params, working_directory: storage.working_directory, specific_cert_type: additional_cert_type)
+      end
+
+      cert_ids << cert_id
+      spaceship.certificates_exists(username: params[:username], certificate_ids: cert_ids, platform: params[:platform]) if spaceship
 
       # Provisioning Profiles
       unless params[:skip_provisioning_profiles]
@@ -119,6 +128,7 @@ module Match
     ensure
       storage.clear_changes if storage
     end
+    # rubocop:enable Metrics/PerceivedComplexity
 
     # Used when creating a new certificate or profile
     def prefixed_working_directory
@@ -133,8 +143,8 @@ module Match
       end
     end
 
-    def fetch_certificate(params: nil, working_directory: nil)
-      cert_type = Match.cert_type_sym(params[:type])
+    def fetch_certificate(params: nil, working_directory: nil, specific_cert_type: nil)
+      cert_type = Match.cert_type_sym(specific_cert_type || params[:type])
 
       certs = Dir[File.join(prefixed_working_directory, "certs", cert_type.to_s, "*.cer")]
       keys = Dir[File.join(prefixed_working_directory, "certs", cert_type.to_s, "*.p12")]
@@ -142,7 +152,7 @@ module Match
       if certs.count == 0 || keys.count == 0
         UI.important("Couldn't find a valid code signing identity for #{cert_type}... creating one for you now")
         UI.crash!("No code signing identity found and can not create a new one because you enabled `readonly`") if params[:readonly]
-        cert_path = Generator.generate_certificate(params, cert_type, prefixed_working_directory)
+        cert_path = Generator.generate_certificate(params, cert_type, prefixed_working_directory, specific_cert_type: specific_cert_type)
         private_key_path = cert_path.gsub(".cer", ".p12")
 
         self.files_to_commit << cert_path
@@ -196,13 +206,15 @@ module Match
       prov_type = Match.profile_type_sym(params[:type])
 
       names = [Match::Generator.profile_type_name(prov_type), app_identifier]
-      if params[:platform].to_s != :ios.to_s
+      if params[:platform].to_s == :tvos.to_s
         names.push(params[:platform])
       end
 
       profile_name = names.join("_").gsub("*", '\*') # this is important, as it shouldn't be a wildcard
       base_dir = File.join(prefixed_working_directory, "profiles", prov_type.to_s)
-      profiles = Dir[File.join(base_dir, "#{profile_name}.mobileprovision")]
+
+      extension = params[:platform].to_s == :macos.to_s ? ".provisionprofile" : ".mobileprovision"
+      profiles = Dir[File.join(base_dir, "#{profile_name}#{extension}")]
       if Helper.mac?
         keychain_path = FastlaneCore::Helper.keychain_path(params[:keychain_name]) unless params[:keychain_name].nil?
       end
@@ -254,7 +266,7 @@ module Match
         FileUtils.cp(profile, params[:output_path])
       end
 
-      if spaceship && !spaceship.profile_exists(username: params[:username], uuid: uuid)
+      if spaceship && !spaceship.profile_exists(username: params[:username], uuid: uuid, platform: params[:platform])
         # This profile is invalid, let's remove the local file and generate a new one
         File.delete(profile)
         # This method will be called again, no need to modify `files_to_commit`