honeybadger 5.0.2 → 5.1.0

data/vendor/cli/thor/parser/option.rb

@@ -1,125 +1,125 @@
-class Thor
-  class Option < Argument #:nodoc:
-    attr_reader :aliases, :group, :lazy_default, :hide
-
-    VALID_TYPES = [:boolean, :numeric, :hash, :array, :string]
-
-    def initialize(name, options = {})
-      options[:required] = false unless options.key?(:required)
-      super
-      @lazy_default = options[:lazy_default]
-      @group        = options[:group].to_s.capitalize if options[:group]
-      @aliases      = Array(options[:aliases])
-      @hide         = options[:hide]
-    end
-
-    # This parse quick options given as method_options. It makes several
-    # assumptions, but you can be more specific using the option method.
-    #
-    #   parse :foo => "bar"
-    #   #=> Option foo with default value bar
-    #
-    #   parse [:foo, :baz] => "bar"
-    #   #=> Option foo with default value bar and alias :baz
-    #
-    #   parse :foo => :required
-    #   #=> Required option foo without default value
-    #
-    #   parse :foo => 2
-    #   #=> Option foo with default value 2 and type numeric
-    #
-    #   parse :foo => :numeric
-    #   #=> Option foo without default value and type numeric
-    #
-    #   parse :foo => true
-    #   #=> Option foo with default value true and type boolean
-    #
-    # The valid types are :boolean, :numeric, :hash, :array and :string. If none
-    # is given a default type is assumed. This default type accepts arguments as
-    # string (--foo=value) or booleans (just --foo).
-    #
-    # By default all options are optional, unless :required is given.
-    #
-    def self.parse(key, value) # rubocop:disable MethodLength
-      if key.is_a?(Array)
-        name, *aliases = key
-      else
-        name, aliases = key, []
-      end
-
-      name    = name.to_s
-      default = value
-
-      type = case value
-             when Symbol
-               default = nil
-               if VALID_TYPES.include?(value)
-                 value
-               elsif required = (value == :required) # rubocop:disable AssignmentInCondition
-                 :string
-               end
-             when TrueClass, FalseClass
-               :boolean
-             when Numeric
-               :numeric
-             when Hash, Array, String
-               value.class.name.downcase.to_sym
-             end
-      new(name.to_s, :required => required, :type => type, :default => default, :aliases => aliases)
-    end
-
-    def switch_name
-      @switch_name ||= dasherized? ? name : dasherize(name)
-    end
-
-    def human_name
-      @human_name ||= dasherized? ? undasherize(name) : name
-    end
-
-    def usage(padding = 0)
-      sample = if banner && !banner.to_s.empty?
-        "#{switch_name}=#{banner}"
-      else
-        switch_name
-      end
-
-      sample = "[#{sample}]" unless required?
-
-      if boolean?
-        sample << ", [#{dasherize("no-" + human_name)}]" unless name == "force"
-      end
-
-      if aliases.empty?
-        (" " * padding) << sample
-      else
-        "#{aliases.join(', ')}, #{sample}"
-      end
-    end
-
-    VALID_TYPES.each do |type|
-      class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def #{type}?
-          self.type == #{type.inspect}
-        end
-      RUBY
-    end
-
-  protected
-
-    def validate!
-      fail ArgumentError, "An option cannot be boolean and required." if boolean? && required?
-    end
-
-    def dasherized?
-      name.index("-") == 0
-    end
-
-    def undasherize(str)
-      str.sub(/^-{1,2}/, "")
-    end
-
-    def dasherize(str)
-      (str.length > 1 ? "--" : "-") + str.gsub("_", "-")
-    end
-  end
-end
+class Thor
+  class Option < Argument #:nodoc:
+    attr_reader :aliases, :group, :lazy_default, :hide
+
+    VALID_TYPES = [:boolean, :numeric, :hash, :array, :string]
+
+    def initialize(name, options = {})
+      options[:required] = false unless options.key?(:required)
+      super
+      @lazy_default = options[:lazy_default]
+      @group        = options[:group].to_s.capitalize if options[:group]
+      @aliases      = Array(options[:aliases])
+      @hide         = options[:hide]
+    end
+
+    # This parse quick options given as method_options. It makes several
+    # assumptions, but you can be more specific using the option method.
+    #
+    #   parse :foo => "bar"
+    #   #=> Option foo with default value bar
+    #
+    #   parse [:foo, :baz] => "bar"
+    #   #=> Option foo with default value bar and alias :baz
+    #
+    #   parse :foo => :required
+    #   #=> Required option foo without default value
+    #
+    #   parse :foo => 2
+    #   #=> Option foo with default value 2 and type numeric
+    #
+    #   parse :foo => :numeric
+    #   #=> Option foo without default value and type numeric
+    #
+    #   parse :foo => true
+    #   #=> Option foo with default value true and type boolean
+    #
+    # The valid types are :boolean, :numeric, :hash, :array and :string. If none
+    # is given a default type is assumed. This default type accepts arguments as
+    # string (--foo=value) or booleans (just --foo).
+    #
+    # By default all options are optional, unless :required is given.
+    #
+    def self.parse(key, value) # rubocop:disable MethodLength
+      if key.is_a?(Array)
+        name, *aliases = key
+      else
+        name, aliases = key, []
+      end
+
+      name    = name.to_s
+      default = value
+
+      type = case value
+             when Symbol
+               default = nil
+               if VALID_TYPES.include?(value)
+                 value
+               elsif required = (value == :required) # rubocop:disable AssignmentInCondition
+                 :string
+               end
+             when TrueClass, FalseClass
+               :boolean
+             when Numeric
+               :numeric
+             when Hash, Array, String
+               value.class.name.downcase.to_sym
+             end
+      new(name.to_s, :required => required, :type => type, :default => default, :aliases => aliases)
+    end
+
+    def switch_name
+      @switch_name ||= dasherized? ? name : dasherize(name)
+    end
+
+    def human_name
+      @human_name ||= dasherized? ? undasherize(name) : name
+    end
+
+    def usage(padding = 0)
+      sample = if banner && !banner.to_s.empty?
+        "#{switch_name}=#{banner}"
+      else
+        switch_name
+      end
+
+      sample = "[#{sample}]" unless required?
+
+      if boolean?
+        sample << ", [#{dasherize("no-" + human_name)}]" unless name == "force"
+      end
+
+      if aliases.empty?
+        (" " * padding) << sample
+      else
+        "#{aliases.join(', ')}, #{sample}"
+      end
+    end
+
+    VALID_TYPES.each do |type|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{type}?
+          self.type == #{type.inspect}
+        end
+      RUBY
+    end
+
+  protected
+
+    def validate!
+      fail ArgumentError, "An option cannot be boolean and required." if boolean? && required?
+    end
+
+    def dasherized?
+      name.index("-") == 0
+    end
+
+    def undasherize(str)
+      str.sub(/^-{1,2}/, "")
+    end
+
+    def dasherize(str)
+      (str.length > 1 ? "--" : "-") + str.gsub("_", "-")
+    end
+  end
+end

data/vendor/cli/thor/parser/options.rb

@@ -1,218 +1,218 @@
-class Thor
-  class Options < Arguments #:nodoc: # rubocop:disable ClassLength
-    LONG_RE     = /^(--\w+(?:-\w+)*)$/
-    SHORT_RE    = /^(-[a-z])$/i
-    EQ_RE       = /^(--\w+(?:-\w+)*|-[a-z])=(.*)$/i
-    SHORT_SQ_RE = /^-([a-z]{2,})$/i # Allow either -x -v or -xv style for single char args
-    SHORT_NUM   = /^(-[a-z])#{NUMERIC}$/i
-    OPTS_END    = "--".freeze
-
-    # Receives a hash and makes it switches.
-    def self.to_switches(options)
-      options.map do |key, value|
-        case value
-        when true
-          "--#{key}"
-        when Array
-          "--#{key} #{value.map { |v| v.inspect }.join(' ')}"
-        when Hash
-          "--#{key} #{value.map { |k, v| "#{k}:#{v}" }.join(' ')}"
-        when nil, false
-          ""
-        else
-          "--#{key} #{value.inspect}"
-        end
-      end.join(" ")
-    end
-
-    # Takes a hash of Thor::Option and a hash with defaults.
-    #
-    # If +stop_on_unknown+ is true, #parse will stop as soon as it encounters
-    # an unknown option or a regular argument.
-    def initialize(hash_options = {}, defaults = {}, stop_on_unknown = false)
-      @stop_on_unknown = stop_on_unknown
-      options = hash_options.values
-      super(options)
-
-      # Add defaults
-      defaults.each do |key, value|
-        @assigns[key.to_s] = value
-        @non_assigned_required.delete(hash_options[key])
-      end
-
-      @shorts, @switches, @extra = {}, {}, []
-
-      options.each do |option|
-        @switches[option.switch_name] = option
-
-        option.aliases.each do |short|
-          name = short.to_s.sub(/^(?!\-)/, "-")
-          @shorts[name] ||= option.switch_name
-        end
-      end
-    end
-
-    def remaining # rubocop:disable TrivialAccessors
-      @extra
-    end
-
-    def peek
-      return super unless @parsing_options
-
-      result = super
-      if result == OPTS_END
-        shift
-        @parsing_options = false
-        super
-      else
-        result
-      end
-    end
-
-    def parse(args) # rubocop:disable MethodLength
-      @pile = args.dup
-      @parsing_options = true
-
-      while peek
-        if parsing_options?
-          match, is_switch = current_is_switch?
-          shifted = shift
-
-          if is_switch
-            case shifted
-            when SHORT_SQ_RE
-              unshift($1.split("").map { |f| "-#{f}" })
-              next
-            when EQ_RE, SHORT_NUM
-              unshift($2)
-              switch = $1
-            when LONG_RE, SHORT_RE
-              switch = $1
-            end
-
-            switch = normalize_switch(switch)
-            option = switch_option(switch)
-            @assigns[option.human_name] = parse_peek(switch, option)
-          elsif @stop_on_unknown
-            @parsing_options = false
-            @extra << shifted
-            @extra << shift while peek
-            break
-          elsif match
-            @extra << shifted
-            @extra << shift while peek && peek !~ /^-/
-          else
-            @extra << shifted
-          end
-        else
-          @extra << shift
-        end
-      end
-
-      check_requirement!
-
-      assigns = Thor::CoreExt::HashWithIndifferentAccess.new(@assigns)
-      assigns.freeze
-      assigns
-    end
-
-    def check_unknown!
-      # an unknown option starts with - or -- and has no more --'s afterward.
-      unknown = @extra.select { |str| str =~ /^--?(?:(?!--).)*$/ }
-      fail UnknownArgumentError, "Unknown switches '#{unknown.join(', ')}'" unless unknown.empty?
-    end
-
-  protected
-
-    # Check if the current value in peek is a registered switch.
-    #
-    # Two booleans are returned.  The first is true if the current value
-    # starts with a hyphen; the second is true if it is a registered switch.
-    def current_is_switch?
-      case peek
-      when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM
-        [true, switch?($1)]
-      when SHORT_SQ_RE
-        [true, $1.split("").any? { |f| switch?("-#{f}") }]
-      else
-        [false, false]
-      end
-    end
-
-    def current_is_switch_formatted?
-      case peek
-      when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM, SHORT_SQ_RE
-        true
-      else
-        false
-      end
-    end
-
-    def current_is_value?
-      peek && (!parsing_options? || super)
-    end
-
-    def switch?(arg)
-      switch_option(normalize_switch(arg))
-    end
-
-    def switch_option(arg)
-      if match = no_or_skip?(arg) # rubocop:disable AssignmentInCondition
-        @switches[arg] || @switches["--#{match}"]
-      else
-        @switches[arg]
-      end
-    end
-
-    # Check if the given argument is actually a shortcut.
-    #
-    def normalize_switch(arg)
-      (@shorts[arg] || arg).tr("_", "-")
-    end
-
-    def parsing_options?
-      peek
-      @parsing_options
-    end
-
-    # Parse boolean values which can be given as --foo=true, --foo or --no-foo.
-    #
-    def parse_boolean(switch)
-      if current_is_value?
-        if ["true", "TRUE", "t", "T", true].include?(peek)
-          shift
-          true
-        elsif ["false", "FALSE", "f", "F", false].include?(peek)
-          shift
-          false
-        else
-          true
-        end
-      else
-        @switches.key?(switch) || !no_or_skip?(switch)
-      end
-    end
-
-    # Parse the value at the peek analyzing if it requires an input or not.
-    #
-    def parse_peek(switch, option)
-      if parsing_options? && (current_is_switch_formatted? || last?)
-        if option.boolean?
-          # No problem for boolean types
-        elsif no_or_skip?(switch)
-          return nil # User set value to nil
-        elsif option.string? && !option.required?
-          # Return the default if there is one, else the human name
-          return option.lazy_default || option.default || option.human_name
-        elsif option.lazy_default
-          return option.lazy_default
-        else
-          fail MalformattedArgumentError, "No value provided for option '#{switch}'"
-        end
-      end
-
-      @non_assigned_required.delete(option)
-      send(:"parse_#{option.type}", switch)
-    end
-  end
-end
+class Thor
+  class Options < Arguments #:nodoc: # rubocop:disable ClassLength
+    LONG_RE     = /^(--\w+(?:-\w+)*)$/
+    SHORT_RE    = /^(-[a-z])$/i
+    EQ_RE       = /^(--\w+(?:-\w+)*|-[a-z])=(.*)$/i
+    SHORT_SQ_RE = /^-([a-z]{2,})$/i # Allow either -x -v or -xv style for single char args
+    SHORT_NUM   = /^(-[a-z])#{NUMERIC}$/i
+    OPTS_END    = "--".freeze
+
+    # Receives a hash and makes it switches.
+    def self.to_switches(options)
+      options.map do |key, value|
+        case value
+        when true
+          "--#{key}"
+        when Array
+          "--#{key} #{value.map { |v| v.inspect }.join(' ')}"
+        when Hash
+          "--#{key} #{value.map { |k, v| "#{k}:#{v}" }.join(' ')}"
+        when nil, false
+          ""
+        else
+          "--#{key} #{value.inspect}"
+        end
+      end.join(" ")
+    end
+
+    # Takes a hash of Thor::Option and a hash with defaults.
+    #
+    # If +stop_on_unknown+ is true, #parse will stop as soon as it encounters
+    # an unknown option or a regular argument.
+    def initialize(hash_options = {}, defaults = {}, stop_on_unknown = false)
+      @stop_on_unknown = stop_on_unknown
+      options = hash_options.values
+      super(options)
+
+      # Add defaults
+      defaults.each do |key, value|
+        @assigns[key.to_s] = value
+        @non_assigned_required.delete(hash_options[key])
+      end
+
+      @shorts, @switches, @extra = {}, {}, []
+
+      options.each do |option|
+        @switches[option.switch_name] = option
+
+        option.aliases.each do |short|
+          name = short.to_s.sub(/^(?!\-)/, "-")
+          @shorts[name] ||= option.switch_name
+        end
+      end
+    end
+
+    def remaining # rubocop:disable TrivialAccessors
+      @extra
+    end
+
+    def peek
+      return super unless @parsing_options
+
+      result = super
+      if result == OPTS_END
+        shift
+        @parsing_options = false
+        super
+      else
+        result
+      end
+    end
+
+    def parse(args) # rubocop:disable MethodLength
+      @pile = args.dup
+      @parsing_options = true
+
+      while peek
+        if parsing_options?
+          match, is_switch = current_is_switch?
+          shifted = shift
+
+          if is_switch
+            case shifted
+            when SHORT_SQ_RE
+              unshift($1.split("").map { |f| "-#{f}" })
+              next
+            when EQ_RE, SHORT_NUM
+              unshift($2)
+              switch = $1
+            when LONG_RE, SHORT_RE
+              switch = $1
+            end
+
+            switch = normalize_switch(switch)
+            option = switch_option(switch)
+            @assigns[option.human_name] = parse_peek(switch, option)
+          elsif @stop_on_unknown
+            @parsing_options = false
+            @extra << shifted
+            @extra << shift while peek
+            break
+          elsif match
+            @extra << shifted
+            @extra << shift while peek && peek !~ /^-/
+          else
+            @extra << shifted
+          end
+        else
+          @extra << shift
+        end
+      end
+
+      check_requirement!
+
+      assigns = Thor::CoreExt::HashWithIndifferentAccess.new(@assigns)
+      assigns.freeze
+      assigns
+    end
+
+    def check_unknown!
+      # an unknown option starts with - or -- and has no more --'s afterward.
+      unknown = @extra.select { |str| str =~ /^--?(?:(?!--).)*$/ }
+      fail UnknownArgumentError, "Unknown switches '#{unknown.join(', ')}'" unless unknown.empty?
+    end
+
+  protected
+
+    # Check if the current value in peek is a registered switch.
+    #
+    # Two booleans are returned.  The first is true if the current value
+    # starts with a hyphen; the second is true if it is a registered switch.
+    def current_is_switch?
+      case peek
+      when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM
+        [true, switch?($1)]
+      when SHORT_SQ_RE
+        [true, $1.split("").any? { |f| switch?("-#{f}") }]
+      else
+        [false, false]
+      end
+    end
+
+    def current_is_switch_formatted?
+      case peek
+      when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM, SHORT_SQ_RE
+        true
+      else
+        false
+      end
+    end
+
+    def current_is_value?
+      peek && (!parsing_options? || super)
+    end
+
+    def switch?(arg)
+      switch_option(normalize_switch(arg))
+    end
+
+    def switch_option(arg)
+      if match = no_or_skip?(arg) # rubocop:disable AssignmentInCondition
+        @switches[arg] || @switches["--#{match}"]
+      else
+        @switches[arg]
+      end
+    end
+
+    # Check if the given argument is actually a shortcut.
+    #
+    def normalize_switch(arg)
+      (@shorts[arg] || arg).tr("_", "-")
+    end
+
+    def parsing_options?
+      peek
+      @parsing_options
+    end
+
+    # Parse boolean values which can be given as --foo=true, --foo or --no-foo.
+    #
+    def parse_boolean(switch)
+      if current_is_value?
+        if ["true", "TRUE", "t", "T", true].include?(peek)
+          shift
+          true
+        elsif ["false", "FALSE", "f", "F", false].include?(peek)
+          shift
+          false
+        else
+          true
+        end
+      else
+        @switches.key?(switch) || !no_or_skip?(switch)
+      end
+    end
+
+    # Parse the value at the peek analyzing if it requires an input or not.
+    #
+    def parse_peek(switch, option)
+      if parsing_options? && (current_is_switch_formatted? || last?)
+        if option.boolean?
+          # No problem for boolean types
+        elsif no_or_skip?(switch)
+          return nil # User set value to nil
+        elsif option.string? && !option.required?
+          # Return the default if there is one, else the human name
+          return option.lazy_default || option.default || option.human_name
+        elsif option.lazy_default
+          return option.lazy_default
+        else
+          fail MalformattedArgumentError, "No value provided for option '#{switch}'"
+        end
+      end
+
+      @non_assigned_required.delete(option)
+      send(:"parse_#{option.type}", switch)
+    end
+  end
+end