fastlane_pricing_fix 2.212.1

data/fastlane/lib/fastlane/cli_tools_distributor.rb

@@ -0,0 +1,215 @@
+module Fastlane
+  # This class is responsible for checking the ARGV
+  # to see if the user wants to launch another fastlane
+  # tool or fastlane itself
+  class CLIToolsDistributor
+    class << self
+      def running_version_command?
+        ARGV.include?('-v') || ARGV.include?('--version')
+      end
+
+      def running_help_command?
+        ARGV.include?('-h') || ARGV.include?('--help')
+      end
+
+      def running_init_command?
+        ARGV.include?("init")
+      end
+
+      def utf8_locale?
+        (ENV['LANG'] || "").end_with?("UTF-8", "utf8") || (ENV['LC_ALL'] || "").end_with?("UTF-8", "utf8") || (FastlaneCore::CommandExecutor.which('locale') && `locale charmap`.strip == "UTF-8")
+      end
+
+      def take_off
+        before_import_time = Time.now
+
+        if ENV["FASTLANE_DISABLE_ANIMATION"].nil?
+          # Usually in the fastlane code base we use
+          #
+          #   Helper.show_loading_indicator
+          #   longer_taking_task_here
+          #   Helper.hide_loading_indicator
+          #
+          # but in this case we haven't required FastlaneCore yet
+          # so we'll have to access the raw API for now
+          require "tty-spinner"
+          require_fastlane_spinner = TTY::Spinner.new("[:spinner] 🚀 ", format: :dots)
+          require_fastlane_spinner.auto_spin
+
+          # this might take a long time if there is no Gemfile :(
+          # That's why we show the loading indicator here also
+          require "fastlane"
+
+          require_fastlane_spinner.success
+        else
+          require "fastlane"
+        end
+
+        # Loading any .env files before any lanes are called since
+        # variables like FASTLANE_HIDE_CHANGELOG, SKIP_SLOW_FASTLANE_WARNING
+        # and FASTLANE_DISABLE_COLORS need to be set early on in execution
+        load_dot_env
+
+        # We want to avoid printing output other than the version number if we are running `fastlane -v`
+        unless running_version_command? || running_init_command?
+          print_bundle_exec_warning(is_slow: (Time.now - before_import_time > 3))
+        end
+
+        # Try to check UTF-8 with `locale`, fallback to environment variables
+        unless utf8_locale?
+          warn = "WARNING: fastlane requires your locale to be set to UTF-8. To learn more go to https://docs.fastlane.tools/getting-started/ios/setup/#set-up-environment-variables"
+          UI.error(warn)
+          at_exit do
+            # Repeat warning here so users hopefully see it
+            UI.error(warn)
+          end
+        end
+
+        # Needs to go after load_dot_env for variable FASTLANE_SKIP_UPDATE_CHECK
+        FastlaneCore::UpdateChecker.start_looking_for_update('fastlane')
+
+        # Disabling colors if environment variable set
+        require 'fastlane_core/ui/disable_colors' if FastlaneCore::Helper.colors_disabled?
+
+        # Set interactive environment variable for spaceship (which can't require fastlane_core)
+        ENV["FASTLANE_IS_INTERACTIVE"] = FastlaneCore::UI.interactive?.to_s
+
+        ARGV.unshift("spaceship") if ARGV.first == "spaceauth"
+        tool_name = ARGV.first ? ARGV.first.downcase : nil
+
+        tool_name = process_emojis(tool_name)
+        tool_name = map_aliased_tools(tool_name)
+
+        if tool_name && Fastlane::TOOLS.include?(tool_name.to_sym) && !available_lanes.include?(tool_name.to_sym)
+          # Triggering a specific tool
+          # This happens when the users uses things like
+          #
+          #   fastlane sigh
+          #   fastlane snapshot
+          #
+          require tool_name
+          begin
+            # First, remove the tool's name from the arguments
+            # Since it will be parsed by the `commander` at a later point
+            # and it must not contain the binary name
+            ARGV.shift
+
+            # Import the CommandsGenerator class, which is used to parse
+            # the user input
+            require File.join(tool_name, "commands_generator")
+
+            # Call the tool's CommandsGenerator class and let it do its thing
+            commands_generator = Object.const_get(tool_name.fastlane_module)::CommandsGenerator
+          rescue LoadError
+            # This will only happen if the tool we call here, doesn't provide
+            # a CommandsGenerator class yet
+            # When we launch this feature, this should never be the case
+            abort("#{tool_name} can't be called via `fastlane #{tool_name}`, run '#{tool_name}' directly instead".red)
+          end
+
+          # Some of the tools use other actions so need to load all
+          # actions before we start the tool generator
+          # Example: scan uses slack
+          Fastlane.load_actions
+
+          commands_generator.start
+        elsif tool_name == "fastlane-credentials"
+          require 'credentials_manager'
+          ARGV.shift
+          CredentialsManager::CLI.new.run
+        else
+          # Triggering fastlane to call a lane
+          require "fastlane/commands_generator"
+          Fastlane::CommandsGenerator.start
+        end
+      ensure
+        FastlaneCore::UpdateChecker.show_update_status('fastlane', Fastlane::VERSION)
+      end
+
+      def map_aliased_tools(tool_name)
+        Fastlane::TOOL_ALIASES[tool_name&.to_sym] || tool_name
+      end
+
+      # Since loading dotenv should respect additional environments passed using
+      # --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 correctly respect variables
+      # like FASTLANE_HIDE_CHANGELOG and FASTLANE_DISABLE_COLORS
+      def load_dot_env
+        env_cl_param = lambda do
+          index = ARGV.index("--env")
+          return nil if index.nil?
+          ARGV.delete_at(index)
+
+          return nil if ARGV[index].nil?
+          value = ARGV[index]
+          ARGV.delete_at(index)
+
+          value
+        end
+
+        require 'fastlane/helper/dotenv_helper'
+        Fastlane::Helper::DotenvHelper.load_dot_env(env_cl_param.call)
+      end
+
+      # Since fastlane also supports the rocket and biceps emoji as executable
+      # we need to map those to the appropriate tools
+      def process_emojis(tool_name)
+        return {
+          "🚀" => "fastlane",
+          "💪" => "gym"
+        }[tool_name] || tool_name
+      end
+
+      def print_bundle_exec_warning(is_slow: false)
+        return if FastlaneCore::Helper.bundler? # user is alread using bundler
+        return if FastlaneCore::Env.truthy?('SKIP_SLOW_FASTLANE_WARNING') # user disabled the warnings
+        return if FastlaneCore::Helper.contained_fastlane? # user uses the bundled fastlane
+
+        gemfile_path = PluginManager.new.gemfile_path
+        if gemfile_path
+          # The user has a Gemfile, but forgot to use `bundle exec`
+          # Let's tell the user how to use `bundle exec`
+          # We show this warning no matter if the command is slow or not
+          UI.important("fastlane detected a Gemfile in the current directory")
+          UI.important("However, it seems like you didn't use `bundle exec`")
+          UI.important("To launch fastlane faster, please use")
+          UI.message("")
+          UI.command "bundle exec fastlane #{ARGV.join(' ')}"
+          UI.message("")
+        elsif is_slow
+          # fastlane is slow and there is no Gemfile
+          # Let's tell the user how to use `gem cleanup` and how to
+          # start using a Gemfile
+          UI.important("Seems like launching fastlane takes a while - please run")
+          UI.message("")
+          UI.command "[sudo] gem cleanup"
+          UI.message("")
+          UI.important("to uninstall outdated gems and make fastlane launch faster")
+          UI.important("Alternatively it's recommended to start using a Gemfile to lock your dependencies")
+          UI.important("To get started with a Gemfile, run")
+          UI.message("")
+          UI.command "bundle init"
+          UI.command "echo 'gem \"fastlane\"' >> Gemfile"
+          UI.command "bundle install"
+          UI.message("")
+          UI.important("After creating the Gemfile and Gemfile.lock, commit those files into version control")
+        end
+        UI.important("Get started using a Gemfile for fastlane https://docs.fastlane.tools/getting-started/ios/setup/#use-a-gemfile")
+      end
+
+      # Returns an array of symbols for the available lanes for the Fastfile
+      # This doesn't actually use the Fastfile parser, but only
+      # the available lanes. This way it's much faster, which
+      # is very important in this case, since it will be executed
+      # every time one of the tools is launched
+      # Use this only if performance is :key:
+      def available_lanes
+        fastfile_path = FastlaneCore::FastlaneFolder.fastfile_path
+        return [] if fastfile_path.nil?
+        output = `cat #{fastfile_path.shellescape} | grep \"^\s*lane \:\" | awk -F ':' '{print $2}' | awk -F ' ' '{print $1}'`
+        return output.strip.split(" ").collect(&:to_sym)
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/command_line_handler.rb

@@ -0,0 +1,49 @@
+module Fastlane
+  class CommandLineHandler
+    # This method handles command line inputs and properly transforms them to a usable format
+    # @param [Array] args An array of all arguments (not options)
+    # @param [Array] args A hash of all options (e.g. --env NAME)
+    def self.handle(args, options)
+      lane_parameters = {} # the parameters we'll pass to the lane
+      platform_lane_info = [] # the part that's responsible for the lane/platform definition
+      args.each do |current|
+        if current.include?(":") # that's a key/value which we want to pass to the lane
+          key, value = current.split(":", 2)
+          UI.user_error!("Please pass values like this: key:value") unless key.length > 0
+          value = convert_value(value)
+          UI.verbose("Using #{key}: #{value}")
+          lane_parameters[key.to_sym] = value
+        else
+          platform_lane_info << current
+        end
+      end
+
+      platform = nil
+      lane = platform_lane_info[1]
+      if lane
+        platform = platform_lane_info[0]
+      else
+        lane = platform_lane_info[0]
+      end
+
+      dot_env = Helper.test? ? nil : options.env
+
+      if FastlaneCore::FastlaneFolder.swift?
+        disable_runner_upgrades = options.disable_runner_upgrades || false
+        swift_server_port = options.swift_server_port
+        Fastlane::SwiftLaneManager.cruise_lane(lane, lane_parameters, dot_env, disable_runner_upgrades: disable_runner_upgrades, swift_server_port: swift_server_port)
+      else
+        Fastlane::LaneManager.cruise_lane(platform, lane, lane_parameters, dot_env)
+      end
+    end
+
+    # Helper to convert into the right data type
+    def self.convert_value(value)
+      return true if value == 'true' || value == 'yes'
+      return false if value == 'false' || value == 'no'
+
+      # Default case:
+      return value
+    end
+  end
+end

data/fastlane/lib/fastlane/commands_generator.rb

@@ -0,0 +1,371 @@
+require 'commander'
+require 'fastlane/new_action'
+require 'fastlane_core/ui/help_formatter'
+
+HighLine.track_eof = false
+
+module Fastlane
+  class CommandsGenerator
+    include Commander::Methods
+
+    def self.start
+      # since at this point we haven't yet loaded commander
+      # however we do want to log verbose information in the PluginManager
+      FastlaneCore::Globals.verbose = true if ARGV.include?("--verbose")
+      if ARGV.include?("--capture_output")
+        FastlaneCore::Globals.verbose = true
+        FastlaneCore::Globals.capture_output = true
+      end
+      FastlaneCore::Swag.show_loader
+
+      # has to be checked here - in case we want to troubleshoot plugin related issues
+      if ARGV.include?("--troubleshoot")
+        self.confirm_troubleshoot
+      end
+
+      if FastlaneCore::Globals.capture_output?
+        # Trace mode is enabled
+        # redirect STDOUT and STDERR
+        out_channel = StringIO.new
+        $stdout = out_channel
+        $stderr = out_channel
+      end
+
+      Fastlane.load_actions
+      FastlaneCore::Swag.stop_loader
+      # do not use "include" as it may be some where in the commandline where "env" is required, therefore explicit index->0
+      unless ARGV[0] == "env" || CLIToolsDistributor.running_version_command? || CLIToolsDistributor.running_help_command?
+        # *after* loading the plugins
+        hide_plugins_table = FastlaneCore::Env.truthy?("FASTLANE_HIDE_PLUGINS_TABLE")
+        Fastlane.plugin_manager.load_plugins(print_table: !hide_plugins_table)
+        Fastlane::PluginUpdateManager.start_looking_for_updates
+      end
+      self.new.run
+    ensure
+      Fastlane::PluginUpdateManager.show_update_status
+      if FastlaneCore::Globals.capture_output?
+        if $stdout.respond_to?(:string)
+          # Sometimes you can get NoMethodError: undefined method `string' for #<IO:<STDOUT>> when running with FastlaneRunner (swift)
+          FastlaneCore::Globals.captured_output = Helper.strip_ansi_colors($stdout.string)
+        end
+        $stdout = STDOUT
+        $stderr = STDERR
+
+        require "fastlane/environment_printer"
+        Fastlane::EnvironmentPrinter.output
+      end
+    end
+
+    def self.confirm_troubleshoot
+      if Helper.ci?
+        UI.error("---")
+        UI.error("You are trying to use '--troubleshoot' on CI")
+        UI.error("this option is not usable in CI, as it is insecure")
+        UI.error("---")
+        UI.user_error!("Do not use --troubleshoot in CI")
+      end
+      # maybe already set by 'start'
+      return if $troubleshoot
+      UI.error("---")
+      UI.error("Are you sure you want to enable '--troubleshoot'?")
+      UI.error("All commmands will run in full unfiltered output mode.")
+      UI.error("Sensitive data, like passwords, could be printed to the log.")
+      UI.error("---")
+      if UI.confirm("Do you really want to enable --troubleshoot")
+        $troubleshoot = true
+      end
+    end
+
+    def run
+      program :name, 'fastlane'
+      program :version, Fastlane::VERSION
+      program :description, [
+        "CLI for 'fastlane' - #{Fastlane::DESCRIPTION}\n",
+        "\tRun using `fastlane [platform] [lane_name]`",
+        "\tTo pass values to the lanes use `fastlane [platform] [lane_name] key:value key2:value2`"
+      ].join("\n")
+      program :help, 'Author', 'Felix Krause <fastlane@krausefx.com>'
+      program :help, 'Website', 'https://fastlane.tools'
+      program :help, 'GitHub', 'https://github.com/fastlane/fastlane'
+      program :help_formatter, FastlaneCore::HelpFormatter
+
+      global_option('--verbose') { FastlaneCore::Globals.verbose = true }
+      global_option('--capture_output', 'Captures the output of the current run, and generates a markdown issue template') do
+        FastlaneCore::Globals.capture_output = false
+        FastlaneCore::Globals.verbose = true
+      end
+      global_option('--troubleshoot', 'Enables extended verbose mode. Use with caution, as this even includes ALL sensitive data. Cannot be used on CI.')
+      global_option('--env STRING[,STRING2]', String, 'Add environment(s) to use with `dotenv`')
+
+      always_trace!
+
+      command :trigger do |c|
+        c.syntax = 'fastlane [lane]'
+        c.description = 'Run a specific lane. Pass the lane name and optionally the platform first.'
+        c.option('--disable_runner_upgrades', 'Prevents fastlane from attempting to update FastlaneRunner swift project')
+        c.option('--swift_server_port INT', 'Set specific port to communicate between fastlane and FastlaneRunner')
+
+        c.action do |args, options|
+          if ensure_fastfile
+            Fastlane::CommandLineHandler.handle(args, options)
+          end
+        end
+      end
+
+      command :init do |c|
+        c.syntax = 'fastlane init'
+        c.description = 'Helps you with your initial fastlane setup'
+
+        c.option('-u STRING', '--user STRING', String, 'iOS projects only: Your Apple ID')
+
+        c.action do |args, options|
+          is_swift_fastfile = args.include?("swift")
+          Fastlane::Setup.start(user: options.user, is_swift_fastfile: is_swift_fastfile)
+        end
+      end
+
+      # Creating alias for mapping "swift init" to "init swift"
+      alias_command(:'swift init', :init, 'swift')
+
+      command :new_action do |c|
+        c.syntax = 'fastlane new_action'
+        c.description = 'Create a new custom action for fastlane.'
+
+        c.option('--name STRING', String, 'Name of your new action')
+
+        c.action do |args, options|
+          Fastlane::NewAction.run(new_action_name: options.name)
+        end
+      end
+
+      command :socket_server do |c|
+        c.syntax = 'fastlane start_server'
+        c.description = 'Starts local socket server and enables only a single local connection'
+        c.option('-s', '--stay_alive', 'Keeps socket server up even after error or disconnects, requires CTRL-C to kill.')
+        c.option('-c seconds', '--connection_timeout', 'Sets connection established timeout')
+        c.option('-p port', '--port', "Sets the port on localhost for the socket connection")
+        c.action do |args, options|
+          default_connection_timeout = 5
+          stay_alive = options.stay_alive || false
+          connection_timeout = options.connection_timeout || default_connection_timeout
+          port = options.port || 2000
+
+          if stay_alive && options.connection_timeout.nil?
+            UI.important("stay_alive is set, but the connection timeout is not, this will give you #{default_connection_timeout} seconds to (re)connect")
+          end
+
+          require 'fastlane/server/socket_server'
+          require 'fastlane/server/socket_server_action_command_executor'
+
+          command_executor = SocketServerActionCommandExecutor.new
+          server = Fastlane::SocketServer.new(
+            command_executor: command_executor,
+            connection_timeout: connection_timeout,
+            stay_alive: stay_alive,
+            port: port
+          )
+          result = server.start
+          UI.success("Result: #{result}") if result
+        end
+      end
+
+      command :lanes do |c|
+        c.syntax = 'fastlane lanes'
+        c.description = 'Lists all available lanes and shows their description'
+        c.option("-j", "--json", "Output the lanes in JSON instead of text")
+
+        c.action do |args, options|
+          if options.json || ensure_fastfile
+            require 'fastlane/lane_list'
+            path = FastlaneCore::FastlaneFolder.fastfile_path
+
+            if options.json
+              Fastlane::LaneList.output_json(path)
+            else
+              Fastlane::LaneList.output(path)
+            end
+          end
+        end
+      end
+
+      command :list do |c|
+        c.syntax = 'fastlane list'
+        c.description = 'Lists all available lanes without description'
+        c.action do |args, options|
+          if ensure_fastfile
+            ff = Fastlane::FastFile.new(FastlaneCore::FastlaneFolder.fastfile_path)
+            UI.message("Available lanes:")
+            ff.runner.available_lanes.each do |lane|
+              UI.message("- #{lane}")
+            end
+            UI.important("Execute using `fastlane [lane_name]`")
+          end
+        end
+      end
+
+      command :docs do |c|
+        c.syntax = 'fastlane docs'
+        c.description = 'Generate a markdown based documentation based on the Fastfile'
+        c.option('-f', '--force', 'Overwrite the existing README.md in the ./fastlane folder')
+
+        c.action do |args, options|
+          if ensure_fastfile
+            ff = Fastlane::FastFile.new(File.join(FastlaneCore::FastlaneFolder.path || '.', 'Fastfile'))
+            UI.message("You don't need to run `fastlane docs` manually any more, this will be done automatically for you when running a lane.")
+            Fastlane::DocsGenerator.run(ff)
+          end
+        end
+      end
+
+      command :run do |c|
+        c.syntax = 'fastlane run [action] key1:value1 key2:value2'
+        c.description = 'Run a fastlane one-off action without a full lane'
+
+        c.action do |args, options|
+          require 'fastlane/one_off'
+          result = Fastlane::OneOff.execute(args: args)
+          UI.success("Result: #{result}") if result
+        end
+      end
+
+      command :actions do |c|
+        c.syntax = 'fastlane actions'
+        c.description = 'Lists all available fastlane actions'
+
+        c.option('--platform STRING', String, 'Only show actions available on the given platform')
+
+        c.action do |args, options|
+          require 'fastlane/documentation/actions_list'
+          Fastlane::ActionsList.run(filter: args.first, platform: options.platform)
+        end
+      end
+
+      command :action do |c|
+        c.syntax = 'fastlane action [tool_name]'
+        c.description = 'Shows more information for a specific command'
+        c.action do |args, options|
+          require 'fastlane/documentation/actions_list'
+          Fastlane::ActionsList.run(filter: args.first)
+        end
+      end
+
+      command :enable_auto_complete do |c|
+        c.syntax = 'fastlane enable_auto_complete'
+        c.description = 'Enable tab auto completion'
+        c.option('-c STRING[,STRING2]', '--custom STRING[,STRING2]', String, 'Add custom command(s) for which tab auto complete should be enabled too')
+
+        c.action do |args, options|
+          require 'fastlane/auto_complete'
+          Fastlane::AutoComplete.execute(args, options)
+        end
+      end
+
+      command :env do |c|
+        c.syntax = 'fastlane env'
+        c.description = 'Print your fastlane environment, use this when you submit an issue on GitHub'
+        c.action do |args, options|
+          require "fastlane/environment_printer"
+          Fastlane::EnvironmentPrinter.output
+        end
+      end
+
+      command :update_fastlane do |c|
+        c.syntax = 'fastlane update_fastlane'
+        c.description = 'Update fastlane to the latest release'
+        c.action do |args, options|
+          require 'fastlane/one_off'
+          Fastlane::OneOff.run(action: "update_fastlane", parameters: {})
+        end
+      end
+
+      #####################################################
+      # @!group Plugins
+      #####################################################
+
+      command :new_plugin do |c|
+        c.syntax = 'fastlane new_plugin [plugin_name]'
+        c.description = 'Create a new plugin that can be used with fastlane'
+
+        c.action do |args, options|
+          PluginGenerator.new.generate(args.shift)
+        end
+      end
+
+      command :add_plugin do |c|
+        c.syntax = 'fastlane add_plugin [plugin_name]'
+        c.description = 'Add a new plugin to your fastlane setup'
+
+        c.action do |args, options|
+          args << UI.input("Enter the name of the plugin to install: ") if args.empty?
+          args.each do |plugin_name|
+            Fastlane.plugin_manager.add_dependency(plugin_name)
+          end
+
+          UI.important("Make sure to commit your Gemfile, Gemfile.lock and #{PluginManager::PLUGINFILE_NAME} to version control")
+          Fastlane.plugin_manager.install_dependencies!
+        end
+      end
+
+      command :install_plugins do |c|
+        c.syntax = 'fastlane install_plugins'
+        c.description = 'Install all plugins for this project'
+
+        c.action do |args, options|
+          Fastlane.plugin_manager.install_dependencies!
+        end
+      end
+
+      command :update_plugins do |c|
+        c.syntax = 'fastlane update_plugins'
+        c.description = 'Update all plugin dependencies'
+
+        c.action do |args, options|
+          Fastlane.plugin_manager.update_dependencies!
+        end
+      end
+
+      command :search_plugins do |c|
+        c.syntax = 'fastlane search_plugins [search_query]'
+        c.description = 'Search for plugins, search query is optional'
+
+        c.action do |args, options|
+          search_query = args.last
+          PluginSearch.print_plugins(search_query: search_query)
+        end
+      end
+
+      #####################################################
+      # @!group Swift
+      #####################################################
+
+      if FastlaneCore::FastlaneFolder.swift?
+        command :generate_swift do |c|
+          c.syntax = 'fastlane generate_swift'
+          c.description = 'Generates additional Swift APIs for plugins and local actions'
+
+          c.action do |args, options|
+            SwiftActionsAPIGenerator.new(target_output_path: FastlaneCore::FastlaneFolder.swift_folder_path).generate_swift
+            SwiftPluginsAPIGenerator.new(target_output_path: FastlaneCore::FastlaneFolder.swift_folder_path).generate_swift
+          end
+        end
+      end
+
+      default_command(:trigger)
+      run!
+    end
+
+    # Makes sure a Fastfile is available
+    # Shows an appropriate message to the user
+    # if that's not the case
+    # return true if the Fastfile is available
+    def ensure_fastfile
+      return true if FastlaneCore::FastlaneFolder.setup?
+
+      create = UI.confirm('Could not find fastlane in current directory. Make sure to have your fastlane configuration files inside a folder called "fastlane". Would you like to set fastlane up?')
+      if create
+        Fastlane::Setup.start
+      end
+      return false
+    end
+  end
+end

data/fastlane/lib/fastlane/configuration_helper.rb

@@ -0,0 +1,26 @@
+module Fastlane
+  class ConfigurationHelper
+    def self.parse(action, params)
+      first_element = (action.available_options || []).first
+
+      if first_element && first_element.kind_of?(FastlaneCore::ConfigItem)
+        # default use case
+        return FastlaneCore::Configuration.create(action.available_options, params)
+      elsif first_element
+        UI.error("Old configuration format for action '#{action}'") if Helper.test?
+        return params
+      else
+
+        # No parameters... we still need the configuration object array
+        FastlaneCore::Configuration.create(action.available_options, {})
+
+      end
+    rescue => ex
+      if action.respond_to?(:action_name)
+        UI.error("You passed invalid parameters to '#{action.action_name}'.")
+        UI.error("Check out the error below and available options by running `fastlane action #{action.action_name}`")
+      end
+      raise ex
+    end
+  end
+end

data/fastlane/lib/fastlane/core_ext/bundler_monkey_patch.rb

@@ -0,0 +1,14 @@
+# https://github.com/bundler/bundler/issues/4368
+#
+# There is an issue with RubyGems 2.6.2 where it attempts to call Bundler::SpecSet#size, which doesn't exist.
+# If a gem is not installed, a `Gem::Specification.find_by_name` call will trigger this problem.
+if Object.const_defined?(:Bundler) &&
+   Bundler.const_defined?(:SpecSet) &&
+   Bundler::SpecSet.instance_methods.include?(:length) &&
+   !Bundler::SpecSet.instance_methods.include?(:size)
+  module Bundler
+    class SpecSet
+      alias size length
+    end
+  end
+end