fastlane_hotfix 2.165.0

data/fastlane_core/lib/fastlane_core/command_executor.rb

@@ -0,0 +1,100 @@
+require_relative 'ui/ui'
+require_relative 'globals'
+require_relative 'fastlane_pty'
+
+module FastlaneCore
+  # Executes commands and takes care of error handling and more
+  class CommandExecutor
+    class << self
+      # Cross-platform way of finding an executable in the $PATH. Respects the $PATHEXT, which lists
+      # valid file extensions for executables on Windows.
+      #
+      #    which('ruby') #=> /usr/bin/ruby
+      #
+      # Derived from https://stackoverflow.com/a/5471032/3005
+      def which(cmd)
+        # PATHEXT contains the list of file extensions that Windows considers executable, semicolon separated.
+        # e.g. ".COM;.EXE;.BAT;.CMD"
+        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : []
+        exts << '' # Always have an empty string (= no file extension)
+
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+          exts.each do |ext|
+            cmd_path = File.join(path, "#{cmd}#{ext}")
+            return cmd_path if Helper.executable?(cmd_path)
+          end
+        end
+
+        return nil
+      end
+
+      # @param command [String] The command to be executed
+      # @param print_all [Boolean] Do we want to print out the command output while running?
+      # @param print_command [Boolean] Should we print the command that's being executed
+      # @param error [Block] A block that's called if an error occurs
+      # @param prefix [Array] An array containing a prefix + block which might get applied to the output
+      # @param loading [String] A loading string that is shown before the first output
+      # @param suppress_output [Boolean] Should we print the command's output?
+      # @return [String] All the output as string
+      def execute(command: nil, print_all: false, print_command: true, error: nil, prefix: nil, loading: nil, suppress_output: false)
+        print_all = true if FastlaneCore::Globals.verbose?
+        prefix ||= {}
+
+        output = []
+        command = command.join(" ") if command.kind_of?(Array)
+        UI.command(command) if print_command
+
+        if print_all && loading # this is only used to show the "Loading text"...
+          UI.command_output(loading)
+        end
+
+        begin
+          status = FastlaneCore::FastlanePty.spawn(command) do |command_stdout, command_stdin, pid|
+            command_stdout.each do |l|
+              line = l.chomp
+              line = line[1..-1] if line[0] == "\r"
+              output << line
+
+              next unless print_all
+
+              # Prefix the current line with a string
+              prefix.each do |element|
+                line = element[:prefix] + line if element[:block] && element[:block].call(line)
+              end
+
+              UI.command_output(line) unless suppress_output
+            end
+          end
+        rescue => ex
+          # FastlanePty adds exit_status on to StandardError so every error will have a status code
+          status = ex.exit_status
+
+          # This could happen when the environment is wrong:
+          # > invalid byte sequence in US-ASCII (ArgumentError)
+          output << ex.to_s
+          o = output.join("\n")
+          puts(o)
+          if error
+            error.call(o, nil)
+          else
+            raise ex
+          end
+        end
+
+        # Exit status for build command, should be 0 if build succeeded
+        if status != 0
+          o = output.join("\n")
+          puts(o) unless suppress_output # the user has the right to see the raw output
+          UI.error("Exit status: #{status}")
+          if error
+            error.call(o, status)
+          else
+            UI.user_error!("Exit status: #{status}")
+          end
+        end
+
+        return output.join("\n")
+      end
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/configuration/commander_generator.rb

@@ -0,0 +1,103 @@
+require 'commander'
+
+require_relative '../module'
+require_relative '../ui/ui'
+
+module FastlaneCore
+  class CommanderGenerator
+    include Commander::Methods
+
+    # Calls the appropriate methods for commander to show the available parameters
+    def generate(options, command: nil)
+      # First, enable `always_trace`, to show the stack trace
+      always_trace!
+
+      used_switches = []
+      options.each do |option|
+        next if option.description.to_s.empty? # "private" options
+        next unless option.display_in_shell
+
+        short_switch = option.short_option
+        key = option.key
+        validate_short_switch(used_switches, short_switch, key)
+
+        type = option.data_type
+
+        # We added type: Hash to code generation, but Ruby's OptionParser doesn't like that
+        # so we need to switch that to something that is supported, luckily, we have an `is_string`
+        # property and if that is false, we'll default to nil
+        if type == Hash
+          type = option.is_string ? String : nil
+        end
+
+        # Boolean is a fastlane thing, it's either TrueClass, or FalseClass, but we won't know
+        # that until runtime, so nil is the best we get
+        if type == Fastlane::Boolean
+          type = nil
+        end
+
+        # This is an important bit of trickery to solve the boolean option situation.
+        #
+        # Typically, boolean command line flags do not accept trailing values. If the flag
+        # is present, the value is true, if it is missing, the value is false. fastlane
+        # supports this style of flag. For example, you can specify a flag like `--clean`,
+        # and the :clean option will be true.
+        #
+        # However, fastlane also supports another boolean flag style that accepts trailing
+        # values much like options for Strings and other value types. That looks like
+        # `--include_bitcode false` The problem is that this does not work out of the box
+        # for Commander and OptionsParser. So, we need to get tricky.
+        #
+        # The value_appendix below acts as a placeholder in the switch definition that
+        # states that we expect to have a trailing value for our options. When an option
+        # declares a data type, we use the name of that data type in all caps like:
+        # "--devices ARRAY". When the data type is nil, this implies that we're going
+        # to be doing some special handling on that value. One special thing we do
+        # automatically in Configuration is to coerce special Strings into boolean values.
+        #
+        # If the data type is nil, the trick we do is to specify a value placeholder, but
+        # we wrap it in [] brackets to mark it as optional. That means that the trailing
+        # value may or may not be present for this flag. If the flag is present, but the
+        # value is not, we get a value of `true`. Perfect for the boolean flag base-case!
+        # If the value is there, we'll actually get it back as a String, which we can
+        # later coerce into a boolean.
+        #
+        # In this way we support handling boolean flags with or without trailing values.
+        value_appendix = (type || '[VALUE]').to_s.upcase
+        long_switch = "--#{option.key} #{value_appendix}"
+
+        description = option.description
+        description += " (#{option.env_name})" unless option.env_name.to_s.empty?
+
+        # We compact this array here to remove the short_switch variable if it is nil.
+        # Passing a nil value to global_option has been shown to create problems with
+        # option parsing!
+        #
+        # See: https://github.com/fastlane/fastlane_core/pull/89
+        #
+        # If we don't have a data type for this option, we tell it to act like a String.
+        # This allows us to get a reasonable value for boolean options that can be
+        # automatically coerced or otherwise handled by the ConfigItem for others.
+        args = [short_switch, long_switch, (type || String), description].compact
+
+        if command
+          command.option(*args)
+        else
+          # This is the call to Commander to set up the option we've been building.
+          global_option(*args)
+        end
+      end
+    end
+
+    def validate_short_switch(used_switches, short_switch, key)
+      return if short_switch.nil?
+
+      UI.user_error!("Short option #{short_switch} already taken for key #{key}") if used_switches.include?(short_switch)
+      UI.user_error!("-v is already used for the fastlane version (key #{key})") if short_switch == "-v"
+      UI.user_error!("-h is already used for the fastlane help screen (key #{key})") if short_switch == "-h"
+      UI.user_error!("-t is already used for the fastlane trace screen (key #{key})") if short_switch == "-t"
+
+      used_switches << short_switch
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/configuration/config_item.rb

@@ -0,0 +1,321 @@
+require_relative '../ui/ui'
+require_relative '../ui/errors/fastlane_error'
+require_relative '../helper'
+require_relative '../module'
+require 'json'
+
+module FastlaneCore
+  class ConfigItem
+    # [Symbol] the key which is used as command parameters or key in the fastlane tools
+    attr_accessor :key
+
+    # [String] the name of the environment variable, which is only used if no other values were found
+    attr_accessor :env_name
+
+    # [String] A description shown to the user
+    attr_accessor :description
+
+    # [String] A string of length 1 which is used for the command parameters (e.g. -f)
+    attr_accessor :short_option
+
+    # the value which is used if there was no given values and no environment values
+    attr_accessor :default_value
+
+    # [Boolean] Set if the default value is generated dynamically
+    attr_accessor :default_value_dynamic
+
+    # the value which is used during Swift code generation
+    #   if the default_value reads from ENV or a file, or from local credentials, we need
+    #   to provide a different default or it might be included in our autogenerated Swift
+    #   as a built-in default for the fastlane gem. This is because when we generate the
+    #   Swift API at deployment time, it fetches the default_value from the config_items
+    attr_accessor :code_gen_default_value
+
+    # An optional block which is called when a new value is set.
+    #   Check value is valid. This could be type checks or if a folder/file exists
+    #   You have to raise a specific exception if something goes wrong. Use `user_error!` for the message: UI.user_error!("your message")
+    attr_accessor :verify_block
+
+    # [Boolean] is false by default. If set to true, also string values will not be asked to the user
+    attr_accessor :optional
+
+    # [Boolean] is false by default. If set to true, type of the parameter will not be validated.
+    attr_accessor :skip_type_validation
+
+    # [Array] array of conflicting option keys(@param key). This allows to resolve conflicts intelligently
+    attr_accessor :conflicting_options
+
+    # An optional block which is called when options conflict happens
+    attr_accessor :conflict_block
+
+    # [String] Set if the option is deprecated. A deprecated option should be optional and is made optional if the parameter isn't set, and fails otherwise
+    attr_accessor :deprecated
+
+    # [Boolean] Set if the variable is sensitive, such as a password or API token, to prevent echoing when prompted for the parameter
+    # If a default value exists, it won't be used during code generation as default values can read from environment variables.
+    attr_accessor :sensitive
+
+    # [Boolean] Set if the default value should never be used during code generation for Swift
+    #   We generate the Swift API at deployment time, and if there is a value that should never be
+    #   included in the Fastlane.swift or other autogenerated classes, we need to strip it out.
+    #   This includes things like API keys that could be read from ENV[]
+    attr_accessor :code_gen_sensitive
+
+    # [Boolean] Set if the variable is to be converted to a shell-escaped String when provided as a Hash or Array
+    # Allows items expected to be strings used in shell arguments to be alternatively provided as a Hash or Array for better readability and auto-escaped for us.
+    attr_accessor :allow_shell_conversion
+
+    # [Boolean] Set if the variable can be used from shell
+    attr_accessor :display_in_shell
+
+    # Creates a new option
+    # @param key (Symbol) the key which is used as command parameters or key in the fastlane tools
+    # @param env_name (String) the name of the environment variable, which is only used if no other values were found
+    # @param description (String) A description shown to the user
+    # @param short_option (String) A string of length 1 which is used for the command parameters (e.g. -f)
+    # @param default_value the value which is used if there was no given values and no environment values
+    # @param default_value_dynamic (Boolean) Set if the default value is generated dynamically
+    # @param verify_block an optional block which is called when a new value is set.
+    #   Check value is valid. This could be type checks or if a folder/file exists
+    #   You have to raise a specific exception if something goes wrong. Append .red after the string
+    # @param is_string *DEPRECATED: Use `type` instead* (Boolean) is that parameter a string? Defaults to true. If it's true, the type string will be verified.
+    # @param type (Class) the data type of this config item. Takes precedence over `is_string`. Use `:shell_string` to allow types `String`, `Hash` and `Array` that will be converted to shell-escaped strings
+    # @param skip_type_validation (Boolean) is false by default. If set to true, type of the parameter will not be validated.
+    # @param optional (Boolean) is false by default. If set to true, also string values will not be asked to the user
+    # @param conflicting_options ([]) array of conflicting option keys(@param key). This allows to resolve conflicts intelligently
+    # @param conflict_block an optional block which is called when options conflict happens
+    # @param deprecated (Boolean|String) Set if the option is deprecated. A deprecated option should be optional and is made optional if the parameter isn't set, and fails otherwise
+    # @param sensitive (Boolean) Set if the variable is sensitive, such as a password or API token, to prevent echoing when prompted for the parameter
+    # @param display_in_shell (Boolean) Set if the variable can be used from shell
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(key: nil,
+                   env_name: nil,
+                   description: nil,
+                   short_option: nil,
+                   default_value: nil,
+                   default_value_dynamic: false,
+                   verify_block: nil,
+                   is_string: true,
+                   type: nil,
+                   skip_type_validation: false,
+                   optional: nil,
+                   conflicting_options: nil,
+                   conflict_block: nil,
+                   deprecated: nil,
+                   sensitive: nil,
+                   code_gen_sensitive: false,
+                   code_gen_default_value: nil,
+                   display_in_shell: true)
+      UI.user_error!("key must be a symbol") unless key.kind_of?(Symbol)
+      UI.user_error!("env_name must be a String") unless (env_name || '').kind_of?(String)
+
+      if short_option
+        UI.user_error!("short_option for key :#{key} must of type String") unless short_option.kind_of?(String)
+        UI.user_error!("short_option for key :#{key} must be a string of length 1") unless short_option.delete('-').length == 1
+      end
+
+      if description
+        UI.user_error!("Do not let descriptions end with a '.', since it's used for user inputs as well for key :#{key}") if description[-1] == '.'
+      end
+
+      if conflicting_options
+        conflicting_options.each do |conflicting_option_key|
+          UI.user_error!("Conflicting option key must be a symbol") unless conflicting_option_key.kind_of?(Symbol)
+        end
+      end
+
+      if deprecated
+        # deprecated options are automatically optional
+        optional = true if optional.nil?
+        UI.crash!("Deprecated option must be optional") unless optional
+
+        # deprecated options are marked deprecated in their description
+        description = deprecated_description(description, deprecated)
+      end
+
+      optional = false if optional.nil?
+      sensitive = false if sensitive.nil?
+
+      @key = key
+      @env_name = env_name
+      @description = description
+      @short_option = short_option
+      @default_value = default_value
+      @default_value_dynamic = default_value_dynamic
+      @verify_block = verify_block
+      @is_string = is_string
+      @data_type = type
+      @data_type = String if type == :shell_string
+      @optional = optional
+      @conflicting_options = conflicting_options
+      @conflict_block = conflict_block
+      @deprecated = deprecated
+      @sensitive = sensitive
+      @code_gen_sensitive = code_gen_sensitive || sensitive
+      @allow_shell_conversion = (type == :shell_string)
+      @display_in_shell = display_in_shell
+      @skip_type_validation = skip_type_validation # sometimes we allow multiple types which causes type validation failures, e.g.: export_options in gym
+
+      @code_gen_default_value = code_gen_default_value
+
+      update_code_gen_default_value_if_able!
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    # if code_gen_default_value is nil, use the default value if it isn't a `code_gen_sensitive` value
+    def update_code_gen_default_value_if_able!
+      # we don't support default values for procs
+      if @data_type == :string_callback
+        @code_gen_default_value = nil
+        return
+      end
+
+      if @code_gen_default_value.nil?
+        unless @code_gen_sensitive
+
+          @code_gen_default_value = @default_value
+        end
+      end
+    end
+
+    def verify!(value)
+      valid?(value)
+    end
+
+    def ensure_generic_type_passes_validation(value)
+      if @skip_type_validation
+        return
+      end
+
+      if data_type != :string_callback && data_type && !value.kind_of?(data_type)
+        UI.user_error!("'#{self.key}' value must be a #{data_type}! Found #{value.class} instead.")
+      end
+    end
+
+    def ensure_boolean_type_passes_validation(value)
+      if @skip_type_validation
+        return
+      end
+
+      # We need to explicitly test against Fastlane::Boolean, TrueClass/FalseClass
+      if value.class != FalseClass && value.class != TrueClass
+        UI.user_error!("'#{self.key}' value must be either `true` or `false`! Found #{value.class} instead.")
+      end
+    end
+
+    # Make sure, the value is valid (based on the verify block)
+    # Raises an exception if the value is invalid
+    def valid?(value)
+      # we also allow nil values, which do not have to be verified.
+      return true if value.nil?
+
+      # Verify that value is the type that we're expecting, if we are expecting a type
+      if data_type == Fastlane::Boolean
+        ensure_boolean_type_passes_validation(value)
+      else
+        ensure_generic_type_passes_validation(value)
+      end
+
+      if @verify_block
+        begin
+          @verify_block.call(value)
+        rescue => ex
+          UI.error("Error setting value '#{value}' for option '#{@key}'")
+          raise Interface::FastlaneError.new, ex.to_s
+        end
+      end
+
+      true
+    end
+
+    # rubocop:disable Metrics/PerceivedComplexity
+    # Returns an updated value type (if necessary)
+    def auto_convert_value(value)
+      return nil if value.nil?
+
+      if data_type == Array
+        return value.split(',') if value.kind_of?(String)
+      elsif data_type == Integer
+        return value.to_i if value.to_i.to_s == value.to_s
+      elsif data_type == Float
+        return value.to_f if value.to_f.to_s == value.to_s
+      elsif allow_shell_conversion
+        return value.shelljoin if value.kind_of?(Array)
+        return value.map { |k, v| "#{k.to_s.shellescape}=#{v.shellescape}" }.join(' ') if value.kind_of?(Hash)
+      elsif data_type == Hash && value.kind_of?(String)
+        begin
+          parsed = JSON.parse(value)
+          return parsed if parsed.kind_of?(Hash)
+        rescue JSON::ParserError
+        end
+      elsif data_type != String
+        # Special treatment if the user specified true, false or YES, NO
+        # There is no boolean type, so we just do it here
+        if %w(YES yes true TRUE).include?(value)
+          return true
+        elsif %w(NO no false FALSE).include?(value)
+          return false
+        end
+      end
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      return value # fallback to not doing anything
+    end
+
+    # Determines the defined data type of this ConfigItem
+    def data_type
+      if @data_type
+        @data_type
+      else
+        (@is_string ? String : nil)
+      end
+    end
+
+    # Replaces the attr_accessor, but maintains the same interface
+    def string?
+      data_type == String
+    end
+
+    # it's preferred to use self.string? In most cases, except in commander_generator.rb, cause... reasons
+    def is_string
+      return @is_string
+    end
+
+    def to_s
+      [@key, @description].join(": ")
+    end
+
+    def deprecated_description(initial_description, deprecated)
+      has_description = !initial_description.to_s.empty?
+
+      description = "**DEPRECATED!**"
+
+      if deprecated.kind_of?(String)
+        description << " #{deprecated}"
+        description << " -" if has_description
+      end
+
+      description << " #{initial_description}" if has_description
+
+      description
+    end
+
+    def doc_default_value
+      return "[*](#parameters-legend-dynamic)" if self.default_value_dynamic
+      return "" if self.default_value.nil?
+      return "`''`" if self.default_value.instance_of?(String) && self.default_value.empty?
+      return "`:#{self.default_value}`" if self.default_value.instance_of?(Symbol)
+
+      "`#{self.default_value}`"
+    end
+
+    def help_default_value
+      return "#{self.default_value} *".strip if self.default_value_dynamic
+      return "" if self.default_value.nil?
+      return "''" if self.default_value.instance_of?(String) && self.default_value.empty?
+      return ":#{self.default_value}" if self.default_value.instance_of?(Symbol)
+
+      self.default_value
+    end
+  end
+end