fastlane 2.159.0 → 2.164.0

data/fastlane/lib/fastlane/actions/ensure_git_status_clean.rb

@@ -7,7 +7,13 @@ module Fastlane
     # Raises an exception and stop the lane execution if the repo is not in a clean state
     class EnsureGitStatusCleanAction < Action
       def self.run(params)
-        repo_status = Actions.sh("git status --porcelain")
+        if params[:ignored]
+          ignored_file = params[:ignored]
+          repo_status = Actions.sh("git status --porcelain --ignored #{ignored_file}")
+        else
+          repo_status = Actions.sh("git status --porcelain")
+        end
+
         repo_clean = repo_status.empty?
 
         if repo_clean
@@ -65,7 +71,12 @@ module Fastlane
                                        description: "The flag whether to show the git diff if the repo is dirty",
                                        optional: true,
                                        default_value: false,
-                                       is_string: false)
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :ignored,
+                                       env_name: "FL_ENSURE_GIT_STATUS_CLEAN_IGNORED_FILE",
+                                       description: "The flag whether to ignore file the git status if the repo is dirty",
+                                       optional: true,
+                                       is_string: true)
         ]
       end
 

data/fastlane/lib/fastlane/actions/get_certificates.rb

@@ -13,6 +13,7 @@ module Fastlane
 
         begin
           Cert.config = params # we alread have the finished config
+          Cert.config[:api_key] ||= Actions.lane_context[SharedValues::APP_STORE_CONNECT_API_KEY]
 
           Cert::Runner.new.launch
           cert_file_path = ENV["CER_FILE_PATH"]

data/fastlane/lib/fastlane/actions/get_provisioning_profile.rb

@@ -15,6 +15,7 @@ module Fastlane
         require 'credentials_manager/appfile_config'
 
         Sigh.config = values # we already have the finished config
+        Sigh.config[:api_key] ||= Actions.lane_context[SharedValues::APP_STORE_CONNECT_API_KEY]
 
         path = Sigh::Manager.start
 

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

@@ -37,6 +37,21 @@ module Fastlane
         user ||= CredentialsManager::AppfileConfig.try_fetch_value(:apple_id)
 
         [
+          FastlaneCore::ConfigItem.new(key: :api_key_path,
+                                       env_name: "APPSTORE_BUILD_NUMBER_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: "APPSTORE_BUILD_NUMBER_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: :live,
                                        short_option: "-l",
                                        env_name: "CURRENT_BUILD_NUMBER_LIVE",

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

@@ -11,23 +11,39 @@ module Fastlane
         require 'spaceship'
 
         name = params[:name]
+        platform = params[:platform]
         udid = params[:udid]
 
-        credentials = CredentialsManager::AccountManager.new(user: params[:username])
-        Spaceship.login(credentials.user, credentials.password)
-        Spaceship.select_team
+        platform = Spaceship::ConnectAPI::BundleIdPlatform.map(platform)
+
+        if (token = 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]})")
+          credentials = CredentialsManager::AccountManager.new(user: params[:username])
+          Spaceship::ConnectAPI.login(credentials.user, credentials.password, use_portal: true, use_tunes: false)
+          UI.message("Login successful")
+        end
 
         begin
-          Spaceship::Device.create!(name: name, udid: udid)
+          Spaceship::ConnectAPI::Device.create(name: name, platform: platform, udid: udid)
         rescue => ex
           UI.error(ex.to_s)
-          UI.crash!("Failed to register new device (name: #{name}, UDID: #{udid})")
+          UI.crash!("Failed to register new device (name: #{name}, platform: #{platform}, UDID: #{udid})")
         end
 
         UI.success("Successfully registered new device")
         return udid
       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.description
         "Registers a new device to the Apple Dev Portal"
       end
@@ -35,14 +51,38 @@ module Fastlane
       def self.available_options
         user = CredentialsManager::AppfileConfig.try_fetch_value(:apple_dev_portal_id)
         user ||= CredentialsManager::AppfileConfig.try_fetch_value(:apple_id)
+        platform = Actions.lane_context[Actions::SharedValues::PLATFORM_NAME].to_s
 
         [
           FastlaneCore::ConfigItem.new(key: :name,
                                        env_name: "FL_REGISTER_DEVICE_NAME",
                                        description: "Provide the name of the device to register as"),
+          FastlaneCore::ConfigItem.new(key: :platform,
+                                       env_name: "FL_REGISTER_DEVICE_PLATFORM",
+                                       description: "Provide the platform of the device to register as (ios, mac)",
+                                       optional: true,
+                                       default_value: platform.empty? ? "ios" : platform,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("The platform can only be ios or mac") unless %('ios', 'mac').include?(value)
+                                       end),
           FastlaneCore::ConfigItem.new(key: :udid,
                                        env_name: "FL_REGISTER_DEVICE_UDID",
                                        description: "Provide the UDID of the device to register as"),
+          FastlaneCore::ConfigItem.new(key: :api_key_path,
+                                       env_name: "FL_REGISTER_DEVICE_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_REGISTER_DEVICE_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: :team_id,
                                      env_name: "REGISTER_DEVICE_TEAM_ID",
                                      code_gen_sensitive: true,
@@ -66,6 +106,7 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :username,
                                        env_name: "DELIVER_USER",
                                        description: "Optional: Your Apple ID",
+                                       optional: true,
                                        default_value: user,
                                        default_value_dynamic: true)
         ]

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

@@ -12,6 +12,8 @@ module Fastlane
       end
 
       def self.run(params)
+        platform = Spaceship::ConnectAPI::BundleIdPlatform.map(params[:platform])
+
         if params[:devices]
           new_devices = params[:devices].map do |name, udid|
             [udid, name]
@@ -37,40 +39,57 @@ module Fastlane
         end
 
         require 'spaceship'
-        credentials = CredentialsManager::AccountManager.new(user: params[:username])
-        Spaceship.login(credentials.user, credentials.password)
-        Spaceship.select_team
-
-        UI.message("Fetching list of currently registered devices...")
-        all_platforms = Set[params[:platform]]
-        new_devices.each do |device|
-          next if device[2].nil?
-          all_platforms.add(device[2])
+        if (token = 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]})")
+          credentials = CredentialsManager::AccountManager.new(user: params[:username])
+          Spaceship::ConnectAPI.login(credentials.user, credentials.password, use_portal: true, use_tunes: false)
+          UI.message("Login successful")
         end
-        supported_platforms = all_platforms.select { |platform| self.is_supported?(platform.to_sym) }
 
-        existing_devices = supported_platforms.flat_map { |platform| Spaceship::Device.all(mac: platform == "mac") }
+        UI.message("Fetching list of currently registered devices...")
+        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
 
           device_platform_supported = !device[2].nil? && self.is_supported?(device[2].to_sym)
-          mac = (device_platform_supported ? device[2] : params[:platform]) == "mac"
+          if device_platform_supported
+            if device[2] == "mac"
+              device_platform = Spaceship::ConnectAPI::BundleIdPlatform::MAC_OS
+            else
+              device_platform = Spaceship::ConnectAPI::BundleIdPlatform::IOS
+            end
+          end
 
-          try_create_device(name: device[1], udid: device[0], mac: mac)
+          try_create_device(name: device[1], platform: device_platform, udid: device[0])
         end
 
         UI.success("Successfully registered new devices.")
         return device_objs
       end
 
-      def self.try_create_device(name: nil, udid: nil, mac: false)
-        Spaceship::Device.create!(name: name, udid: udid, mac: mac)
+      def self.try_create_device(name: nil, platform: nil, udid: nil)
+        Spaceship::ConnectAPI::Device.create(name: name, platform: platform, udid: udid)
       rescue => ex
         UI.error(ex.to_s)
         UI.crash!("Failed to register new device (name: #{name}, UDID: #{udid})")
       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
+
       #####################################################
       # @!group Documentation
       #####################################################
@@ -98,6 +117,21 @@ module Fastlane
                                        verify_block: proc do |value|
                                          UI.user_error!("Could not find file '#{value}'") unless File.exist?(value)
                                        end),
+          FastlaneCore::ConfigItem.new(key: :api_key_path,
+                                       env_name: "FL_REGISTER_DEVICES_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_REGISTER_DEVICES_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: :team_id,
                                      env_name: "REGISTER_DEVICES_TEAM_ID",
                                      code_gen_sensitive: true,

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

@@ -10,6 +10,7 @@ module Fastlane
         require 'match'
 
         params.load_configuration_file("Matchfile")
+        params[:api_key] ||= Actions.lane_context[SharedValues::APP_STORE_CONNECT_API_KEY]
         Match::Runner.new.run(params)
 
         define_profile_type(params)

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

@@ -12,6 +12,7 @@ module Fastlane
           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?
           Deliver::Runner.new(config).run
@@ -26,7 +27,7 @@ module Fastlane
         [
           "Using _upload_to_app_store_ after _build_app_ and _capture_screenshots_ will automatically upload the latest ipa and screenshots with no other configuration.",
           "",
-          "If you don't want a PDF report for App Store builds, use the `:force` option.",
+          "If you don't want to verify an HTML preview for App Store builds, use the `:force` option.",
           "This is useful when running _fastlane_ on your Continuous Integration server:",
           "`_upload_to_app_store_(force: true)`",
           "If your account is on multiple teams and you need to tell the `iTMSTransporter` which 'provider' to use, you can set the `:itc_provider` option to pass this info."
@@ -50,7 +51,7 @@ module Fastlane
       def self.example_code
         [
           'upload_to_app_store(
-            force: true, # Set to true to skip PDF verification
+            force: true, # Set to true to skip verification of HTML preview
             itc_provider: "abcde12345" # pass a specific value to the iTMSTransporter -itc_provider option
           )',
           'deliver   # alias for "upload_to_app_store"',

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