fastlane 2.163.0 → 2.168.0

data/fastlane/lib/fastlane/actions/appledoc.rb

@@ -55,7 +55,7 @@ module Fastlane
 
       def self.run(params)
         unless Helper.test?
-          UI.message("Install using `brew install homebrew/boneyard/appledoc`")
+          UI.message("Install using `brew install appledoc`")
           UI.user_error!("appledoc not installed") if `which appledoc`.length == 0
         end
 

data/fastlane/lib/fastlane/actions/docs/capture_ios_screenshots.md

@@ -106,7 +106,7 @@ app.launch()
 
 ```objective-c
 XCUIApplication *app = [[XCUIApplication alloc] init];
-[Snapshot setupSnapshot:app];
+[Snapshot setupSnapshot:app waitForAnimations:NO];
 [app launch];
 ```
 
@@ -282,6 +282,10 @@ launch_arguments([
 ])
 ```
 
+## Xcode Environment Variables
+
+_snapshot_ includes `FASTLANE_SNAPSHOT=YES` and `FASTLANE_LANGUAGE=<language>` as arguments when executing `xcodebuild`. This means you may use these environment variables in a custom build phase run script to do any additional configuration.
+
 # How does it work?
 
 The easiest solution would be to just render the UIWindow into a file. That's not possible because UI Tests don't run on a main thread. So _snapshot_ uses a different approach:

data/fastlane/lib/fastlane/actions/docs/sync_code_signing.md

@@ -492,6 +492,15 @@ fastlane match import
 
 You'll be prompted for the certificate (`.cer`), the private key (`.p12`) and the provisioning profiles (`.mobileprovision` or `.provisionprofile`) paths. _match_ will first validate the certificate (`.cer`) against the Developer Portal before importing the certificate, the private key and the provisioning profiles into the specified _match_ repository.
 
+However if there is no access to the developer portal but there are certificates, private keys and profiles provided, you can use the `skip_certificate_matching` option to tell _match_ not to verify the certificates. Like this:
+
+```no-highlight
+fastlane match import --skip_certificate_matching true
+```
+This will skip login to Apple Developer Portal and will import the provided certificate, private key and profile directly to the certificates repo.
+
+Please be careful when using this option and ensure the certificates and profiles match the type (development, adhoc, appstore, enterprise, developer_id) and are not revoked or expired.
+
 ### Manual Decrypt
 
 If you want to manually decrypt a file you can.

data/fastlane/lib/fastlane/actions/import_from_git.rb

@@ -19,6 +19,9 @@ module Fastlane
 
       def self.available_options
         [
+          # Because the `run` method is actually implemented in `fast_file.rb`,
+          # and because magic, some of the parameters on `ConfigItem`s (e.g.
+          # `conflicting_options`, `verify_block`) are completely ignored.
           FastlaneCore::ConfigItem.new(key: :url,
                                        description: "The URL of the repository to import the Fastfile from",
                                        default_value: nil),
@@ -38,6 +41,10 @@ module Fastlane
                                        description: "The version to checkout on the repository. Optimistic match operator or multiple conditions can be used to select the latest version within constraints",
                                        default_value: nil,
                                        is_string: false,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :cache_path,
+                                       description: "The path to a directory where the repository should be cloned into. This is ignored if `version` is not specified. Defaults to `nil`, which causes the repository to be cloned on every call, to a temporary directory",
+                                       default_value: nil,
                                        optional: true)
         ]
       end
@@ -62,7 +69,8 @@ module Fastlane
             url: "git@github.com:fastlane/fastlane.git", # The URL of the repository to import the Fastfile from.
             branch: "HEAD", # The branch to checkout on the repository
             path: "fastlane/Fastfile", # The path of the Fastfile in the repository
-            version: [">= 1.1.0", "< 2.0.0"] # The version to checkout on the repository. Multiple conditions can be used to select the latest version within constraints.
+            version: [">= 1.1.0", "< 2.0.0"], # The version to checkout on the repository. Multiple conditions can be used to select the latest version within constraints.
+            cache_path: "~/.cache/fastlane/imported" # A directory in which the repository will be added, which means that it will not be cloned again on subsequent calls.
           )'
         ]
       end

data/fastlane/lib/fastlane/actions/is_ci.rb

@@ -35,7 +35,7 @@ module Fastlane
 
       def self.example_code
         [
-          'if is_ci?
+          'if is_ci
             puts "I\'m a computer"
           else
             say "Hi Human!"

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

@@ -53,7 +53,10 @@ module Fastlane
         existing_devices = Spaceship::ConnectAPI::Device.all
 
         device_objs = new_devices.map do |device|
-          next if existing_devices.map(&:udid).include?(device[0])
+          if existing_devices.map(&:udid).map(&:downcase).include?(device[0].downcase)
+            UI.verbose("UDID #{device[0]} already exists - Skipping...")
+            next
+          end
 
           device_platform = platform
 

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

@@ -6,9 +6,14 @@ module Fastlane
 
         # Team selection passed though FASTLANE_ITC_TEAM_ID and FASTLANE_ITC_TEAM_NAME environment variables
         # Prompts select team if multiple teams and none specified
-        UI.message("Login to App Store Connect (#{params[:username]})")
-        Spaceship::ConnectAPI.login(params[:username], use_portal: false, use_tunes: true)
-        UI.message("Login successful")
+        if (token = self.api_token(params))
+          UI.message("Using App Store Connect API token...")
+          Spaceship::ConnectAPI.token = token
+        else
+          UI.message("Login to App Store Connect (#{params[:username]})")
+          Spaceship::ConnectAPI.login(params[:username], use_portal: false, use_tunes: true, tunes_team_id: params[:team_id], team_name: params[:team_name])
+          UI.message("Login successful")
+        end
 
         app = Spaceship::ConnectAPI::App.find(params[:app_identifier])
         UI.user_error!("Couldn't find app with identifier #{params[:app_identifier]}") if app.nil?
@@ -73,6 +78,13 @@ module Fastlane
         UI.success("👼  Successfully pushed the new changelog to for #{edit_version.version_string}")
       end
 
+      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.from_json_file(params[:api_key_path]) if params[:api_key_path]
+        return api_token
+      end
+
       def self.default_changelog_path
         File.join(FastlaneCore::FastlaneFolder.path.to_s, 'changelog.txt')
       end
@@ -98,6 +110,21 @@ module Fastlane
         user ||= CredentialsManager::AppfileConfig.try_fetch_value(:apple_id)
 
         [
+          FastlaneCore::ConfigItem.new(key: :api_key_path,
+                                     env_name: "FL_SET_CHANGELOG_API_KEY_PATH",
+                                     description: "Path to your App Store Connect API Key JSON file (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-json-file)",
+                                     optional: true,
+                                     conflicting_options: [:api_key],
+                                     verify_block: proc do |value|
+                                       UI.user_error!("Couldn't find API key JSON file at path '#{value}'") unless File.exist?(value)
+                                     end),
+          FastlaneCore::ConfigItem.new(key: :api_key,
+                                     env_name: "FL_SET_CHANGELOG_API_KEY",
+                                     description: "Your App Store Connect API Key information (https://docs.fastlane.tools/app-store-connect-api/#use-return-value-and-pass-in-as-an-option)",
+                                     type: Hash,
+                                     optional: true,
+                                     sensitive: true,
+                                     conflicting_options: [:api_key_path]),
           FastlaneCore::ConfigItem.new(key: :app_identifier,
                                      short_option: "-a",
                                      env_name: "FASTLANE_APP_IDENTIFIER",
@@ -109,6 +136,7 @@ module Fastlane
                                      short_option: "-u",
                                      env_name: "FASTLANE_USERNAME",
                                      description: "Your Apple ID Username",
+                                     optional: true,
                                      default_value: user,
                                      default_value_dynamic: true),
           FastlaneCore::ConfigItem.new(key: :version,

data/fastlane/lib/fastlane/actions/slather.rb

@@ -272,8 +272,8 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :binary_basename,
                                        env_name: "FL_SLATHER_BINARY_BASENAME",
                                        description: "Basename of the binary file, this should match the name of your bundle excluding its extension (i.e. YourApp [for YourApp.app bundle])",
-                                       is_string: false,
-                                       default_value: false),
+                                       type: Array,
+                                       optional: true),
           FastlaneCore::ConfigItem.new(key: :binary_file,
                                        env_name: "FL_SLATHER_BINARY_FILE",
                                        description: "Binary file name to be used for code coverage",

data/fastlane/lib/fastlane/actions/spm.rb

@@ -11,6 +11,7 @@ module Fastlane
         cmd << "--disable-sandbox" if params[:disable_sandbox]
         cmd << "--verbose" if params[:verbose]
         cmd << params[:command] if package_commands.include?(params[:command])
+        cmd << "--enable-code-coverage" if params[:enable_code_coverage] && params[:command] == 'generate-xcodeproj'
         if params[:xcconfig]
           cmd << "--xcconfig-overrides #{params[:xcconfig]}"
         end
@@ -44,6 +45,11 @@ module Fastlane
                                        verify_block: proc do |value|
                                          UI.user_error!("Please pass a valid command. Use one of the following: #{available_commands.join(', ')}") unless available_commands.include?(value)
                                        end),
+          FastlaneCore::ConfigItem.new(key: :enable_code_coverage,
+                                       env_name: "FL_SPM_ENABLE_CODE_COVERAGE",
+                                       description: "Enables code coverage for the generated Xcode project when using the generate-xcodeproj command",
+                                       is_string: false,
+                                       optional: true),
           FastlaneCore::ConfigItem.new(key: :build_path,
                                        env_name: "FL_SPM_BUILD_PATH",
                                        description: "Specify build/cache directory [default: ./.build]",

data/fastlane/lib/fastlane/actions/update_fastlane.rb

@@ -45,25 +45,36 @@ module Fastlane
         end
 
         # suppress updater output - very noisy
-        Gem::DefaultUserInteraction.ui = Gem::SilentUI.new
+        Gem::DefaultUserInteraction.ui = Gem::SilentUI.new unless FastlaneCore::Globals.verbose?
 
         update_needed.each do |tool_info|
-          tool = tool_info[0]
+          tool = self.get_gem_name(tool_info)
           local_version = Gem::Version.new(highest_versions[tool].version)
           latest_official_version = FastlaneCore::UpdateChecker.fetch_latest(tool)
 
           UI.message("Updating #{tool} from #{local_version.to_s.yellow} to #{latest_official_version.to_s.yellow}... 🚀")
 
-          # Approximate_recommendation will create a string like "~> 0.10" from a version 0.10.0, e.g. one that is valid for versions >= 0.10 and <1.0
-          requirement_version = local_version.approximate_recommendation
-          updater.update_gem(tool, Gem::Requirement.new(requirement_version))
+          if Helper.homebrew?
+            Helper.backticks('brew upgrade fastlane')
+          else
+            # Approximate_recommendation will create a string like "~> 0.10" from a version 0.10.0, e.g. one that is valid for versions >= 0.10 and <1.0
+            requirement_version = local_version.approximate_recommendation
+            updater.update_gem(tool, Gem::Requirement.new(requirement_version))
+          end
 
           UI.success("Finished updating #{tool}")
         end
 
-        UI.message("Cleaning up old versions...")
-        cleaner.options[:args] = tools_to_update
-        cleaner.execute
+        unless Helper.homebrew?
+          UI.message("Cleaning up old versions...")
+          cleaner.options[:args] = tools_to_update
+          cleaner.execute
+        end
+
+        if FastlaneCore::FastlaneFolder.swift?
+          upgrader = SwiftRunnerUpgrader.new
+          upgrader.upgrade_if_needed!
+        end
 
         UI.message("fastlane.tools successfully updated! I will now restart myself... 😴")
 
@@ -71,6 +82,16 @@ module Fastlane
         exec("FL_NO_UPDATE=true #{$PROGRAM_NAME} #{ARGV.join(' ')}")
       end
 
+      def self.get_gem_name(tool_info)
+        if tool_info.kind_of?(Array)
+          return tool_info[0]
+        elsif tool_info.respond_to?(:name) # Gem::NameTuple in RubyGems >= 3.1.0
+          return tool_info.name
+        else
+          UI.crash!("Unknown gem update information returned from RubyGems. Please file a new issue for this... 🤷")
+        end
+      end
+
       def self.description
         "Makes sure fastlane-tools are up-to-date when running fastlane"
       end

data/fastlane/lib/fastlane/actions/upload_to_app_store.rb

@@ -9,9 +9,9 @@ module Fastlane
 
         begin
           config.load_configuration_file("Deliverfile")
-          config[:screenshots_path] = Actions.lane_context[SharedValues::SNAPSHOT_SCREENSHOTS_PATH] if Actions.lane_context[SharedValues::SNAPSHOT_SCREENSHOTS_PATH]
-          config[:ipa] = Actions.lane_context[SharedValues::IPA_OUTPUT_PATH] if Actions.lane_context[SharedValues::IPA_OUTPUT_PATH]
-          config[:pkg] = Actions.lane_context[SharedValues::PKG_OUTPUT_PATH] if Actions.lane_context[SharedValues::PKG_OUTPUT_PATH]
+          config[:screenshots_path] ||= Actions.lane_context[SharedValues::SNAPSHOT_SCREENSHOTS_PATH] if Actions.lane_context[SharedValues::SNAPSHOT_SCREENSHOTS_PATH]
+          config[:ipa] ||= Actions.lane_context[SharedValues::IPA_OUTPUT_PATH] if Actions.lane_context[SharedValues::IPA_OUTPUT_PATH]
+          config[:pkg] ||= Actions.lane_context[SharedValues::PKG_OUTPUT_PATH] if Actions.lane_context[SharedValues::PKG_OUTPUT_PATH]
           config[:api_key] ||= Actions.lane_context[SharedValues::APP_STORE_CONNECT_API_KEY]
 
           return config if Helper.test?

data/fastlane/lib/fastlane/cli_tools_distributor.rb

@@ -123,9 +123,9 @@ module Fastlane
       end
 
       # Since loading dotenv should respect additional environments passed using
-      # --env, we must extrat the arguments out of ARGV and process them before
+      # --env, we must extract the arguments out of ARGV and process them before
       # calling into commander. This is required since the ENV must be configured
-      # before running any other commands in order to correclty respect variables
+      # before running any other commands in order to correctly respect variables
       # like FASTLANE_HIDE_CHANGELOG and FASTLANE_DISABLE_COLORS
       def load_dot_env
         env_cl_param = lambda do

data/fastlane/lib/fastlane/fast_file.rb

@@ -259,11 +259,20 @@ module Fastlane
       return return_value
     end
 
+    def find_tag(folder: nil, version: nil, remote: false)
+      req = Gem::Requirement.new(version)
+      all_tags = get_tags(folder: folder, remote: remote)
+
+      return all_tags.select { |t| req =~ FastlaneCore::TagVersion.new(t) }.last
+    end
+
     # @param url [String] The git URL to clone the repository from
     # @param branch [String] The branch to checkout in the repository
     # @param path [String] The path to the Fastfile
     # @param version [String, Array] Version requirement for repo tags
-    def import_from_git(url: nil, branch: 'HEAD', path: 'fastlane/Fastfile', version: nil, dependencies: [])
+    # @param dependencies [Array] An optional array of additional Fastfiles in the repository
+    # @param cache_path [String] An optional path to a directory where the repository should be cloned into
+    def import_from_git(url: nil, branch: 'HEAD', path: 'fastlane/Fastfile', version: nil, dependencies: [], cache_path: nil) # rubocop:disable Metrics/PerceivedComplexity
       UI.user_error!("Please pass a path to the `import_from_git` action") if url.to_s.length == 0
 
       Actions.execute_action('import_from_git') do
@@ -271,41 +280,75 @@ module Fastlane
 
         action_launched('import_from_git')
 
+        is_eligible_for_caching = !version.nil? && !cache_path.nil?
+
+        UI.message("Eligible for caching") if is_eligible_for_caching
+
         # Checkout the repo
         repo_name = url.split("/").last
         checkout_param = branch
 
-        Dir.mktmpdir("fl_clone") do |tmp_path|
-          clone_folder = File.join(tmp_path, repo_name)
+        import_block = proc do |target_path|
+          clone_folder = File.join(target_path, repo_name)
 
           branch_option = "--branch #{branch}" if branch != 'HEAD'
 
           checkout_dependencies = dependencies.map(&:shellescape).join(" ")
 
-          checkout_path = "#{path.shellescape} #{checkout_dependencies}"
-
-          UI.message("Cloning remote git repo...")
-          Helper.with_env_values('GIT_TERMINAL_PROMPT' => '0') do
-            Actions.sh("git clone #{url.shellescape} #{clone_folder.shellescape} --depth 1 -n #{branch_option}")
+          # If the current call is eligible for caching, we check out all the
+          # files and directories. If not, we only check out the specified
+          # `path` and `dependencies`.
+          checkout_path = is_eligible_for_caching ? "" : "#{path.shellescape} #{checkout_dependencies}"
+
+          if Dir[clone_folder].empty?
+            UI.message("Cloning remote git repo...")
+            Helper.with_env_values('GIT_TERMINAL_PROMPT' => '0') do
+              # When using cached clones, we need the entire repository history
+              # so we can switch between tags or branches instantly, or else,
+              # it would defeat the caching's purpose.
+              depth = is_eligible_for_caching ? "" : "--depth 1"
+
+              Actions.sh("git clone #{url.shellescape} #{clone_folder.shellescape} #{depth} --no-checkout #{branch_option}")
+            end
           end
 
           unless version.nil?
-            req = Gem::Requirement.new(version)
-            all_tags = fetch_remote_tags(folder: clone_folder)
-            checkout_param = all_tags.select { |t| req =~ FastlaneCore::TagVersion.new(t) }.last
+            if is_eligible_for_caching
+              checkout_param = find_tag(folder: clone_folder, version: version, remote: false)
+
+              if checkout_param.nil?
+                # Update the repo and try again before failing
+                UI.message("Updating git repo...")
+                Helper.with_env_values('GIT_TERMINAL_PROMPT' => '0') do
+                  Actions.sh("cd #{clone_folder.shellescape} && git checkout #{branch} && git reset --hard && git pull --all")
+                end
+
+                checkout_param = find_tag(folder: clone_folder, version: version, remote: false)
+              else
+                UI.message("Found tag #{checkout_param}. No git repo update needed.")
+              end
+            else
+              checkout_param = find_tag(folder: clone_folder, version: version, remote: true)
+            end
+
             UI.user_error!("No tag found matching #{version.inspect}") if checkout_param.nil?
           end
 
           Actions.sh("cd #{clone_folder.shellescape} && git checkout #{checkout_param.shellescape} #{checkout_path}")
 
-          # We also want to check out all the local actions of this fastlane setup
-          containing = path.split(File::SEPARATOR)[0..-2]
-          containing = "." if containing.count == 0
-          actions_folder = File.join(containing, "actions")
-          begin
-            Actions.sh("cd #{clone_folder.shellescape} && git checkout #{checkout_param.shellescape} #{actions_folder.shellescape}")
-          rescue
-            # We don't care about a failure here, as local actions are optional
+          # Knowing that we check out all the files and directories when the
+          # current call is eligible for caching, we don't need to also
+          # explicitly check out the "actions" directory.
+          unless is_eligible_for_caching
+            # We also want to check out all the local actions of this fastlane setup
+            containing = path.split(File::SEPARATOR)[0..-2]
+            containing = "." if containing.count == 0
+            actions_folder = File.join(containing, "actions")
+            begin
+              Actions.sh("cd #{clone_folder.shellescape} && git checkout #{checkout_param.shellescape} #{actions_folder.shellescape}")
+            rescue
+              # We don't care about a failure here, as local actions are optional
+            end
           end
 
           return_value = nil
@@ -320,6 +363,12 @@ module Fastlane
 
           return return_value
         end
+
+        if is_eligible_for_caching
+          import_block.call(File.expand_path(cache_path))
+        else
+          Dir.mktmpdir("fl_clone", &import_block)
+        end
       end
     end
 
@@ -327,10 +376,12 @@ module Fastlane
     # @!group Versioning helpers
     #####################################################
 
-    def fetch_remote_tags(folder: nil)
-      UI.message("Fetching remote git tags...")
-      Helper.with_env_values('GIT_TERMINAL_PROMPT' => '0') do
-        Actions.sh("cd #{folder.shellescape} && git fetch --all --tags -q")
+    def get_tags(folder: nil, remote: false)
+      if remote
+        UI.message("Fetching remote git tags...")
+        Helper.with_env_values('GIT_TERMINAL_PROMPT' => '0') do
+          Actions.sh("cd #{folder.shellescape} && git fetch --all --tags -q")
+        end
       end
 
       # Fetch all possible tags

data/fastlane/lib/fastlane/features.rb

@@ -1,4 +1,4 @@
-# Use this file as the place to register Feature switches for the fastlan_core project
+# Use this file as the place to register Feature switches for the fastlane_core project
 
 # FastlaneCore::Feature.register(env_var: 'YOUR_FEATURE_SWITCH_ENV_VAR',
 #                            description: 'Describe what this feature switch controls')

data/fastlane/lib/fastlane/plugins/template/.rubocop.yml

@@ -41,6 +41,7 @@ Require/MissingRequireStatement:
   - "**/spec/**/*.rb"
   - "**/spec_helper.rb"
   - spaceship/lib/spaceship/babosa_fix.rb
+  - fastlane_core/lib/fastlane_core/ui/disable_colors.rb
   - "**/Fastfile"
   - "**/*.gemspec"
   - rakelib/**/*
@@ -179,6 +180,7 @@ Style/MethodCallWithArgsParentheses:
   - private_lane
   - platform
   - to
+  - not_to
   - describe
   - it
   - be