fastlane 2.176.0 → 2.180.1

data/fastlane/lib/fastlane/actions/latest_testflight_build_number.rb

@@ -70,6 +70,7 @@ module Fastlane
                                        short_option: "-u",
                                        env_name: "ITUNESCONNECT_USER",
                                        description: "Your Apple ID Username",
+                                       optional: true,
                                        default_value: user,
                                        default_value_dynamic: true),
           FastlaneCore::ConfigItem.new(key: :version,

data/fastlane/lib/fastlane/actions/match_nuke.rb

@@ -0,0 +1,59 @@
+module Fastlane
+  module Actions
+    class MatchNukeAction < Action
+      def self.run(params)
+        require 'match'
+
+        params.load_configuration_file("Matchfile")
+        params[:api_key] ||= Actions.lane_context[SharedValues::APP_STORE_CONNECT_API_KEY]
+
+        cert_type = Match.cert_type_sym(params[:type])
+        UI.important("Going to revoke your '#{cert_type}' certificate type and provisioning profiles")
+
+        Match::Nuke.new.run(params, type: cert_type)
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Easily nuke your certificate and provisioning profiles (via _match_)"
+      end
+
+      def self.details
+        [
+          "Use the match_nuke action to revoke your certificates and provisioning profiles.",
+          "Don't worry, apps that are already available in the App Store / TestFlight will still work.",
+          "Builds distributed via Ad Hoc or Enterprise will be disabled after nuking your account, so you'll have to re-upload a new build.",
+          "After clearing your account you'll start from a clean state, and you can run match to generate your certificates and profiles again.",
+          "More information: https://docs.fastlane.tools/actions/match/"
+        ].join("\n")
+      end
+
+      def self.available_options
+        require 'match'
+        Match::Options.available_options
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'match_nuke(type: "development")', # See all other options https://github.com/fastlane/fastlane/blob/master/match/lib/match/module.rb#L23
+          'match_nuke(type: "development", api_key: app_store_connect_api_key)'
+        ]
+      end
+
+      def self.authors
+        ["crazymanish"]
+      end
+
+      def self.category
+        :code_signing
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/notarize.rb

@@ -1,12 +1,14 @@
 module Fastlane
   module Actions
     class NotarizeAction < Action
+      # rubocop:disable Metrics/PerceivedComplexity
       def self.run(params)
         package_path = params[:package]
         bundle_id = params[:bundle_id]
         try_early_stapling = params[:try_early_stapling]
         print_log = params[:print_log]
         verbose = params[:verbose]
+        api_key_path = params[:api_key_path]
 
         # Compress and read bundle identifier only for .app bundle.
         compressed_package_path = nil
@@ -28,68 +30,73 @@ module Fastlane
 
         UI.user_error!('Could not read bundle identifier, provide as a parameter') unless bundle_id
 
-        apple_id_account = CredentialsManager::AccountManager.new(user: params[:username])
-
-        # Add password as a temporary environment variable for altool.
-        # Use app specific password if specified.
-        ENV['FL_NOTARIZE_PASSWORD'] = ENV['FASTLANE_APPLE_APPLICATION_SPECIFIC_PASSWORD'] || apple_id_account.password
-
         UI.message('Uploading package to notarization service, might take a while')
 
-        notarization_upload_command = "xcrun altool --notarize-app -t osx -f \"#{compressed_package_path || package_path}\" --primary-bundle-id #{bundle_id} -u #{apple_id_account.user} -p @env:FL_NOTARIZE_PASSWORD --output-format xml"
-        notarization_upload_command << " --asc-provider \"#{params[:asc_provider]}\"" if params[:asc_provider]
+        notarization_upload_command = "xcrun altool --notarize-app -t osx -f \"#{compressed_package_path || package_path}\" --primary-bundle-id #{bundle_id} --output-format xml"
 
-        notarization_upload_response = Actions.sh(
-          notarization_upload_command,
-          log: verbose
-        )
+        notarization_info = {}
+        with_notarize_authenticator(params, api_key_path) do |notarize_authenticator|
+          notarization_upload_command << " --asc-provider \"#{params[:asc_provider]}\"" if params[:asc_provider] && api_key_path.nil?
 
-        FileUtils.rm_rf(compressed_package_path) if compressed_package_path
+          notarization_upload_response = Actions.sh(
+            notarize_authenticator.call(notarization_upload_command),
+            log: verbose
+          )
 
-        notarization_upload_plist = Plist.parse_xml(notarization_upload_response)
-        notarization_request_id = notarization_upload_plist['notarization-upload']['RequestUUID']
+          FileUtils.rm_rf(compressed_package_path) if compressed_package_path
 
-        UI.success("Successfully uploaded package to notarization service with request identifier #{notarization_request_id}")
+          notarization_upload_plist = Plist.parse_xml(notarization_upload_response)
 
-        notarization_info = {}
-        while notarization_info.empty? || (notarization_info['Status'] == 'in progress')
-          if notarization_info.empty?
-            UI.message('Waiting to query request status')
-          elsif try_early_stapling
-            UI.message('Request in progress, trying early staple')
-
-            begin
-              self.staple(package_path, verbose)
-              UI.message('Successfully notarized and early stapled package.')
-
-              return
-            rescue
-              UI.message('Early staple failed, waiting to query again')
-            end
+          if notarization_upload_plist.key?('product-errors') && notarization_upload_plist['product-errors'].any?
+            UI.important("🚫 Could not upload package to notarization service! Here are the reasons:")
+            notarization_upload_plist['product-errors'].each { |product_error| UI.error("#{product_error['message']} (#{product_error['code']})") }
+            UI.user_error!("Package upload to notarization service cancelled. Please check the error messages above.")
           end
 
-          sleep(30)
-
-          UI.message('Querying request status')
-
-          # As of July 2020, the request UUID might not be available for polling yet which returns an error code
-          # This is now handled with the error_callback (which prevents an error from being raised)
-          # Catching this error allows for polling to continue until the notarization is complete
-          error = false
-          notarization_info_response = Actions.sh(
-            "xcrun altool --notarization-info #{notarization_request_id} -u #{apple_id_account.user} -p @env:FL_NOTARIZE_PASSWORD --output-format xml",
-            log: verbose,
-            error_callback: lambda { |msg|
-              error = true
-              UI.error("Error polling for notarization info: #{msg}")
-            }
-          )
+          notarization_request_id = notarization_upload_plist['notarization-upload']['RequestUUID']
+
+          UI.success("Successfully uploaded package to notarization service with request identifier #{notarization_request_id}")
+
+          while notarization_info.empty? || (notarization_info['Status'] == 'in progress')
+            if notarization_info.empty?
+              UI.message('Waiting to query request status')
+            elsif try_early_stapling
+              UI.message('Request in progress, trying early staple')
+
+              begin
+                self.staple(package_path, verbose)
+                UI.message('Successfully notarized and early stapled package.')
+
+                return
+              rescue
+                UI.message('Early staple failed, waiting to query again')
+              end
+            end
 
-          unless error
-            notarization_info_plist = Plist.parse_xml(notarization_info_response)
-            notarization_info = notarization_info_plist['notarization-info']
+            sleep(30)
+
+            UI.message('Querying request status')
+
+            # As of July 2020, the request UUID might not be available for polling yet which returns an error code
+            # This is now handled with the error_callback (which prevents an error from being raised)
+            # Catching this error allows for polling to continue until the notarization is complete
+            error = false
+            notarization_info_response = Actions.sh(
+              notarize_authenticator.call("xcrun altool --notarization-info #{notarization_request_id} --output-format xml"),
+              log: verbose,
+              error_callback: lambda { |msg|
+                error = true
+                UI.error("Error polling for notarization info: #{msg}")
+              }
+            )
+
+            unless error
+              notarization_info_plist = Plist.parse_xml(notarization_info_response)
+              notarization_info = notarization_info_plist['notarization-info']
+            end
           end
         end
+        # rubocop:enable Metrics/PerceivedComplexity
 
         log_url = notarization_info['LogFileURL']
         ENV['FL_NOTARIZE_LOG_FILE_URL'] = log_url
@@ -123,6 +130,35 @@ module Fastlane
         )
       end
 
+      def self.with_notarize_authenticator(params, api_key_path)
+        if api_key_path
+          # From xcrun altool for --apiKey:
+          # This option will search the following directories in sequence for a private key file with the name of 'AuthKey_<api_key>.p8':  './private_keys', '~/private_keys', '~/.private_keys', and '~/.appstoreconnect/private_keys'.
+          api_key = Spaceship::ConnectAPI::Token.from_json_file(api_key_path)
+          api_key_folder_path = File.expand_path('~/.appstoreconnect/private_keys')
+          api_key_file_path = File.join(api_key_folder_path, "AuthKey_#{api_key.key_id}.p8")
+          directory_exists = File.directory?(api_key_folder_path)
+          file_exists = File.exist?(api_key_file_path)
+          begin
+            FileUtils.mkdir_p(api_key_folder_path) unless directory_exists
+            api_key.write_key_to_file(api_key_file_path) unless file_exists
+
+            yield(proc { |command| "#{command} --apiKey #{api_key.key_id} --apiIssuer #{api_key.issuer_id}" })
+          ensure
+            FileUtils.rm(api_key_file_path) unless file_exists
+            FileUtils.rm_r(api_key_folder_path) unless directory_exists
+          end
+        else
+          apple_id_account = CredentialsManager::AccountManager.new(user: params[:username])
+
+          # Add password as a temporary environment variable for altool.
+          # Use app specific password if specified.
+          ENV['FL_NOTARIZE_PASSWORD'] = ENV['FASTLANE_APPLE_APPLICATION_SPECIFIC_PASSWORD'] || apple_id_account.password
+
+          yield(proc { |command| "#{command} -u #{apple_id_account.user} -p @env:FL_NOTARIZE_PASSWORD" })
+        end
+      end
+
       def self.description
         'Notarizes a macOS app'
       end
@@ -160,6 +196,8 @@ module Fastlane
                                        env_name: 'FL_NOTARIZE_USERNAME',
                                        description: 'Apple ID username',
                                        default_value: username,
+                                       optional: true,
+                                       conflicting_options: [:api_key_path],
                                        default_value_dynamic: true),
           FastlaneCore::ConfigItem.new(key: :asc_provider,
                                        env_name: 'FL_NOTARIZE_ASC_PROVIDER',
@@ -177,7 +215,16 @@ module Fastlane
                                        description: 'Whether to log requests',
                                        optional: true,
                                        default_value: false,
-                                       type: Boolean)
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :api_key_path,
+                                       env_name: 'FL_NOTARIZE_API_KEY_PATH',
+                                       description: 'Path to AppStore Connect API key',
+                                       optional: true,
+                                       conflicting_options: [:username],
+                                       is_string: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("API Key not found at '#{value}'") unless File.exist?(value)
+                                       end)
         ]
       end
 

data/fastlane/lib/fastlane/actions/push_to_git_remote.rb

@@ -36,7 +36,6 @@ module Fastlane
         params[:push_options].each { |push_option| command << "--push-option=#{push_option}" } if params[:push_options]
 
         # execute our command
-        Actions.sh('pwd')
         return command.join(' ') if Helper.test?
 
         Actions.sh(command.join(' '))

data/fastlane/lib/fastlane/actions/register_device.rb

@@ -39,7 +39,7 @@ module Fastlane
 
       def self.api_token(params)
         params[:api_key] ||= Actions.lane_context[SharedValues::APP_STORE_CONNECT_API_KEY]
-        api_token ||= Spaceship::ConnectAPI::Token.create(params[:api_key]) if params[:api_key]
+        api_token ||= Spaceship::ConnectAPI::Token.create(**params[:api_key]) if params[:api_key]
         api_token ||= Spaceship::ConnectAPI::Token.from_json_file(params[:api_key_path]) if params[:api_key_path]
         return api_token
       end

data/fastlane/lib/fastlane/actions/register_devices.rb

@@ -85,7 +85,7 @@ module Fastlane
 
       def self.api_token(params)
         params[:api_key] ||= Actions.lane_context[SharedValues::APP_STORE_CONNECT_API_KEY]
-        api_token ||= Spaceship::ConnectAPI::Token.create(params[:api_key]) if params[:api_key]
+        api_token ||= Spaceship::ConnectAPI::Token.create(**params[:api_key]) if params[:api_key]
         api_token ||= Spaceship::ConnectAPI::Token.from_json_file(params[:api_key_path]) if params[:api_key_path]
         return api_token
       end

data/fastlane/lib/fastlane/actions/restore_file.rb

@@ -5,7 +5,7 @@ module Fastlane
         path = params[:path]
         backup_path = "#{path}.back"
         UI.user_error!("Could not find file '#{backup_path}'") unless File.exist?(backup_path)
-        FileUtils.cp(backup_path, path, { preserve: true })
+        FileUtils.cp(backup_path, path, preserve: true)
         FileUtils.rm(backup_path)
         UI.message("Successfully restored backup 📤")
       end

data/fastlane/lib/fastlane/actions/set_changelog.rb

@@ -80,7 +80,7 @@ module Fastlane
 
       def self.api_token(params)
         params[:api_key] ||= Actions.lane_context[SharedValues::APP_STORE_CONNECT_API_KEY]
-        api_token ||= Spaceship::ConnectAPI::Token.create(params[:api_key]) if params[:api_key]
+        api_token ||= Spaceship::ConnectAPI::Token.create(**params[:api_key]) if params[:api_key]
         api_token ||= Spaceship::ConnectAPI::Token.from_json_file(params[:api_key_path]) if params[:api_key_path]
         return api_token
       end

data/fastlane/lib/fastlane/actions/sourcedocs.rb

@@ -0,0 +1,164 @@
+module Fastlane
+  module Actions
+    class SourcedocsAction < Action
+      def self.run(params)
+        UI.user_error!("You have to install sourcedocs using `brew install sourcedocs`") if `which sourcedocs`.to_s.length == 0 && !Helper.test?
+
+        command =  "sourcedocs generate"
+        command << " --all-modules" if params[:all_modules]
+        command << " --spm-module #{params[:spm_module]}" unless params[:spm_module].nil?
+        command << " --module-name #{params[:module_name]}" unless params[:module_name].nil?
+        command << " --link-beginning #{params[:link_beginning]}" unless params[:link_beginning].nil?
+        command << " --link-ending #{params[:link_ending]}" unless params[:link_ending].nil?
+        command << " --output-folder #{params[:output_folder]}" unless params[:output_folder].nil?
+        command << " --min-acl #{params[:min_acl]}" unless params[:min_acl].nil?
+        command << " --module-name-path" if params[:module_name_path]
+        command << " --clean" if params[:clean]
+        command << " --collapsible" if params[:collapsible]
+        command << " --table-of-contents" if params[:table_of_contents]
+        command << " --reproducible-docs" if params[:reproducible]
+        unless params[:scheme].nil?
+          command << " -- -scheme #{params[:scheme]}"
+          command << " -sdk #{params[:sdk_platform]}" unless params[:sdk_platform].nil?
+        end
+        Actions.sh(command)
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Generate docs using SourceDocs"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :all_modules,
+            env_name: 'FL_SOURCEDOCS_OUTPUT_ALL_MODULES',
+            description: 'Generate documentation for all modules in a Swift package',
+            type: Boolean,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :spm_module,
+            env_name: 'FL_SOURCEDOCS_SPM_MODULE',
+            description: 'Generate documentation for Swift Package Manager module',
+            type: String,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :module_name,
+            env_name: 'FL_SOURCEDOCS_MODULE_NAME',
+            description: 'Generate documentation for a Swift module',
+            type: String,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :link_beginning,
+            env_name: 'FL_SOURCEDOCS_LINK_BEGINNING',
+            description: 'The text to begin links with',
+            type: String,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :link_ending,
+            env_name: 'FL_SOURCEDOCS_LINK_ENDING',
+            description: 'The text to end links with (default: .md)',
+            type: String,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :output_folder,
+            env_name: 'FL_SOURCEDOCS_OUTPUT_FOLDER',
+            description: 'Output directory to clean (default: Documentation/Reference)',
+            type: String,
+            optional: false
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :min_acl,
+            env_name: 'FL_SOURCEDOCS_MIN_ACL',
+            description: 'Access level to include in documentation [private, fileprivate, internal, public, open] (default: public)',
+            type: String,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :module_name_path,
+            env_name: 'FL_SOURCEDOCS_MODULE_NAME_PATH',
+            description: 'Include the module name as part of the output folder path',
+            type: Boolean,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :clean,
+            env_name: 'FL_SOURCEDOCS_CLEAN',
+            description: 'Delete output folder before generating documentation',
+            type: Boolean,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :collapsible,
+            env_name: 'FL_SOURCEDOCS_COLLAPSIBLE',
+            description: 'Put methods, properties and enum cases inside collapsible blocks',
+            type: Boolean,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :table_of_contents,
+            env_name: 'FL_SOURCEDOCS_TABLE_OF_CONTENT',
+            description: 'Generate a table of contents with properties and methods for each type',
+            type: Boolean,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :reproducible,
+            env_name: 'FL_SOURCEDOCS_REPRODUCIBLE',
+            description: 'Generate documentation that is reproducible: only depends on the sources',
+            type: Boolean,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :scheme,
+            env_name: 'FL_SOURCEDOCS_SCHEME',
+            description: 'Create documentation for specific scheme',
+            type: String,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :sdk_platform,
+            env_name: 'FL_SOURCEDOCS_SDK_PlATFORM',
+            description: 'Create documentation for specific sdk platform',
+            type: String,
+            optional: true
+          )
+        ]
+      end
+
+      def self.output
+      end
+
+      def self.return_value
+      end
+
+      def self.authors
+        ["Kukurijek"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          "sourcedocs(output_folder: 'docs')",
+          "sourcedocs(output_folder: 'docs', clean: true, reproducible: true, scheme: 'MyApp')"
+        ]
+      end
+
+      def self.category
+        :documentation
+      end
+    end
+  end
+end