fastlane 2.189.0 → 2.193.0

data/fastlane/swift/Gymfile.swift

@@ -17,4 +17,4 @@ public class Gymfile: GymfileProtocol {
     // during the `init` process, and you won't see this message
 }
 
-// Generated with fastlane 2.189.0
+// Generated with fastlane 2.193.0

data/fastlane/swift/GymfileProtocol.swift

@@ -196,4 +196,4 @@ public extension GymfileProtocol {
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.80]
+// FastlaneRunnerAPIVersion [0.9.84]

data/fastlane/swift/Matchfile.swift

@@ -17,4 +17,4 @@ public class Matchfile: MatchfileProtocol {
     // during the `init` process, and you won't see this message
 }
 
-// Generated with fastlane 2.189.0
+// Generated with fastlane 2.193.0

data/fastlane/swift/MatchfileProtocol.swift

@@ -184,4 +184,4 @@ public extension MatchfileProtocol {
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.74]
+// FastlaneRunnerAPIVersion [0.9.78]

data/fastlane/swift/Precheckfile.swift

@@ -17,4 +17,4 @@ public class Precheckfile: PrecheckfileProtocol {
     // during the `init` process, and you won't see this message
 }
 
-// Generated with fastlane 2.189.0
+// Generated with fastlane 2.193.0

data/fastlane/swift/PrecheckfileProtocol.swift

@@ -52,4 +52,4 @@ public extension PrecheckfileProtocol {
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.73]
+// FastlaneRunnerAPIVersion [0.9.77]

data/fastlane/swift/Scanfile.swift

@@ -17,4 +17,4 @@ public class Scanfile: ScanfileProtocol {
     // during the `init` process, and you won't see this message
 }
 
-// Generated with fastlane 2.189.0
+// Generated with fastlane 2.193.0

data/fastlane/swift/ScanfileProtocol.swift

@@ -296,4 +296,4 @@ public extension ScanfileProtocol {
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.85]
+// FastlaneRunnerAPIVersion [0.9.89]

data/fastlane/swift/Screengrabfile.swift

@@ -17,4 +17,4 @@ public class Screengrabfile: ScreengrabfileProtocol {
     // during the `init` process, and you won't see this message
 }
 
-// Generated with fastlane 2.189.0
+// Generated with fastlane 2.193.0

data/fastlane/swift/ScreengrabfileProtocol.swift

@@ -96,4 +96,4 @@ public extension ScreengrabfileProtocol {
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.75]
+// FastlaneRunnerAPIVersion [0.9.79]

data/fastlane/swift/Snapshotfile.swift

@@ -17,4 +17,4 @@ public class Snapshotfile: SnapshotfileProtocol {
     // during the `init` process, and you won't see this message
 }
 
-// Generated with fastlane 2.189.0
+// Generated with fastlane 2.193.0

data/fastlane/swift/SnapshotfileProtocol.swift

@@ -200,4 +200,4 @@ public extension SnapshotfileProtocol {
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.69]
+// FastlaneRunnerAPIVersion [0.9.73]

data/fastlane/swift/formatting/Brewfile.lock.json

@@ -43,19 +43,19 @@
         "macOS": "10.15.7"
       },
       "big_sur": {
-        "HOMEBREW_VERSION": "2.4.13-249-g6454504",
-        "HOMEBREW_PREFIX": "/usr/local",
-        "Homebrew/homebrew-core": "020491c34515c229d904e6e69e14157cb728d2fa",
-        "CLT": "11.0.28.3",
-        "Xcode": "12.0",
-        "macOS": "11.0"
+        "HOMEBREW_VERSION": "3.2.10-18-g7d56615",
+        "HOMEBREW_PREFIX": "/opt/homebrew",
+        "Homebrew/homebrew-core": "17ef60082350d5eea95728f146863b767e2257f2",
+        "CLT": "12.5.1.0.1.1623191612",
+        "Xcode": "13.0",
+        "macOS": "11.5.2"
       },
       "monterey": {
-        "HOMEBREW_VERSION": "3.2.5-13-g89b8619",
+        "HOMEBREW_VERSION": "3.2.6-34-g6bb3699",
         "HOMEBREW_PREFIX": "/usr/local",
-        "Homebrew/homebrew-core": "61ecc3e550752e9348480ec3c221e7f2c6abcac0",
+        "Homebrew/homebrew-core": "b7523de28df0f0f819ff2c49c84611eec19f5455",
         "CLT": "13.0.0.0.1.1626155413",
-        "Xcode": "12.5.1",
+        "Xcode": "13.0",
         "macOS": "12.0"
       }
     }

data/fastlane_core/lib/fastlane_core/build_watcher.rb

@@ -11,7 +11,7 @@ module FastlaneCore
 
     class << self
       # @return The build we waited for. This method will always return a build
-      def wait_for_build_processing_to_be_complete(app_id: nil, platform: nil, train_version: nil, app_version: nil, build_version: nil, poll_interval: 10, timeout_duration: nil, strict_build_watch: false, return_when_build_appears: false, return_spaceship_testflight_build: true, select_latest: false)
+      def wait_for_build_processing_to_be_complete(app_id: nil, platform: nil, train_version: nil, app_version: nil, build_version: nil, poll_interval: 10, timeout_duration: nil, strict_build_watch: false, return_when_build_appears: false, return_spaceship_testflight_build: true, select_latest: false, wait_for_build_beta_detail_processing: false)
         # Warn about train_version being removed in the future
         if train_version
           UI.deprecated(":train_version is no longer a used argument on FastlaneCore::BuildWatcher. Please use :app_version instead.")
@@ -41,13 +41,13 @@ module FastlaneCore
             showed_info = true
           end
 
-          report_status(build: matched_build)
+          report_status(build: matched_build, wait_for_build_beta_detail_processing: wait_for_build_beta_detail_processing)
 
           # Processing of builds by AppStoreConnect can be a very time consuming task and will
           # block the worker running this task until it is completed. In some cases,
           # having a build resource appear in AppStoreConnect (matched_build) may be enough (i.e. setting a changelog)
           # so here we may choose to skip the full processing of the build if return_when_build_appears is true
-          if matched_build && (return_when_build_appears || matched_build.processed?)
+          if matched_build && (return_when_build_appears || processed?(build: matched_build, wait_for_build_beta_detail_processing: wait_for_build_beta_detail_processing))
 
             if !app_version.nil? && app_version != app_version_queried
               UI.important("App version is #{app_version} but build was found while querying #{app_version_queried}")
@@ -145,10 +145,29 @@ module FastlaneCore
         return nil
       end
 
-      def report_status(build: nil)
-        if build && !build.processed?
+      def processed?(build: nil, wait_for_build_beta_detail_processing: false)
+        return false unless build
+
+        is_processed = build.processed?
+
+        # App Store Connect API has multiple build processing states
+        # builds have one processing status
+        # buildBetaDetails have two processing statues (internal and external testing)
+        #
+        # If set, this method will only return true if all three statuses are complete
+        if wait_for_build_beta_detail_processing
+          is_processed &&= build.build_beta_detail.processed?
+        end
+
+        return is_processed
+      end
+
+      def report_status(build: nil, wait_for_build_beta_detail_processing: false)
+        is_processed = processed?(build: build, wait_for_build_beta_detail_processing: wait_for_build_beta_detail_processing)
+
+        if build && !is_processed
           UI.message("Waiting for App Store Connect to finish processing the new build (#{build.app_version} - #{build.version}) for #{build.platform}")
-        elsif build && build.processed?
+        elsif build && is_processed
           UI.success("Successfully finished processing the build #{build.app_version} - #{build.version} for #{build.platform}")
         else
           UI.message("Waiting for the build to show up in the build list - this may take a few minutes (check your email for processing issues if this continues)")

data/fastlane_core/lib/fastlane_core/keychain_importer.rb

@@ -7,14 +7,17 @@ module FastlaneCore
     def self.import_file(path, keychain_path, keychain_password: nil, certificate_password: "", skip_set_partition_list: false, output: FastlaneCore::Globals.verbose?)
       UI.user_error!("Could not find file '#{path}'") unless File.exist?(path)
 
+      password_part = " -P #{certificate_password.shellescape}"
+
       command = "security import #{path.shellescape} -k '#{keychain_path.shellescape}'"
-      command << " -P #{certificate_password.shellescape}"
+      command << password_part
       command << " -T /usr/bin/codesign" # to not be asked for permission when running a tool like `gym` (before Sierra)
       command << " -T /usr/bin/security"
       command << " -T /usr/bin/productbuild" # to not be asked for permission when using an installer cert for macOS
       command << " 1> /dev/null" unless output
 
-      UI.command(command) if output
+      sensitive_command = command.gsub(password_part, " -P ********")
+      UI.command(sensitive_command) if output
       Open3.popen3(command) do |stdin, stdout, stderr, thrd|
         UI.command_output(stdout.read.to_s) if output
 
@@ -38,17 +41,21 @@ module FastlaneCore
       # When security supports partition lists, also add the partition IDs
       # See https://openradar.appspot.com/28524119
       if Helper.backticks('security -h | grep set-key-partition-list', print: false).length > 0
+        password_part = " -k #{keychain_password.to_s.shellescape}"
+
         command = "security set-key-partition-list"
         command << " -S apple-tool:,apple:,codesign:"
         command << " -s" # This is a needed in Catalina to prevent "security: SecKeychainItemCopyAccess: A missing value was detected."
-        command << " -k #{keychain_password.to_s.shellescape}"
+        command << password_part
         command << " #{keychain_path.shellescape}"
         command << " 1> /dev/null" # always disable stdout. This can be very verbose, and leak potentially sensitive info
 
         # Showing loading indicator as this can take some time if a lot of keys installed
         Helper.show_loading_indicator("Setting key partition list... (this can take a minute if there are a lot of keys installed)")
 
-        UI.command(command) if output
+        # Strip keychain password from command output
+        sensitive_command = command.gsub(password_part, " -k ********")
+        UI.command(sensitive_command) if output
         Open3.popen3(command) do |stdin, stdout, stderr, thrd|
           unless thrd.value.success?
             err = stderr.read.to_s.strip

data/fastlane_core/lib/fastlane_core/ui/disable_colors.rb

@@ -10,6 +10,7 @@ class String
     end
   end
   Colored::EXTRAS.keys.each do |extra|
+    next if extra == 'clear'
     define_method(extra) do
       self # do nothing with the string, but return it
     end

data/fastlane_core/lib/fastlane_core/ui/fastlane_runner.rb

@@ -34,6 +34,46 @@ module Commander
 
     attr_accessor :collector
 
+    # Temporary work around for issues mentioned in https://github.com/fastlane/fastlane/pull/18760
+    # Code taken from https://github.com/commander-rb/commander/blob/40d06bfbc54906d0de7c72ac73f4e9188c9ca294/lib/commander/runner.rb#L372-L385
+    #
+    # Problem:
+    #  `optparse` is guessing that command option `-e` is referring to global option `--env` (because it starts with an e).
+    #  This is raising OptionParser::MissingArgument error because `--env` takes a string argument.
+    #  A command of `-e --verbose` works because `--verbose` is seen as the argument.
+    #  A command of `--verbose -e` doesn't work because no argument after `-e` so MissingArgument is raised again.
+    #  This broke somewhere between Ruby 2.5 and Ruby 2.6
+    #
+    # Solution:
+    #  Proper solution is to set `parser.require_exact = true` but this only available on `optparse` version 0.1.1
+    #  which is not used by Commander.
+    #  `require_exact` will prevent OptionParser from assuming `-e` is the same as `--env STRING`
+    #  Even if it was on RubyGems, it would require Commander to allow this option to be set on OptionParser
+    #
+    # This work around was made on 2021-08-13
+    #
+    # When fixed:
+    #  This method implementation overrides one provided by Commander::Runner already. Just delete this method
+    #  so the existing one can be used
+    def parse_global_options
+      parser = options.inject(OptionParser.new) do |options, option|
+        options.on(*option[:args], &global_option_proc(option[:switches], &option[:proc]))
+      end
+
+      # This is the actual solution but is only in version 0.1.1 of optparse and its not in Commander
+      # This is the only change from Commanders implementation of parse_global_options
+      parser.require_exact = true
+
+      options = @args.dup
+      begin
+        parser.parse!(options)
+      rescue OptionParser::InvalidOption => e
+        # Remove the offending args and retry.
+        options = options.reject { |o| e.args.include?(o) }
+        retry
+      end
+    end
+
     def run!
       require_program(:version, :description)
       trap('INT') { abort(program(:int_message)) } if program(:int_message)
@@ -47,6 +87,7 @@ module Commander
         say(version)
         return
       end
+
       parse_global_options
       remove_global_options(options, @args)
 

data/match/lib/match/runner.rb

@@ -191,12 +191,12 @@ module Match
             UI.verbose("Certificate '#{File.basename(cert_path)}' is already installed on this machine")
           else
             Utils.import(cert_path, params[:keychain_name], password: params[:keychain_password])
-          end
 
-          # Import the private key
-          # there seems to be no good way to check if it's already installed - so just install it
-          # Key will only be added to the partition list if it isn't already installed
-          Utils.import(keys.last, params[:keychain_name], password: params[:keychain_password])
+            # Import the private key
+            # there seems to be no good way to check if it's already installed - so just install it
+            # Key will only be added to the partition list if it isn't already installed
+            Utils.import(keys.last, params[:keychain_name], password: params[:keychain_password])
+          end
         else
           UI.message("Skipping installation of certificate as it would not work on this operating system.")
         end

data/pilot/lib/pilot/build_manager.rb

@@ -16,7 +16,7 @@ module Pilot
       should_login_in_start = options[:apple_id].nil?
       start(options, should_login: should_login_in_start)
 
-      UI.user_error!("No ipa file given") unless config[:ipa]
+      UI.user_error!("No ipa or pkg file given") if config[:ipa].nil? && config[:pkg].nil?
 
       check_for_changelog_or_whats_new!(options)
 
@@ -25,10 +25,17 @@ module Pilot
       dir = Dir.mktmpdir
 
       platform = fetch_app_platform
-      package_path = FastlaneCore::IpaUploadPackageBuilder.new.generate(app_id: fetch_app_id,
+      if options[:ipa]
+        package_path = FastlaneCore::IpaUploadPackageBuilder.new.generate(app_id: fetch_app_id,
                                                                       ipa_path: options[:ipa],
                                                                   package_path: dir,
                                                                       platform: platform)
+      else
+        package_path = FastlaneCore::PkgUploadPackageBuilder.new.generate(app_id: fetch_app_id,
+                                                                        pkg_path: options[:pkg],
+                                                                    package_path: dir,
+                                                                        platform: platform)
+      end
 
       transporter = transporter_for_selected_team(options)
       result = transporter.upload(package_path: package_path)
@@ -94,6 +101,9 @@ module Pilot
       if config[:ipa]
         app_version = FastlaneCore::IpaFileAnalyser.fetch_app_version(config[:ipa])
         app_build = FastlaneCore::IpaFileAnalyser.fetch_app_build(config[:ipa])
+      elsif config[:pkg]
+        app_version = FastlaneCore::PkgFileAnalyser.fetch_app_version(config[:pkg])
+        app_build = FastlaneCore::PkgFileAnalyser.fetch_app_build(config[:pkg])
       else
         app_version = config[:app_version]
         app_build = config[:build_number]
@@ -108,7 +118,8 @@ module Pilot
         timeout_duration: config[:wait_processing_timeout_duration],
         return_when_build_appears: return_when_build_appears,
         return_spaceship_testflight_build: false,
-        select_latest: config[:distribute_only]
+        select_latest: config[:distribute_only],
+        wait_for_build_beta_detail_processing: true
       )
 
       unless latest_build.app_version == app_version && latest_build.version == app_build
@@ -558,7 +569,6 @@ module Pilot
       attributes[:autoNotifyEnabled] = info[:auto_notify_enabled] if info.key?(:auto_notify_enabled)
       build_beta_detail = build.build_beta_detail
 
-      # https://github.com/fastlane/fastlane/pull/16006
       if build_beta_detail
         Spaceship::ConnectAPI.patch_build_beta_details(build_beta_details_id: build_beta_detail.id, attributes: attributes)
       else

data/pilot/lib/pilot/manager.rb

@@ -73,7 +73,8 @@ module Pilot
 
     def fetch_app_identifier
       result = config[:app_identifier]
-      result ||= FastlaneCore::IpaFileAnalyser.fetch_app_identifier(config[:ipa])
+      result ||= FastlaneCore::IpaFileAnalyser.fetch_app_identifier(config[:ipa]) if config[:ipa]
+      result ||= FastlaneCore::PkgFileAnalyser.fetch_app_identifier(config[:pkg]) if config[:pkg]
       result ||= UI.input("Please enter the app's bundle identifier: ")
       UI.verbose("App identifier (#{result})")
       return result
@@ -82,6 +83,7 @@ module Pilot
     def fetch_app_platform(required: true)
       result = config[:app_platform]
       result ||= FastlaneCore::IpaFileAnalyser.fetch_app_platform(config[:ipa]) if config[:ipa]
+      result ||= FastlaneCore::PkgFileAnalyser.fetch_app_platform(config[:pkg]) if config[:pkg]
       if required
         result ||= UI.input("Please enter the app's platform (appletvos, ios, osx): ")
         UI.user_error!("App Platform must be ios, appletvos, or osx") unless ['ios', 'appletvos', 'osx'].include?(result)

data/pilot/lib/pilot/options.rb

@@ -48,7 +48,6 @@ module Pilot
                                      env_name: "PILOT_PLATFORM",
                                      description: "The platform to use (optional)",
                                      optional: true,
-                                     default_value: 'ios',
                                      verify_block: proc do |value|
                                        UI.user_error!("The platform can only be ios, appletvos, or osx") unless ['ios', 'appletvos', 'osx'].include?(value)
                                      end),
@@ -82,6 +81,26 @@ module Pilot
                                        value = File.expand_path(value)
                                        UI.user_error!("Could not find ipa file at path '#{value}'") unless File.exist?(value)
                                        UI.user_error!("'#{value}' doesn't seem to be an ipa file") unless value.end_with?(".ipa")
+                                     end,
+                                     conflicting_options: [:pkg],
+                                     conflict_block: proc do |value|
+                                       UI.user_error!("You can't use 'ipa' and '#{value.key}' options in one run.")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :pkg,
+                                     short_option: "-P",
+                                     optional: true,
+                                     env_name: "PILOT_PKG",
+                                     description: "Path to your pkg file",
+                                     code_gen_sensitive: true,
+                                     default_value: Dir["*.pkg"].sort_by { |x| File.mtime(x) }.last,
+                                     default_value_dynamic: true,
+                                     verify_block: proc do |value|
+                                       UI.user_error!("Could not find pkg file at path '#{File.expand_path(value)}'") unless File.exist?(value)
+                                       UI.user_error!("'#{value}' doesn't seem to be a pkg file") unless value.end_with?(".pkg")
+                                     end,
+                                     conflicting_options: [:ipa],
+                                     conflict_block: proc do |value|
+                                       UI.user_error!("You can't use 'pkg' and '#{value.key}' options in one run.")
                                      end),
 
         # app review info

data/produce/lib/produce/commands_generator.rb

@@ -3,6 +3,7 @@ require 'commander'
 require 'fastlane/version'
 require 'fastlane_core/ui/help_formatter'
 require 'fastlane_core/configuration/config_item'
+require 'fastlane_core/print_table'
 require_relative 'module'
 require_relative 'manager'
 require_relative 'options'
@@ -196,6 +197,33 @@ module Produce
         end
       end
 
+      command :available_services do |c|
+        c.syntax = 'fastlane produce available_services -a APP_IDENTIFIER'
+        c.description = 'Displays a list of allowed Application Services for a specific app.'
+        c.example('Check Available Services', 'fastlane produce available_services -a com.example.app')
+
+        FastlaneCore::CommanderGenerator.new.generate(Produce::Options.available_options, command: c)
+
+        c.action do |args, options|
+          # Filter the options so that we can still build the configuration
+          allowed_keys = Produce::Options.available_options.collect(&:key)
+          Produce.config = FastlaneCore::Configuration.create(Produce::Options.available_options, options.__hash__.select { |key, value| allowed_keys.include?(key) })
+
+          require 'produce/service'
+          require 'terminal-table'
+
+          services = Produce::Service.available_services(options, args)
+          rows = services.map { |capabilities| [capabilities.name, capabilities.id, capabilities.description] }
+          table = Terminal::Table.new(
+            title: "Available Services",
+            headings: ['Name', 'ID', 'Description'],
+            rows: FastlaneCore::PrintTable.transform_output(rows),
+            style: { all_separators: true }
+          )
+          puts(table)
+        end
+      end
+
       command :group do |c|
         c.syntax = 'fastlane produce group'
         c.description = 'Ensure that a specific App Group exists'