fastlane_iac_publish 0.1.0

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,350 @@
+require 'commander'
+require 'fastlane/new_action'
+
+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 wan't 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
+        Fastlane.plugin_manager.load_plugins
+        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 runing 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, :compact
+
+      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.')
+
+      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('--env STRING[,STRING2]', String, 'Add environment(s) to use with `dotenv`')
+        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.action do |args, options|
+          default_connection_timeout = 5
+          stay_alive = options.stay_alive || false
+          connection_timeout = options.connection_timeout || default_connection_timeout
+
+          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
+          )
+          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
+
+      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

data/fastlane/lib/fastlane/documentation/actions_list.rb

@@ -0,0 +1,214 @@
+module Fastlane
+  class ActionsList
+    def self.run(filter: nil, platform: nil)
+      require 'terminal-table'
+      if filter
+        show_details(filter: filter)
+      else
+        print_all(platform: platform)
+      end
+    end
+
+    def self.print_all(platform: nil)
+      rows = []
+      all_actions(platform) do |action, name|
+        current = []
+
+        if Fastlane::Actions.is_deprecated?(action)
+          current << "#{name} (DEPRECATED)".deprecated
+        else
+          current << name.yellow
+        end
+
+        if action < Action
+          current << action.description.to_s.remove_markdown if action.description
+
+          authors = Array(action.author || action.authors)
+          current << authors.first.green if authors.count == 1
+          current << "Multiple".green if authors.count > 1
+        else
+          UI.error(action_subclass_error(name))
+          current << "Please update action file".red
+          current << ' '
+        end
+        rows << current
+      end
+
+      puts(Terminal::Table.new(
+             title: "Available fastlane actions".green,
+             headings: ['Action', 'Description', 'Author'],
+             rows: FastlaneCore::PrintTable.transform_output(rows)
+      ))
+      puts("  Platform filter: #{platform}".magenta) if platform
+      puts("  Total of #{rows.count} actions")
+
+      puts("\nGet more information for one specific action using `fastlane action [name]`\n".green)
+    end
+
+    def self.show_details(filter: nil)
+      puts("Loading documentation for #{filter}:".green)
+      puts("")
+
+      action = find_action_named(filter)
+
+      if action
+        unless action < Action
+          UI.user_error!(action_subclass_error(filter))
+        end
+
+        print_summary(action, filter)
+        print_options(action, filter)
+        print_output_variables(action, filter)
+        print_return_value(action, filter)
+
+        if Fastlane::Actions.is_deprecated?(action)
+          puts("==========================================".deprecated)
+          puts("This action (#{filter}) is deprecated".deprecated)
+          puts(action.deprecated_notes.to_s.remove_markdown.deprecated) if action.deprecated_notes
+          puts("==========================================\n".deprecated)
+        end
+
+        puts("More information can be found on https://docs.fastlane.tools/actions/#{filter}")
+        puts("")
+      else
+        puts("Couldn't find action for the given filter.".red)
+        puts("==========================================\n".red)
+
+        print_all # show all available actions instead
+        print_suggestions(filter)
+      end
+    end
+
+    def self.print_suggestions(filter)
+      if !filter.nil? && filter.length > 1
+        action_names = []
+        all_actions(nil) do |action_ref, action_name|
+          action_names << action_name
+        end
+
+        corrections = []
+
+        if defined?(DidYouMean::SpellChecker)
+          spell_checker = DidYouMean::SpellChecker.new(dictionary: action_names)
+          corrections << spell_checker.correct(filter).compact
+        end
+
+        corrections << action_names.select { |name| name.include?(filter) }
+
+        puts("Did you mean: #{corrections.flatten.uniq.join(', ')}?".green) unless corrections.flatten.empty?
+      end
+    end
+
+    def self.action_subclass_error(name)
+      "Please update your action '#{name}' to be a subclass of `Action` by adding ` < Action` after your class name."
+    end
+
+    def self.print_summary(action, name)
+      rows = []
+
+      if action.description
+        description = action.description.to_s.remove_markdown
+        rows << [description]
+        rows << [' ']
+      end
+
+      if action.details
+        details = action.details.to_s.remove_markdown
+        details.split("\n").each do |detail|
+          row = detail.empty? ? ' ' : detail
+          rows << [row]
+        end
+
+        rows << [' ']
+      end
+
+      authors = Array(action.author || action.authors)
+      rows << ["Created by #{authors.join(', ').green}"] unless authors.empty?
+
+      puts(Terminal::Table.new(title: name.green, rows: FastlaneCore::PrintTable.transform_output(rows)))
+      puts("")
+    end
+
+    def self.print_options(action, name)
+      options = parse_options(action.available_options) if action.available_options
+
+      if options
+        puts(Terminal::Table.new(
+               title: "#{name} Options".green,
+               headings: ['Key', 'Description', 'Env Var', 'Default'],
+               rows: FastlaneCore::PrintTable.transform_output(options)
+        ))
+      else
+        puts("No available options".yellow)
+      end
+      puts("* = default value is dependent on the user's system")
+      puts("")
+    end
+
+    def self.print_output_variables(action, name)
+      output = action.output
+      return if output.nil? || output.empty?
+
+      puts(Terminal::Table.new(
+             title: "#{name} Output Variables".green,
+             headings: ['Key', 'Description'],
+             rows: FastlaneCore::PrintTable.transform_output(output.map { |key, desc| [key.yellow, desc] })
+      ))
+      puts("Access the output values using `lane_context[SharedValues::VARIABLE_NAME]`")
+      puts("")
+    end
+
+    def self.print_return_value(action, name)
+      return unless action.return_value
+
+      puts(Terminal::Table.new(title: "#{name} Return Value".green,
+                                rows: FastlaneCore::PrintTable.transform_output([[action.return_value]])))
+      puts("")
+    end
+
+    # Iterates through all available actions and yields from there
+    def self.all_actions(platform = nil)
+      action_symbols = Fastlane::Actions.constants.select { |c| Fastlane::Actions.const_get(c).kind_of?(Class) && c != :TestSampleCodeAction }
+      action_symbols.sort.each do |symbol|
+        action = Fastlane::Actions.const_get(symbol)
+
+        # We allow classes that don't respond to is_supported? to come through because we want to list
+        # them as broken actions in the table, regardless of platform specification
+        next if platform && action.respond_to?(:is_supported?) && !action.is_supported?(platform.to_sym)
+
+        name = symbol.to_s.gsub('Action', '').fastlane_underscore
+        yield(action, name)
+      end
+    end
+
+    def self.find_action_named(name)
+      all_actions do |action, action_name|
+        return action if action_name == name
+      end
+
+      nil
+    end
+
+    # Helper:
+    def self.parse_options(options, fill_all = true)
+      rows = []
+      rows << [options] if options.kind_of?(String)
+
+      if options.kind_of?(Array)
+        options.each do |current|
+          if current.kind_of?(FastlaneCore::ConfigItem)
+            rows << [current.key.to_s.yellow, current.deprecated ? current.description.red : current.description, current.env_name, current.help_default_value]
+          elsif current.kind_of?(Array)
+            # Legacy actions that don't use the new config manager
+            UI.user_error!("Invalid number of elements in this row: #{current}. Must be 2 or 3") unless [2, 3].include?(current.count)
+            rows << current
+            rows.last[0] = rows.last.first.yellow # color it yellow :)
+            rows.last << nil while fill_all && rows.last.count < 4 # to have a nice border in the table
+          end
+        end
+      end
+
+      rows
+    end
+  end
+end