Merge pull request #11654 from Homebrew/dependabot/bundler/Library/Homebrew/addressable-2.8.0

build(deps): bump addressable from 2.7.0 to 2.8.0 in /Library/Homebrew

Library/Homebrew/Gemfile.lock

@@ -7,7 +7,7 @@ GEM
       minitest (>= 5.1)
       tzinfo (~> 2.0)
       zeitwerk (~> 2.3)
-    addressable (2.7.0)
+    addressable (2.8.0)
       public_suffix (>= 2.0.2, < 5.0)
     ast (2.4.2)
     bindata (2.4.10)

Library/Homebrew/sorbet/rbi/gems/addressable@2.8.0.rbi

@@ -4,8 +4,7 @@
 
 # typed: true
 
-module Addressable
+module Addressable; end
-end
 
 module Addressable::IDNA
   class << self
@@ -26,6 +25,7 @@ module Addressable::IDNA
     def punycode_delimiter?(codepoint); end
     def punycode_encode(unicode); end
     def punycode_encode_digit(d); end
+    def ucs4_to_utf8(char, buffer); end
     def unicode_compose(unpacked); end
     def unicode_compose_pair(ch_one, ch_two); end
     def unicode_decompose(unpacked); end
@@ -36,80 +36,41 @@ module Addressable::IDNA
 end
 
 Addressable::IDNA::ACE_MAX_LENGTH = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::ACE_PREFIX = T.let(T.unsafe(nil), String)
-
 Addressable::IDNA::COMPOSITION_TABLE = T.let(T.unsafe(nil), Hash)
-
 Addressable::IDNA::HANGUL_LBASE = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::HANGUL_LCOUNT = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::HANGUL_NCOUNT = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::HANGUL_SBASE = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::HANGUL_SCOUNT = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::HANGUL_TBASE = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::HANGUL_TCOUNT = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::HANGUL_VBASE = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::HANGUL_VCOUNT = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::PUNYCODE_BASE = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::PUNYCODE_DAMP = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::PUNYCODE_DELIMITER = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::PUNYCODE_INITIAL_BIAS = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::PUNYCODE_INITIAL_N = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::PUNYCODE_MAXINT = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::PUNYCODE_PRINT_ASCII = T.let(T.unsafe(nil), String)
-
 Addressable::IDNA::PUNYCODE_SKEW = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::PUNYCODE_TMAX = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::PUNYCODE_TMIN = T.let(T.unsafe(nil), Integer)
-
+class Addressable::IDNA::PunycodeBadInput < ::StandardError; end
-class Addressable::IDNA::PunycodeBadInput < ::StandardError
+class Addressable::IDNA::PunycodeBigOutput < ::StandardError; end
-end
+class Addressable::IDNA::PunycodeOverflow < ::StandardError; end
-
-class Addressable::IDNA::PunycodeBigOutput < ::StandardError
-end
-
-class Addressable::IDNA::PunycodeOverflow < ::StandardError
-end
-
 Addressable::IDNA::UNICODE_DATA = T.let(T.unsafe(nil), Hash)
-
 Addressable::IDNA::UNICODE_DATA_CANONICAL = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::UNICODE_DATA_COMBINING_CLASS = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::UNICODE_DATA_COMPATIBILITY = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::UNICODE_DATA_EXCLUSION = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::UNICODE_DATA_LOWERCASE = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::UNICODE_DATA_TITLECASE = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::UNICODE_DATA_UPPERCASE = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::UNICODE_MAX_LENGTH = T.let(T.unsafe(nil), Integer)
-
 Addressable::IDNA::UNICODE_TABLE = T.let(T.unsafe(nil), String)
-
 Addressable::IDNA::UTF8_REGEX = T.let(T.unsafe(nil), Regexp)
-
 Addressable::IDNA::UTF8_REGEX_MULTIBYTE = T.let(T.unsafe(nil), Regexp)
 
 class Addressable::URI
@@ -203,6 +164,7 @@ class Addressable::URI
     def encode(uri, return_type = T.unsafe(nil)); end
     def encode_component(component, character_class = T.unsafe(nil), upcase_encoded = T.unsafe(nil)); end
     def escape(uri, return_type = T.unsafe(nil)); end
+    def escape_component(component, character_class = T.unsafe(nil), upcase_encoded = T.unsafe(nil)); end
     def form_encode(form_values, sort = T.unsafe(nil)); end
     def form_unencode(encoded_value); end
     def heuristic_parse(uri, hints = T.unsafe(nil)); end
@@ -220,71 +182,43 @@ class Addressable::URI
   end
 end
 
-module Addressable::URI::CharacterClasses
+module Addressable::URI::CharacterClasses; end
-end
-
 Addressable::URI::CharacterClasses::ALPHA = T.let(T.unsafe(nil), String)
-
 Addressable::URI::CharacterClasses::AUTHORITY = T.let(T.unsafe(nil), String)
-
 Addressable::URI::CharacterClasses::DIGIT = T.let(T.unsafe(nil), String)
-
 Addressable::URI::CharacterClasses::FRAGMENT = T.let(T.unsafe(nil), String)
-
 Addressable::URI::CharacterClasses::GEN_DELIMS = T.let(T.unsafe(nil), String)
-
 Addressable::URI::CharacterClasses::HOST = T.let(T.unsafe(nil), String)
-
 Addressable::URI::CharacterClasses::PATH = T.let(T.unsafe(nil), String)
-
 Addressable::URI::CharacterClasses::PCHAR = T.let(T.unsafe(nil), String)
-
 Addressable::URI::CharacterClasses::QUERY = T.let(T.unsafe(nil), String)
-
 Addressable::URI::CharacterClasses::RESERVED = T.let(T.unsafe(nil), String)
-
 Addressable::URI::CharacterClasses::SCHEME = T.let(T.unsafe(nil), String)
-
 Addressable::URI::CharacterClasses::SUB_DELIMS = T.let(T.unsafe(nil), String)
-
 Addressable::URI::CharacterClasses::UNRESERVED = T.let(T.unsafe(nil), String)
-
 Addressable::URI::EMPTY_STR = T.let(T.unsafe(nil), String)
-
+class Addressable::URI::InvalidURIError < ::StandardError; end
-class Addressable::URI::InvalidURIError < ::StandardError
-end
-
 Addressable::URI::NORMPATH = T.let(T.unsafe(nil), Regexp)
-
+module Addressable::URI::NormalizeCharacterClasses; end
+Addressable::URI::NormalizeCharacterClasses::FRAGMENT = T.let(T.unsafe(nil), Regexp)
+Addressable::URI::NormalizeCharacterClasses::HOST = T.let(T.unsafe(nil), Regexp)
+Addressable::URI::NormalizeCharacterClasses::PCHAR = T.let(T.unsafe(nil), Regexp)
+Addressable::URI::NormalizeCharacterClasses::QUERY = T.let(T.unsafe(nil), Regexp)
+Addressable::URI::NormalizeCharacterClasses::SCHEME = T.let(T.unsafe(nil), Regexp)
+Addressable::URI::NormalizeCharacterClasses::UNRESERVED = T.let(T.unsafe(nil), Regexp)
 Addressable::URI::PARENT = T.let(T.unsafe(nil), String)
-
 Addressable::URI::PORT_MAPPING = T.let(T.unsafe(nil), Hash)
-
 Addressable::URI::RULE_2A = T.let(T.unsafe(nil), Regexp)
-
 Addressable::URI::RULE_2B_2C = T.let(T.unsafe(nil), Regexp)
-
 Addressable::URI::RULE_2D = T.let(T.unsafe(nil), Regexp)
-
 Addressable::URI::RULE_PREFIXED_PARENT = T.let(T.unsafe(nil), Regexp)
-
 Addressable::URI::SELF_REF = T.let(T.unsafe(nil), String)
-
 Addressable::URI::SEQUENCE_ENCODING_TABLE = T.let(T.unsafe(nil), Hash)
-
 Addressable::URI::SEQUENCE_UPCASED_PERCENT_ENCODING_TABLE = T.let(T.unsafe(nil), Hash)
-
 Addressable::URI::SLASH = T.let(T.unsafe(nil), String)
-
 Addressable::URI::URIREGEX = T.let(T.unsafe(nil), Regexp)
-
+module Addressable::VERSION; end
-module Addressable::VERSION
-end
-
 Addressable::VERSION::MAJOR = T.let(T.unsafe(nil), Integer)
-
 Addressable::VERSION::MINOR = T.let(T.unsafe(nil), Integer)
-
 Addressable::VERSION::STRING = T.let(T.unsafe(nil), String)
-
 Addressable::VERSION::TINY = T.let(T.unsafe(nil), Integer)

Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi

@@ -2740,8 +2740,6 @@ class Addressable::Template
 
   def extract(uri, processor=T.unsafe(nil)); end
 
-  def generate(params=T.unsafe(nil), recall=T.unsafe(nil), options=T.unsafe(nil)); end
-
   def initialize(pattern); end
 
   def keys(); end
@@ -12578,13 +12576,9 @@ Net::HTTPServerErrorCode = Net::HTTPServerError
 
 Net::HTTPSession = Net::HTTP
 
-class Net::HTTPSuccess
+Net::HTTPSuccess::EXCEPTION_TYPE = Net::HTTPError
-end
 
-Net::HTTPSuccessCode::EXCEPTION_TYPE = Net::HTTPError
+Net::HTTPSuccessCode = Net::HTTPSuccess
-
-class Net::HTTPSuccess
-end
 
 class Net::HTTPURITooLong
   HAS_BODY = ::T.let(nil, ::T.untyped)

Library/Homebrew/vendor/bundle/bundler/setup.rb

@@ -10,7 +10,7 @@ $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/tzinfo-2.0.4/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/zeitwerk-2.4.2/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/activesupport-6.1.4/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/public_suffix-4.0.6/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/addressable-2.7.0/lib"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/addressable-2.8.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/ast-2.4.2/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/bindata-2.4.10/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/x86_64-darwin-14/2.6.0-static/msgpack-1.4.2"

Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/lib/addressable/idna/pure.rb

@@ -178,44 +178,46 @@ module Addressable
       end
 
       p = []
-      ucs4_to_utf8 = lambda do |ch|
-        if ch < 128
-          p << ch
-        elsif ch < 2048
-          p << (ch >> 6 | 192)
-          p << (ch & 63 | 128)
-        elsif ch < 0x10000
-          p << (ch >> 12 | 224)
-          p << (ch >> 6 & 63 | 128)
-          p << (ch & 63 | 128)
-        elsif ch < 0x200000
-          p << (ch >> 18 | 240)
-          p << (ch >> 12 & 63 | 128)
-          p << (ch >> 6 & 63 | 128)
-          p << (ch & 63 | 128)
-        elsif ch < 0x4000000
-          p << (ch >> 24 | 248)
-          p << (ch >> 18 & 63 | 128)
-          p << (ch >> 12 & 63 | 128)
-          p << (ch >> 6 & 63 | 128)
-          p << (ch & 63 | 128)
-        elsif ch < 0x80000000
-          p << (ch >> 30 | 252)
-          p << (ch >> 24 & 63 | 128)
-          p << (ch >> 18 & 63 | 128)
-          p << (ch >> 12 & 63 | 128)
-          p << (ch >> 6 & 63 | 128)
-          p << (ch & 63 | 128)
-        end
-      end
 
-      ucs4_to_utf8.call(ch_one)
+      ucs4_to_utf8(ch_one, p)
-      ucs4_to_utf8.call(ch_two)
+      ucs4_to_utf8(ch_two, p)
 
       return lookup_unicode_composition(p)
     end
     private_class_method :unicode_compose_pair
 
+    def self.ucs4_to_utf8(char, buffer)
+      if char < 128
+        buffer << char
+      elsif char < 2048
+        buffer << (char >> 6 | 192)
+        buffer << (char & 63 | 128)
+      elsif char < 0x10000
+        buffer << (char >> 12 | 224)
+        buffer << (char >> 6 & 63 | 128)
+        buffer << (char & 63 | 128)
+      elsif char < 0x200000
+        buffer << (char >> 18 | 240)
+        buffer << (char >> 12 & 63 | 128)
+        buffer << (char >> 6 & 63 | 128)
+        buffer << (char & 63 | 128)
+      elsif char < 0x4000000
+        buffer << (char >> 24 | 248)
+        buffer << (char >> 18 & 63 | 128)
+        buffer << (char >> 12 & 63 | 128)
+        buffer << (char >> 6 & 63 | 128)
+        buffer << (char & 63 | 128)
+      elsif char < 0x80000000
+        buffer << (char >> 30 | 252)
+        buffer << (char >> 24 & 63 | 128)
+        buffer << (char >> 18 & 63 | 128)
+        buffer << (char >> 12 & 63 | 128)
+        buffer << (char >> 6 & 63 | 128)
+        buffer << (char & 63 | 128)
+      end
+    end
+    private_class_method :ucs4_to_utf8
+
     def self.unicode_sort_canonical(unpacked)
       unpacked = unpacked.dup
       i = 1

Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/lib/addressable/template.rb

@@ -37,7 +37,7 @@ module Addressable
       Addressable::URI::CharacterClasses::DIGIT + '_'
 
     var_char =
-      "(?:(?:[#{variable_char_class}]|%[a-fA-F0-9][a-fA-F0-9])+)"
+      "(?>(?:[#{variable_char_class}]|%[a-fA-F0-9][a-fA-F0-9])+)"
     RESERVED =
       "(?:[#{anything}]|%[a-fA-F0-9][a-fA-F0-9])"
     UNRESERVED =
@@ -412,7 +412,7 @@ module Addressable
     #   match.captures
     #   #=> ["a", ["b", "c"]]
     def match(uri, processor=nil)
-      uri = Addressable::URI.parse(uri)
+      uri = Addressable::URI.parse(uri) unless uri.is_a?(Addressable::URI)
       mapping = {}
 
       # First, we need to process the pattern, and extract the values.
@@ -653,40 +653,6 @@ module Addressable
       self.to_regexp.named_captures
     end
 
-    ##
-    # Generates a route result for a given set of parameters.
-    # Should only be used by rack-mount.
-    #
-    # @param params [Hash] The set of parameters used to expand the template.
-    # @param recall [Hash] Default parameters used to expand the template.
-    # @param options [Hash] Either a `:processor` or a `:parameterize` block.
-    #
-    # @api private
-    def generate(params={}, recall={}, options={})
-      merged = recall.merge(params)
-      if options[:processor]
-        processor = options[:processor]
-      elsif options[:parameterize]
-        # TODO: This is sending me into fits trying to shoe-horn this into
-        # the existing API. I think I've got this backwards and processors
-        # should be a set of 4 optional blocks named :validate, :transform,
-        # :match, and :restore. Having to use a singleton here is a huge
-        # code smell.
-        processor = Object.new
-        class <<processor
-          attr_accessor :block
-          def transform(name, value)
-            block.call(name, value)
-          end
-        end
-        processor.block = options[:parameterize]
-      else
-        processor = nil
-      end
-      result = self.expand(merged, processor)
-      result.to_s if result
-    end
-
   private
     def ordered_variable_defaults
       @ordered_variable_defaults ||= begin
@@ -973,15 +939,35 @@ module Addressable
       end
     end
 
+    ##
+    # Generates the <tt>Regexp</tt> that parses a template pattern. Memoizes the
+    # value if template processor not set (processors may not be deterministic)
+    #
+    # @param [String] pattern The URI template pattern.
+    # @param [#match] processor The template processor to use.
+    #
+    # @return [Array, Regexp]
+    #   An array of expansion variables nad a regular expression which may be
+    #   used to parse a template pattern
+    def parse_template_pattern(pattern, processor = nil)
+      if processor.nil? && pattern == @pattern
+        @cached_template_parse ||=
+          parse_new_template_pattern(pattern, processor)
+      else
+        parse_new_template_pattern(pattern, processor)
+      end
+    end
+
     ##
     # Generates the <tt>Regexp</tt> that parses a template pattern.
     #
     # @param [String] pattern The URI template pattern.
     # @param [#match] processor The template processor to use.
     #
-    # @return [Regexp]
+    # @return [Array, Regexp]
-    #   A regular expression which may be used to parse a template pattern.
+    #   An array of expansion variables nad a regular expression which may be
-    def parse_template_pattern(pattern, processor=nil)
+    #   used to parse a template pattern
+    def parse_new_template_pattern(pattern, processor = nil)
       # Escape the pattern. The two gsubs restore the escaped curly braces
       # back to their original form. Basically, escape everything that isn't
       # within an expansion.

Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/lib/addressable/uri.rb

@@ -48,12 +48,21 @@ module Addressable
       PCHAR = UNRESERVED + SUB_DELIMS + "\\:\\@"
       SCHEME = ALPHA + DIGIT + "\\-\\+\\."
       HOST = UNRESERVED + SUB_DELIMS + "\\[\\:\\]"
-      AUTHORITY = PCHAR
+      AUTHORITY = PCHAR + "\\[\\:\\]"
       PATH = PCHAR + "\\/"
       QUERY = PCHAR + "\\/\\?"
       FRAGMENT = PCHAR + "\\/\\?"
     end
 
+    module NormalizeCharacterClasses
+      HOST = /[^#{CharacterClasses::HOST}]/
+      UNRESERVED = /[^#{CharacterClasses::UNRESERVED}]/
+      PCHAR = /[^#{CharacterClasses::PCHAR}]/
+      SCHEME = /[^#{CharacterClasses::SCHEME}]/
+      FRAGMENT = /[^#{CharacterClasses::FRAGMENT}]/
+      QUERY = %r{[^a-zA-Z0-9\-\.\_\~\!\$\'\(\)\*\+\,\=\:\@\/\?%]|%(?!2B|2b)}
+    end
+
     SLASH = '/'
     EMPTY_STR = ''
 
@@ -73,7 +82,7 @@ module Addressable
       "wais" => 210,
       "ldap" => 389,
       "prospero" => 1525
-    }
+    }.freeze
 
     ##
     # Returns a URI object based on the parsed string.
@@ -421,7 +430,7 @@ module Addressable
     end
 
     class << self
-      alias_method :encode_component, :encode_component
+      alias_method :escape_component, :encode_component
     end
 
     ##
@@ -463,7 +472,11 @@ module Addressable
       uri = uri.dup
       # Seriously, only use UTF-8. I'm really not kidding!
       uri.force_encoding("utf-8")
+
+      unless leave_encoded.empty?
         leave_encoded = leave_encoded.dup.force_encoding("utf-8")
+      end
+
       result = uri.gsub(/%[0-9a-f]{2}/iu) do |sequence|
         c = sequence[1..3].to_i(16).chr
         c.force_encoding("utf-8")
@@ -554,7 +567,11 @@ module Addressable
           end.flatten.join('|')})"
         end
 
-        character_class = /[^#{character_class}]#{leave_re}/
+        character_class = if leave_re
+                            /[^#{character_class}]#{leave_re}/
+                          else
+                            /[^#{character_class}]/
+                          end
       end
       # We can't perform regexps on invalid UTF sequences, but
       # here we need to, so switch to ASCII.
@@ -878,7 +895,7 @@ module Addressable
         else
           Addressable::URI.normalize_component(
             self.scheme.strip.downcase,
-            Addressable::URI::CharacterClasses::SCHEME
+            Addressable::URI::NormalizeCharacterClasses::SCHEME
           )
         end
       end
@@ -898,7 +915,7 @@ module Addressable
         new_scheme = new_scheme.to_str
       end
       if new_scheme && new_scheme !~ /\A[a-z][a-z0-9\.\+\-]*\z/i
-        raise InvalidURIError, "Invalid scheme format: #{new_scheme}"
+        raise InvalidURIError, "Invalid scheme format: '#{new_scheme}'"
       end
       @scheme = new_scheme
       @scheme = nil if @scheme.to_s.strip.empty?
@@ -933,7 +950,7 @@ module Addressable
         else
           Addressable::URI.normalize_component(
             self.user.strip,
-            Addressable::URI::CharacterClasses::UNRESERVED
+            Addressable::URI::NormalizeCharacterClasses::UNRESERVED
           )
         end
       end
@@ -990,7 +1007,7 @@ module Addressable
         else
           Addressable::URI.normalize_component(
             self.password.strip,
-            Addressable::URI::CharacterClasses::UNRESERVED
+            Addressable::URI::NormalizeCharacterClasses::UNRESERVED
           )
         end
       end
@@ -1114,6 +1131,7 @@ module Addressable
     # @return [String] The host component, normalized.
     def normalized_host
       return nil unless self.host
+
       @normalized_host ||= begin
         if !self.host.strip.empty?
           result = ::Addressable::IDNA.to_ascii(
@@ -1125,14 +1143,17 @@ module Addressable
           end
           result = Addressable::URI.normalize_component(
             result,
-            CharacterClasses::HOST)
+            NormalizeCharacterClasses::HOST
+          )
           result
         else
           EMPTY_STR.dup
         end
       end
       # All normalized values should be UTF-8
-      @normalized_host.force_encoding(Encoding::UTF_8) if @normalized_host
+      if @normalized_host && !@normalized_host.empty?
+        @normalized_host.force_encoding(Encoding::UTF_8)
+      end
       @normalized_host
     end
 
@@ -1537,7 +1558,7 @@ module Addressable
         result = path.strip.split(SLASH, -1).map do |segment|
           Addressable::URI.normalize_component(
             segment,
-            Addressable::URI::CharacterClasses::PCHAR
+            Addressable::URI::NormalizeCharacterClasses::PCHAR
           )
         end.join(SLASH)
 
@@ -1612,11 +1633,15 @@ module Addressable
         modified_query_class = Addressable::URI::CharacterClasses::QUERY.dup
         # Make sure possible key-value pair delimiters are escaped.
         modified_query_class.sub!("\\&", "").sub!("\\;", "")
-        pairs = (self.query || "").split("&", -1)
+        pairs = (query || "").split("&", -1)
-        pairs.delete_if(&:empty?) if flags.include?(:compacted)
+        pairs.delete_if(&:empty?).uniq! if flags.include?(:compacted)
         pairs.sort! if flags.include?(:sorted)
         component = pairs.map do |pair|
-          Addressable::URI.normalize_component(pair, modified_query_class, "+")
+          Addressable::URI.normalize_component(
+            pair,
+            Addressable::URI::NormalizeCharacterClasses::QUERY,
+            "+"
+          )
         end.join("&")
         component == "" ? nil : component
       end
@@ -1675,11 +1700,13 @@ module Addressable
         # so it's best to make all changes in-place.
         pair[0] = URI.unencode_component(pair[0])
         if pair[1].respond_to?(:to_str)
+          value = pair[1].to_str
           # I loathe the fact that I have to do this. Stupid HTML 4.01.
           # Treating '+' as a space was just an unbelievably bad idea.
           # There was nothing wrong with '%20'!
           # If it ain't broke, don't fix it!
-          pair[1] = URI.unencode_component(pair[1].to_str.tr("+", " "))
+          value = value.tr("+", " ") if ["http", "https", nil].include?(scheme)
+          pair[1] = URI.unencode_component(value)
         end
         if return_type == Hash
           accu[pair[0]] = pair[1]
@@ -1810,7 +1837,7 @@ module Addressable
       @normalized_fragment ||= begin
         component = Addressable::URI.normalize_component(
           self.fragment,
-          Addressable::URI::CharacterClasses::FRAGMENT
+          Addressable::URI::NormalizeCharacterClasses::FRAGMENT
         )
         component == "" ? nil : component
       end

Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/lib/addressable/version.rb

@@ -23,7 +23,7 @@ if !defined?(Addressable::VERSION)
   module Addressable
     module VERSION
       MAJOR = 2
-      MINOR = 7
+      MINOR = 8
       TINY  = 0
 
       STRING = [MAJOR, MINOR, TINY].join('.')