fastlane 2.178.0 → 2.182.0

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/slack.rb

@@ -1,70 +1,178 @@
+require 'fastlane/notification/slack'
+
 # rubocop:disable Style/CaseEquality
 # rubocop:disable Style/MultilineTernaryOperator
 # rubocop:disable Style/NestedTernaryOperator
 module Fastlane
   module Actions
     class SlackAction < Action
-      def self.is_supported?(platform)
-        true
-      end
+      class Runner
+        def initialize(slack_url)
+          @notifier = Fastlane::Notification::Slack.new(slack_url)
+        end
 
-      # As there is a text limit in the notifications, we are
-      # usually interested in the last part of the message
-      # e.g. for tests
-      def self.trim_message(message)
-        # We want the last 7000 characters, instead of the first 7000, as the error is at the bottom
-        start_index = [message.length - 7000, 0].max
-        message = message[start_index..-1]
-        # We want line breaks to be shown on slack output so we replace
-        # input non-interpreted line break with interpreted line break
-        message.gsub('\n', "\n")
-      end
+        def run(options)
+          options[:message] = self.class.trim_message(options[:message].to_s || '')
+          options[:message] = Fastlane::Notification::Slack::LinkConverter.convert(options[:message])
 
-      def self.run(options)
-        require 'slack-notifier'
+          options[:pretext] = options[:pretext].gsub('\n', "\n") unless options[:pretext].nil?
 
-        options[:message] = self.trim_message(options[:message].to_s || '')
-        options[:message] = Slack::Notifier::Util::LinkFormatter.format(options[:message])
+          if options[:channel].to_s.length > 0
+            channel = options[:channel]
+            channel = ('#' + options[:channel]) unless ['#', '@'].include?(channel[0]) # send message to channel by default
+          end
 
-        options[:pretext] = options[:pretext].gsub('\n', "\n") unless options[:pretext].nil?
+          username = options[:use_webhook_configured_username_and_icon] ? nil : options[:username]
 
-        if options[:channel].to_s.length > 0
-          channel = options[:channel]
-          channel = ('#' + options[:channel]) unless ['#', '@'].include?(channel[0]) # send message to channel by default
+          slack_attachment = self.class.generate_slack_attachments(options)
+          link_names = options[:link_names]
+          icon_url = options[:use_webhook_configured_username_and_icon] ? nil : options[:icon_url]
+
+          post_message(
+            channel: channel,
+            username: username,
+            attachments: [slack_attachment],
+            link_names: link_names,
+            icon_url: icon_url,
+            fail_on_error: options[:fail_on_error]
+          )
         end
 
-        username = options[:use_webhook_configured_username_and_icon] ? nil : options[:username]
+        def post_message(channel:, username:, attachments:, link_names:, icon_url:, fail_on_error:)
+          @notifier.post_to_legacy_incoming_webhook(
+            channel: channel,
+            username: username,
+            link_names: link_names,
+            icon_url: icon_url,
+            attachments: attachments
+          )
+          UI.success('Successfully sent Slack notification')
+        rescue => error
+          UI.error("Exception: #{error}")
+          message = "Error pushing Slack message, maybe the integration has no permission to post on this channel? Try removing the channel parameter in your Fastfile, this is usually caused by a misspelled or changed group/channel name or an expired SLACK_URL"
+          if fail_on_error
+            UI.user_error!(message)
+          else
+            UI.error(message)
+          end
+        end
 
-        notifier = Slack::Notifier.new(options[:slack_url], channel: channel, username: username)
+        # As there is a text limit in the notifications, we are
+        # usually interested in the last part of the message
+        # e.g. for tests
+        def self.trim_message(message)
+          # We want the last 7000 characters, instead of the first 7000, as the error is at the bottom
+          start_index = [message.length - 7000, 0].max
+          message = message[start_index..-1]
+          # We want line breaks to be shown on slack output so we replace
+          # input non-interpreted line break with interpreted line break
+          message.gsub('\n', "\n")
+        end
 
-        link_names = options[:link_names]
+        def self.generate_slack_attachments(options)
+          color = (options[:success] ? 'good' : 'danger')
+          should_add_payload = ->(payload_name) { options[:default_payloads].map(&:to_sym).include?(payload_name.to_sym) }
 
-        icon_url = options[:use_webhook_configured_username_and_icon] ? nil : options[:icon_url]
+          slack_attachment = {
+            fallback: options[:message],
+            text: options[:message],
+            pretext: options[:pretext],
+            color: color,
+            mrkdwn_in: ["pretext", "text", "fields", "message"],
+            fields: []
+          }
 
-        slack_attachment = generate_slack_attachments(options)
+          # custom user payloads
+          slack_attachment[:fields] += options[:payload].map do |k, v|
+            {
+              title: k.to_s,
+              value: Fastlane::Notification::Slack::LinkConverter.convert(v.to_s),
+              short: false
+            }
+          end
 
-        return [notifier, slack_attachment] if Helper.test? # tests will verify the slack attachments and other properties
+          # Add the lane to the Slack message
+          # This might be nil, if slack is called as "one-off" action
+          if should_add_payload[:lane] && Actions.lane_context[Actions::SharedValues::LANE_NAME]
+            slack_attachment[:fields] << {
+              title: 'Lane',
+              value: Actions.lane_context[Actions::SharedValues::LANE_NAME],
+              short: true
+            }
+          end
 
-        begin
-          results = notifier.ping('', link_names: link_names, icon_url: icon_url, attachments: [slack_attachment])
-        rescue => exception
-          UI.error("Exception: #{exception}")
-        ensure
-          result = results.first if results
-          if !result.nil? && result.code.to_i == 200
-            UI.success('Successfully sent Slack notification')
-          else
-            UI.verbose(result) unless result.nil?
-            message = "Error pushing Slack message, maybe the integration has no permission to post on this channel? Try removing the channel parameter in your Fastfile, this is usually caused by a misspelled or changed group/channel name or an expired SLACK_URL"
-            if options[:fail_on_error]
-              UI.user_error!(message)
+          # test_result
+          if should_add_payload[:test_result]
+            slack_attachment[:fields] << {
+              title: 'Result',
+              value: (options[:success] ? 'Success' : 'Error'),
+              short: true
+            }
+          end
+
+          # git branch
+          if Actions.git_branch && should_add_payload[:git_branch]
+            slack_attachment[:fields] << {
+              title: 'Git Branch',
+              value: Actions.git_branch,
+              short: true
+            }
+          end
+
+          # git_author
+          if Actions.git_author_email && should_add_payload[:git_author]
+            if FastlaneCore::Env.truthy?('FASTLANE_SLACK_HIDE_AUTHOR_ON_SUCCESS') && options[:success]
+            # We only show the git author if the build failed
             else
-              UI.error(message)
+              slack_attachment[:fields] << {
+                title: 'Git Author',
+                value: Actions.git_author_email,
+                short: true
+              }
             end
           end
+
+          # last_git_commit
+          if Actions.last_git_commit_message && should_add_payload[:last_git_commit]
+            slack_attachment[:fields] << {
+              title: 'Git Commit',
+              value: Actions.last_git_commit_message,
+              short: false
+            }
+          end
+
+          # last_git_commit_hash
+          if Actions.last_git_commit_hash(true) && should_add_payload[:last_git_commit_hash]
+            slack_attachment[:fields] << {
+              title: 'Git Commit Hash',
+              value: Actions.last_git_commit_hash(short: true),
+              short: false
+            }
+          end
+
+          # merge additional properties
+          deep_merge(slack_attachment, options[:attachment_properties])
+        end
+
+        # Adapted from https://stackoverflow.com/a/30225093/158525
+        def self.deep_merge(a, b)
+          merger = proc do |key, v1, v2|
+            Hash === v1 && Hash === v2 ?
+              v1.merge(v2, &merger) : Array === v1 && Array === v2 ?
+                                        v1 | v2 : [:undefined, nil, :nil].include?(v2) ? v1 : v2
+          end
+          a.merge(b, &merger)
         end
       end
 
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.run(options)
+        Runner.new(options[:slack_url]).run(options)
+      end
+
       def self.description
         "Send a success/error message to your [Slack](https://slack.com) group"
       end
@@ -185,99 +293,13 @@ module Fastlane
       # @!group Helper
       #####################################################
 
-      def self.generate_slack_attachments(options)
-        color = (options[:success] ? 'good' : 'danger')
-        should_add_payload = ->(payload_name) { options[:default_payloads].map(&:to_sym).include?(payload_name.to_sym) }
-
-        slack_attachment = {
-          fallback: options[:message],
-          text: options[:message],
-          pretext: options[:pretext],
-          color: color,
-          mrkdwn_in: ["pretext", "text", "fields", "message"],
-          fields: []
-        }
-
-        # custom user payloads
-        slack_attachment[:fields] += options[:payload].map do |k, v|
-          {
-            title: k.to_s,
-            value: Slack::Notifier::Util::LinkFormatter.format(v.to_s),
-            short: false
-          }
-        end
-
-        # Add the lane to the Slack message
-        # This might be nil, if slack is called as "one-off" action
-        if should_add_payload[:lane] && Actions.lane_context[Actions::SharedValues::LANE_NAME]
-          slack_attachment[:fields] << {
-            title: 'Lane',
-            value: Actions.lane_context[Actions::SharedValues::LANE_NAME],
-            short: true
-          }
-        end
-
-        # test_result
-        if should_add_payload[:test_result]
-          slack_attachment[:fields] << {
-            title: 'Result',
-            value: (options[:success] ? 'Success' : 'Error'),
-            short: true
-          }
-        end
-
-        # git branch
-        if Actions.git_branch && should_add_payload[:git_branch]
-          slack_attachment[:fields] << {
-            title: 'Git Branch',
-            value: Actions.git_branch,
-            short: true
-          }
-        end
-
-        # git_author
-        if Actions.git_author_email && should_add_payload[:git_author]
-          if FastlaneCore::Env.truthy?('FASTLANE_SLACK_HIDE_AUTHOR_ON_SUCCESS') && options[:success]
-            # We only show the git author if the build failed
-          else
-            slack_attachment[:fields] << {
-              title: 'Git Author',
-              value: Actions.git_author_email,
-              short: true
-            }
-          end
-        end
-
-        # last_git_commit
-        if Actions.last_git_commit_message && should_add_payload[:last_git_commit]
-          slack_attachment[:fields] << {
-            title: 'Git Commit',
-            value: Actions.last_git_commit_message,
-            short: false
-          }
-        end
-
-        # last_git_commit_hash
-        if Actions.last_git_commit_hash(true) && should_add_payload[:last_git_commit_hash]
-          slack_attachment[:fields] << {
-            title: 'Git Commit Hash',
-            value: Actions.last_git_commit_hash(short: true),
-            short: false
-          }
-        end
-
-        # merge additional properties
-        deep_merge(slack_attachment, options[:attachment_properties])
+      def self.trim_message(message)
+        Runner.trim_message(message)
       end
 
-      # Adapted from https://stackoverflow.com/a/30225093/158525
-      def self.deep_merge(a, b)
-        merger = proc do |key, v1, v2|
-          Hash === v1 && Hash === v2 ?
-                 v1.merge(v2, &merger) : Array === v1 && Array === v2 ?
-                   v1 | v2 : [:undefined, nil, :nil].include?(v2) ? v1 : v2
-        end
-        a.merge(b, &merger)
+      def self.generate_slack_attachments(options)
+        UI.deprecated('`Fastlane::Actions::Slack.generate_slack_attachments` is subject to be removed as Slack recommends migrating `attachments` to Block Kit. fastlane will also follow the same direction.')
+        Runner.generate_slack_attachments(options)
       end
     end
   end