fastlane_hotfix 2.165.0

data/fastlane/lib/fastlane/environment_printer.rb

@@ -0,0 +1,303 @@
+module Fastlane
+  class EnvironmentPrinter
+    def self.output
+      env_info = get
+
+      # Remove sensitive option values
+      FastlaneCore::Configuration.sensitive_strings.compact.each do |sensitive_element|
+        env_info.gsub!(sensitive_element, "#########")
+      end
+
+      puts(env_info)
+      UI.important("Take notice that this output may contain sensitive information, or simply information that you don't want to make public.")
+      if FastlaneCore::Helper.mac? && UI.interactive? && UI.confirm("🙄  Wow, that's a lot of markdown text... should fastlane put it into your clipboard, so you can easily paste it on GitHub?")
+        copy_to_clipboard(env_info)
+        UI.success("Successfully copied markdown into your clipboard 🎨")
+      end
+      UI.success("Open https://github.com/fastlane/fastlane/issues/new to submit a new issue ✅")
+    end
+
+    def self.get
+      UI.important("Generating fastlane environment output, this might take a few seconds...")
+      require "fastlane/markdown_table_formatter"
+      env_output = ""
+      env_output << print_system_environment
+      env_output << print_system_locale
+      env_output << print_fastlane_files
+      env_output << print_loaded_fastlane_gems
+      env_output << print_loaded_plugins
+      env_output << print_loaded_gems
+      env_output << print_date
+
+      # Adding title
+      status = (env_output.include?("🚫") ? "🚫" : "✅")
+      env_header = "<details><summary>#{status} fastlane environment #{status}</summary>\n\n"
+      env_tail = "</details>"
+      final_output = ""
+
+      if FastlaneCore::Globals.captured_output?
+        final_output << "### Captured Output\n\n"
+        final_output << "Command Used: `#{ARGV.join(' ')}`\n"
+        final_output << "<details><summary>Output/Log</summary>\n\n```\n\n#{FastlaneCore::Globals.captured_output}\n\n```\n\n</details>\n\n"
+      end
+
+      final_output << env_header + env_output + env_tail
+    end
+
+    def self.print_date
+      date = Time.now.strftime("%Y-%m-%d")
+      "\n*generated on:* **#{date}**\n"
+    end
+
+    def self.print_loaded_plugins
+      env_output =  "### Loaded fastlane plugins:\n"
+      env_output << "\n"
+      plugin_manager = Fastlane::PluginManager.new
+      plugin_manager.load_plugins(print_table: false)
+
+      if plugin_manager.available_plugins.length <= 0
+        env_output << "**No plugins Loaded**\n"
+      else
+        table = ""
+        table << "| Plugin | Version | Update-Status |\n"
+        table << "|--------|---------|\n"
+        plugin_manager.available_plugins.each do |plugin|
+          begin
+            installed_version = Fastlane::ActionCollector.determine_version(plugin)
+            latest_version = FastlaneCore::UpdateChecker.fetch_latest(plugin)
+            if Gem::Version.new(installed_version) == Gem::Version.new(latest_version)
+              update_status = "✅ Up-To-Date"
+            else
+              update_status = "🚫 Update available"
+            end
+          rescue
+            update_status = "💥 Check failed"
+          end
+          table << "| #{plugin} | #{installed_version} | #{update_status} |\n"
+        end
+
+        rendered_table = MarkdownTableFormatter.new(table)
+        env_output << rendered_table.to_md
+      end
+
+      env_output << "\n\n"
+      env_output
+    end
+
+    # We have this as a separate method, as this has to be handled
+    # slightly differently, depending on how fastlane is being called
+    def self.gems_to_check
+      if Helper.contained_fastlane?
+        Gem::Specification
+      else
+        Gem.loaded_specs.values
+      end
+    end
+
+    def self.print_loaded_fastlane_gems
+      # fastlanes internal gems
+      env_output = "### fastlane gems\n\n"
+      table = ""
+      table << "| Gem | Version | Update-Status |\n"
+      table << "|-----|---------|------------|\n"
+      fastlane_tools = Fastlane::TOOLS + [:fastlane_core, :credentials_manager]
+
+      gems_to_check.each do |current_gem|
+        update_status = "N/A"
+
+        next unless fastlane_tools.include?(current_gem.name.to_sym)
+        begin
+          latest_version = FastlaneCore::UpdateChecker.fetch_latest(current_gem.name)
+          if Gem::Version.new(current_gem.version) >= Gem::Version.new(latest_version)
+            update_status = "✅ Up-To-Date"
+          else
+            update_status = "🚫 Update available"
+          end
+        rescue
+          update_status = "💥 Check failed"
+        end
+        table << "| #{current_gem.name} | #{current_gem.version} | #{update_status} |\n"
+      end
+
+      rendered_table = MarkdownTableFormatter.new(table)
+      env_output << rendered_table.to_md
+
+      env_output << "\n\n"
+
+      return env_output
+    end
+
+    def self.print_loaded_gems
+      env_output = "<details>"
+      env_output << "<summary><b>Loaded gems</b></summary>\n\n"
+
+      table = "| Gem | Version |\n"
+      table << "|-----|---------|\n"
+      gems_to_check.each do |current_gem|
+        unless Fastlane::TOOLS.include?(current_gem.name.to_sym)
+          table << "| #{current_gem.name} | #{current_gem.version} |\n"
+        end
+      end
+      rendered_table = MarkdownTableFormatter.new(table)
+
+      env_output << rendered_table.to_md
+      env_output << "</details>\n\n"
+      return env_output
+    end
+
+    def self.print_system_locale
+      env_output = "### System Locale\n\n"
+      found_one = false
+      env_table = ""
+      ["LANG", "LC_ALL", "LANGUAGE"].each do |e|
+        env_icon = "🚫"
+        if ENV[e] && ENV[e].end_with?("UTF-8")
+          env_icon = "✅"
+          found_one = true
+        end
+        if ENV[e].nil?
+          env_icon = ""
+        end
+        env_table << "| #{e} | #{ENV[e]} | #{env_icon} |\n"
+      end
+      if !found_one
+        table = "| Error |\n"
+        table << "|-----|\n"
+        table << "| No Locale with UTF8 found 🚫|\n"
+      else
+        table = "| Variable | Value |  |\n"
+        table << "|-----|---------|----|\n"
+        table << env_table
+      end
+      rendered_table = MarkdownTableFormatter.new(table)
+      env_output << rendered_table.to_md
+      env_output << "\n\n"
+    end
+
+    def self.print_system_environment
+      require "openssl"
+
+      env_output = "### Stack\n\n"
+      product, version, build = "Unknown"
+      os_version = "UNKNOWN"
+
+      if Helper.mac?
+        product, version, build = `sw_vers`.strip.split("\n").map { |line| line.split(':').last.strip }
+        os_version = version
+      end
+
+      if Helper.linux?
+        # this should work on pretty much all linux distros
+        os_version = `uname -a`.strip
+        version = ""
+        build = `uname -r`.strip
+        product = `cat /etc/issue.net`.strip
+
+        distro_guesser = {
+          fedora: "/etc/fedora-release",
+          debian_based: "/etc/debian_version",
+          suse: "/etc/SUSE-release",
+          mandrake: "/etc/mandrake-release"
+        }
+
+        distro_guesser.each do |dist, vers|
+          os_version = "#{dist} " + File.read(vers).strip if File.exist?(vers)
+          version = os_version
+        end
+      end
+
+      table_content = {
+        "fastlane" => Fastlane::VERSION,
+        "OS" => os_version,
+        "Ruby" => RUBY_VERSION,
+        "Bundler?" => Helper.bundler?,
+        "Git" => git_version,
+        "Installation Source" => anonymized_path($PROGRAM_NAME),
+        "Host" => "#{product} #{version} (#{build})",
+        "Ruby Lib Dir" => anonymized_path(RbConfig::CONFIG['libdir']),
+        "OpenSSL Version" => OpenSSL::OPENSSL_VERSION,
+        "Is contained" => Helper.contained_fastlane?.to_s,
+        "Is homebrew" => Helper.homebrew?.to_s,
+        "Is installed via Fabric.app" => Helper.mac_app?.to_s
+      }
+
+      if Helper.mac?
+        table_content["Xcode Path"] = anonymized_path(Helper.xcode_path)
+        begin
+          table_content["Xcode Version"] = Helper.xcode_version
+        rescue => ex
+          UI.error(ex)
+          UI.error("Could not get Xcode Version")
+        end
+      end
+
+      table = ["| Key | Value |"]
+      table += table_content.collect { |k, v| "| #{k} | #{v} |" }
+
+      begin
+        rendered_table = MarkdownTableFormatter.new(table.join("\n"))
+        env_output << rendered_table.to_md
+      rescue => ex
+        UI.error(ex)
+        UI.error("Error rendering markdown table using the following text:")
+        UI.message(table.join("\n"))
+        env_output << table.join("\n")
+      end
+
+      env_output << "\n\n"
+      env_output
+    end
+
+    def self.print_fastlane_files
+      env_output = "### fastlane files:\n\n"
+
+      fastlane_path = FastlaneCore::FastlaneFolder.fastfile_path
+
+      if fastlane_path && File.exist?(fastlane_path)
+        env_output << "<details>"
+        env_output << "<summary>`#{fastlane_path}`</summary>\n"
+        env_output << "\n"
+        env_output << "```ruby\n"
+        env_output <<  File.read(fastlane_path, encoding: "utf-8")
+        env_output <<  "\n```\n"
+        env_output << "</details>"
+      else
+        env_output << "**No Fastfile found**\n"
+      end
+      env_output << "\n\n"
+
+      appfile_path = CredentialsManager::AppfileConfig.default_path
+      if appfile_path && File.exist?(appfile_path)
+        env_output << "<details>"
+        env_output << "<summary>`#{appfile_path}`</summary>\n"
+        env_output << "\n"
+        env_output << "```ruby\n"
+        env_output <<  File.read(appfile_path, encoding: "utf-8")
+        env_output <<  "\n```\n"
+        env_output << "</details>"
+      else
+        env_output << "**No Appfile found**\n"
+      end
+      env_output << "\n\n"
+      env_output
+    end
+
+    def self.anonymized_path(path, home = ENV['HOME'])
+      return home ? path.gsub(%r{^#{home}(?=/(.*)|$)}, '~\2') : path
+    end
+
+    # Copy a given string into the clipboard
+    # Make sure to ask the user first, as some people don't
+    # use a clipboard manager, so they might lose something important
+    def self.copy_to_clipboard(string)
+      require 'open3'
+      Open3.popen3('pbcopy') { |input, _, _| input << string }
+    end
+
+    def self.git_version
+      return `git --version`.strip.split("\n").first
+    rescue
+      return "not found"
+    end
+  end
+end

data/fastlane/lib/fastlane/erb_template_helper.rb

@@ -0,0 +1,30 @@
+module Fastlane
+  class ErbTemplateHelper
+    require "erb"
+    def self.load(template_name)
+      path = "#{Fastlane::ROOT}/lib/assets/#{template_name}.erb"
+      load_from_path(path)
+    end
+
+    def self.load_from_path(template_filepath)
+      unless File.exist?(template_filepath)
+        UI.user_error!("Could not find template at path '#{template_filepath}'")
+      end
+      File.read(template_filepath)
+    end
+
+    def self.render(template, template_vars_hash, trim_mode = nil)
+      Fastlane::ErbalT.new(template_vars_hash, trim_mode).render(template)
+    end
+  end
+  class ErbalT < OpenStruct
+    def initialize(hash, trim_mode = nil)
+      super(hash)
+      @trim_mode = trim_mode
+    end
+
+    def render(template)
+      ERB.new(template, nil, @trim_mode).result(binding)
+    end
+  end
+end

data/fastlane/lib/fastlane/fast_file.rb

@@ -0,0 +1,439 @@
+require "rubygems/requirement"
+
+module Fastlane
+  class FastFile
+    # Stores all relevant information from the currently running process
+    attr_accessor :runner
+
+    # the platform in which we're currently in when parsing the Fastfile
+    # This is used to identify the platform in which the lane is in
+    attr_accessor :current_platform
+
+    SharedValues = Fastlane::Actions::SharedValues
+
+    # @return The runner which can be executed to trigger the given actions
+    def initialize(path = nil)
+      return unless (path || '').length > 0
+      UI.user_error!("Could not find Fastfile at path '#{path}'") unless File.exist?(path)
+      @path = File.expand_path(path)
+      content = File.read(path, encoding: "utf-8")
+
+      # From https://github.com/orta/danger/blob/master/lib/danger/Dangerfile.rb
+      if content.tr!('“”‘’‛', %(""'''))
+        UI.error("Your #{File.basename(path)} has had smart quotes sanitised. " \
+                'To avoid issues in the future, you should not use ' \
+                'TextEdit for editing it. If you are not using TextEdit, ' \
+                'you should turn off smart quotes in your editor of choice.')
+      end
+
+      content.scan(/^\s*require ["'](.*?)["']/).each do |current|
+        gem_name = current.last
+        next if gem_name.include?(".") # these are local gems
+
+        begin
+          require(gem_name)
+        rescue LoadError
+          UI.important("You have required a gem, if this is a third party gem, please use `fastlane_require '#{gem_name}'` to ensure the gem is installed locally.")
+        end
+      end
+
+      parse(content, @path)
+    end
+
+    def parsing_binding
+      binding
+    end
+
+    def parse(data, path = nil)
+      @runner ||= Runner.new
+
+      Dir.chdir(FastlaneCore::FastlaneFolder.path || Dir.pwd) do # context: fastlane subfolder
+        # create nice path that we want to print in case of some problem
+        relative_path = path.nil? ? '(eval)' : Pathname.new(path).relative_path_from(Pathname.new(Dir.pwd)).to_s
+
+        begin
+          # We have to use #get_binding method, because some test files defines method called `path` (for example SwitcherFastfile)
+          # and local variable has higher priority, so it causes to remove content of original Fastfile for example. With #get_binding
+          # is this always clear and safe to declare any local variables we want, because the eval function uses the instance scope
+          # instead of local.
+
+          # rubocop:disable Security/Eval
+          eval(data, parsing_binding, relative_path) # using eval is ok for this case
+          # rubocop:enable Security/Eval
+        rescue SyntaxError => ex
+          match = ex.to_s.match(/#{Regexp.escape(relative_path)}:(\d+)/)
+          if match
+            line = match[1]
+            UI.content_error(data, line)
+            UI.user_error!("Syntax error in your Fastfile on line #{line}: #{ex}")
+          else
+            UI.user_error!("Syntax error in your Fastfile: #{ex}")
+          end
+        end
+      end
+
+      self
+    end
+
+    #####################################################
+    # @!group DSL
+    #####################################################
+
+    # User defines a new lane
+    def lane(lane_name, &block)
+      UI.user_error!("You have to pass a block using 'do' for lane '#{lane_name}'. Make sure you read the docs on GitHub.") unless block
+
+      self.runner.add_lane(Lane.new(platform: self.current_platform,
+                                       block: block,
+                                 description: desc_collection,
+                                        name: lane_name,
+                                  is_private: false))
+
+      @desc_collection = nil # reset the collected description again for the next lane
+    end
+
+    # User defines a new private lane, which can't be called from the CLI
+    def private_lane(lane_name, &block)
+      UI.user_error!("You have to pass a block using 'do' for lane '#{lane_name}'. Make sure you read the docs on GitHub.") unless block
+
+      self.runner.add_lane(Lane.new(platform: self.current_platform,
+                                       block: block,
+                                 description: desc_collection,
+                                        name: lane_name,
+                                  is_private: true))
+
+      @desc_collection = nil # reset the collected description again for the next lane
+    end
+
+    # User defines a lane that can overwrite existing lanes. Useful when importing a Fastfile
+    def override_lane(lane_name, &block)
+      UI.user_error!("You have to pass a block using 'do' for lane '#{lane_name}'. Make sure you read the docs on GitHub.") unless block
+
+      self.runner.add_lane(Lane.new(platform: self.current_platform,
+                                       block: block,
+                                 description: desc_collection,
+                                        name: lane_name,
+                                  is_private: false), true)
+
+      @desc_collection = nil # reset the collected description again for the next lane
+    end
+
+    # User defines a platform block
+    def platform(platform_name)
+      SupportedPlatforms.verify!(platform_name)
+
+      self.current_platform = platform_name
+
+      yield
+
+      self.current_platform = nil
+    end
+
+    # Is executed before each test run
+    def before_all(&block)
+      @runner.set_before_all(@current_platform, block)
+    end
+
+    # Is executed before each lane
+    def before_each(&block)
+      @runner.set_before_each(@current_platform, block)
+    end
+
+    # Is executed after each test run
+    def after_all(&block)
+      @runner.set_after_all(@current_platform, block)
+    end
+
+    # Is executed before each lane
+    def after_each(&block)
+      @runner.set_after_each(@current_platform, block)
+    end
+
+    # Is executed if an error occurred during fastlane execution
+    def error(&block)
+      @runner.set_error(@current_platform, block)
+    end
+
+    # Is used to look if the method is implemented as an action
+    def method_missing(method_sym, *arguments, &_block)
+      self.runner.trigger_action_by_name(method_sym, nil, false, *arguments)
+    end
+
+    #####################################################
+    # @!group Other things
+    #####################################################
+
+    # Is the given key a platform block or a lane?
+    def is_platform_block?(key)
+      UI.crash!('No key given') unless key
+
+      return false if self.runner.lanes.fetch(nil, {}).fetch(key.to_sym, nil)
+      return true if self.runner.lanes[key.to_sym].kind_of?(Hash)
+
+      if key.to_sym == :update
+        # The user ran `fastlane update`, instead of `fastlane update_fastlane`
+        # We're gonna be nice and understand what the user is trying to do
+        require 'fastlane/one_off'
+        Fastlane::OneOff.run(action: "update_fastlane", parameters: {})
+      else
+        UI.user_error!("Could not find '#{key}'. Available lanes: #{self.runner.available_lanes.join(', ')}")
+      end
+    end
+
+    def actions_path(path)
+      UI.crash!("Path '#{path}' not found!") unless File.directory?(path)
+
+      Actions.load_external_actions(path)
+    end
+
+    # Execute shell command
+    # Accepts arguments with with and without the command named keyword so that sh
+    # behaves like other actions with named keywords
+    # https://github.com/fastlane/fastlane/issues/14930
+    #
+    # Example:
+    #  sh("ls")
+    #  sh("ls", log: false)
+    #  sh(command: "ls")
+    #  sh(command: "ls", step_name: "listing the files")
+    #  sh(command: "ls", log: false)
+    def sh(*args, &b)
+      # First accepts hash (or named keywords) like other actions
+      # Otherwise uses sh method that doesn't have an interface like an action
+      if args.count == 1 && args.first.kind_of?(Hash)
+        hash = args.first
+        command = hash.delete(:command)
+
+        raise ArgumentError, "sh requires :command keyword in argument" if command.nil?
+
+        new_args = [*command, hash]
+        FastFile.sh(*new_args, &b)
+      else
+        FastFile.sh(*args, &b)
+      end
+    end
+
+    def self.sh(*command, step_name: nil, log: true, error_callback: nil, &b)
+      command_header = log ? step_name || Actions.shell_command_from_args(*command) : "shell command"
+      Actions.execute_action(command_header) do
+        Actions.sh_no_action(*command, log: log, error_callback: error_callback, &b)
+      end
+    end
+
+    def desc(string)
+      desc_collection << string
+    end
+
+    def desc_collection
+      @desc_collection ||= []
+    end
+
+    def fastlane_require(gem_name)
+      FastlaneRequire.install_gem_if_needed(gem_name: gem_name, require_gem: true)
+    end
+
+    def generated_fastfile_id(id)
+      UI.important("The `generated_fastfile_id` action was deprecated, you can remove the line from your `Fastfile`")
+    end
+
+    def import(path = nil)
+      UI.user_error!("Please pass a path to the `import` action") unless path
+
+      path = path.dup.gsub("~", Dir.home)
+      unless Pathname.new(path).absolute? # unless an absolute path
+        path = File.join(File.expand_path('..', @path), path)
+      end
+
+      UI.user_error!("Could not find Fastfile at path '#{path}'") unless File.exist?(path)
+
+      # First check if there are local actions to import in the same directory as the Fastfile
+      actions_path = File.join(File.expand_path("..", path), 'actions')
+      Fastlane::Actions.load_external_actions(actions_path) if File.directory?(actions_path)
+
+      action_launched('import')
+
+      return_value = parse(File.read(path), path)
+
+      action_completed('import', status: FastlaneCore::ActionCompletionStatus::SUCCESS)
+
+      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
+    # @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
+        require 'tmpdir'
+
+        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
+
+        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(" ")
+
+          # 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?
+            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}")
+
+          # 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
+          if dependencies.any?
+            return_value = [import(File.join(clone_folder, path))]
+            return_value += dependencies.map { |file_path| import(File.join(clone_folder, file_path)) }
+          else
+            return_value = import(File.join(clone_folder, path))
+          end
+
+          action_completed('import_from_git', status: FastlaneCore::ActionCompletionStatus::SUCCESS)
+
+          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
+
+    #####################################################
+    # @!group Versioning helpers
+    #####################################################
+
+    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
+      git_tags_string = Actions.sh("cd #{folder.shellescape} && git tag -l")
+      git_tags = git_tags_string.split("\n")
+
+      # Sort tags based on their version number
+      return git_tags
+             .select { |tag| FastlaneCore::TagVersion.correct?(tag) }
+             .sort_by { |tag| FastlaneCore::TagVersion.new(tag) }
+    end
+
+    #####################################################
+    # @!group Overwriting Ruby methods
+    #####################################################
+
+    # Speak out loud
+    def say(value)
+      # Overwrite this, since there is already a 'say' method defined in the Ruby standard library
+      value ||= yield
+
+      value = { text: value } if value.kind_of?(String) || value.kind_of?(Array)
+      self.runner.trigger_action_by_name(:say, nil, false, value)
+    end
+
+    def puts(value)
+      # Overwrite this, since there is already a 'puts' method defined in the Ruby standard library
+      value ||= yield if block_given?
+
+      action_launched('puts')
+      return_value = Fastlane::Actions::PutsAction.run([value])
+      action_completed('puts', status: FastlaneCore::ActionCompletionStatus::SUCCESS)
+      return return_value
+    end
+
+    def test(params = {})
+      # Overwrite this, since there is already a 'test' method defined in the Ruby standard library
+      self.runner.try_switch_to_lane(:test, [params])
+    end
+
+    def action_launched(action_name)
+      action_launch_context = FastlaneCore::ActionLaunchContext.context_for_action_name(action_name,
+                                                                                        fastlane_client_language: :ruby,
+                                                                                        args: ARGV)
+      FastlaneCore.session.action_launched(launch_context: action_launch_context)
+    end
+
+    def action_completed(action_name, status: nil)
+      completion_context = FastlaneCore::ActionCompletionContext.context_for_action_name(action_name,
+                                                                                         args: ARGV,
+                                                                                         status: status)
+      FastlaneCore.session.action_completed(completion_context: completion_context)
+    end
+  end
+end