addressable 2.9.1 → 2.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6d91298f649477b2a758f6205bd3598d071f8c6ee6c063e6a906833d7b1c22d
-  data.tar.gz: '0911936040e27dda609f926393afbd2b5791ec217e25abd02cb744d512e6cf32'
+  metadata.gz: 322c647045515735a4adbd9c7681c7ab0c29b0cf1df4b9893ec5eb7a4c357bba
+  data.tar.gz: 1ddb9d2653a52dc98833f1ff28a849102619c16c752a92b8a6f3a6f1d67ab7c1
 SHA512:
-  metadata.gz: 82bc575aff52883ab8834cd6e588db9e086f9721ef86dc93a43120ac4ae7b3ea88da1d74c05ca1f96ad3890854152f363acf02064c2a754dcd02101f5b509b90
-  data.tar.gz: f5da7b05d4d49ed517a5e3773adbb3146069492e69ee6666285fc9f298925b2805227003489abb5ee353270f23197c165e1b4c6d5b5588d03f887a5a44f4822b
+  metadata.gz: 360a539e633029a58bad0b5173fdaee569c40f2d399dc51254f450dc4cf09f0b1805b2cad7033fd56ade0bf698376dc3be1b737ce0fa19f54a7a11ed6c3cfb0c
+  data.tar.gz: 9ee58aee4c18fb18a1516ac3bb3c85c1bc75804a8720f1719fb1fc66895b0fbaf84bd689b83ec850a52693c3976532bd94a13bdbf7f97fc5c583b2f2cb0d847d

data/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## Addressable 2.9.2 <a name="v2.9.2">
+- fixes `Addressable::URI` returning stale values after a component was
+  changed: e.g. after `host=`, `#site`, `#normalized_site`,
+  `#normalized_authority` and `#normalize` could still use the old host, and
+  after `scheme=`, `#normalized_port` could keep a port that's the new
+  scheme's default (#613)
+- fixes `Addressable::URI#normalized_query` reusing the result of an earlier
+  call with different flags: e.g. after `normalized_query(:sorted)`,
+  `normalized_query` and `#normalize` gave a sorted query, and after
+  `normalized_query`, `normalized_query(:sorted)` gave an unsorted one (#608)
+- fixes `Addressable::Template#expand` and `#partial_expand` changing the
+  arrays given as values: e.g. `[1, :a]` became `["1", "a"]`; a frozen array
+  raised `FrozenError`, and an object that responds to `to_ary`
+  raised `TypeError` (#605)
+- fixes `Addressable::URI#clone` sharing component strings with the original:
+  e.g. appending to the clone's `#host` also changed the original's host, but
+  not its cached normalized values; `#dup` already made a separate copy (#617)
+- fixes the pure-Ruby `Addressable::IDNA.to_unicode` raising `ZeroDivisionError`
+  on some malformed labels, e.g. `xn--rp3=`, which also made
+  `Addressable::URI#display_uri` raise, because the Punycode decoder
+  treated punctuation as digits; such labels are now returned unchanged (#614)
+- speeds up the pure-Ruby `Addressable::IDNA.to_unicode`, which became up to
+  25 times slower in 2.9.1 on long labels with many non-ASCII characters;
+  Punycode encoding no longer takes quadratic time (#645)
+- fixes the "character class has duplicated range" warnings that 2.9.1 gave
+  when `Addressable::IDNA` was loaded with warnings enabled
+- fixes the "instance variable @validation_deferred not initialized" warning
+  that 2.9.1 gave for every new `Addressable::URI` on Ruby before 3.0 with
+  warnings enabled, and a "shadowing outer local variable" warning from
+  `Addressable::Template` on Ruby 2.4 and 2.5
+
 ## Addressable 2.9.1 <a name="v2.9.1">
 - fixes denial of service in `Addressable::URI.normalize_path`, which took
   quadratic time on paths with many dot segments; `URI#normalize`, `#join`,

data/lib/addressable/idna/native.rb

@@ -55,8 +55,10 @@ module Addressable
     # themselves: controls, format characters such as bidi overrides and
     # isolates, and default ignorable code points. libidn rejects most of
     # them, but not those added to Unicode after the version it checks
-    # against, such as U+2066 to U+2069.
-    DISPLAY_CHANGING = /[\p{Cc}\p{Cf}\p{Default_Ignorable_Code_Point}]/
+    # against, such as U+2066 to U+2069. Format characters that are also
+    # default ignorable are left out of the second set, since Ruby warns about
+    # a duplicated range in a character class.
+    DISPLAY_CHANGING = /[\p{Cc}\p{Cf}[\p{Default_Ignorable_Code_Point}&&\P{Cf}]]/
 
     def self.to_unicode(value)
       value.to_s.split('.', -1).map do |segment|

data/lib/addressable/idna/pure.rb

@@ -57,7 +57,9 @@ module Addressable
 
     # Characters that nameprep doesn't allow in a label (Section 5 of
     # RFC 3491), or that it maps to nothing, so they can't be in a label that
-    # toASCII produces.
+    # toASCII produces. Some code points are in more than one table; they're
+    # listed only under the first, since Ruby warns about a duplicated range
+    # in a character class.
     NAMEPREP_PROHIBITED = Regexp.new("[" + [
       # Table C.1.2, non-ASCII space characters
       "\u00A0\u1680\u2000-\u200B\u202F\u205F\u3000",
@@ -70,23 +72,27 @@ module Addressable
       "\uFDD0-\uFDEF" + (0..16).map do |plane|
         [plane * 0x10000 + 0xFFFE, 0x2D, plane * 0x10000 + 0xFFFF].pack("U*")
       end.join,
-      # Table C.6, inappropriate for plain text
-      "\uFFF9-\uFFFD",
+      # Table C.6, inappropriate for plain text (U+FFF9 to U+FFFC are in C.2.2)
+      "\uFFFD",
       # Table C.7, inappropriate for canonical representation
       "\u2FF0-\u2FFB",
-      # Table C.8, change display properties or are deprecated
-      "\u0340\u0341\u200E\u200F\u202A-\u202E\u206A-\u206F",
+      # Table C.8, change display properties or are deprecated (U+206A to
+      # U+206F are in C.2.2)
+      "\u0340\u0341\u200E\u200F\u202A-\u202E",
       # Table C.9, tagging characters
       "\u{E0001}\u{E0020}-\u{E007F}",
-      # Table B.1, commonly mapped to nothing
-      "\u00AD\u034F\u1806\u180B-\u180D\u200B-\u200D\u2060\uFE00-\uFE0F\uFEFF"
+      # Table B.1, commonly mapped to nothing (U+200B is in C.1.2, and U+200C,
+      # U+200D, U+2060 and U+FEFF are in C.2.2)
+      "\u00AD\u034F\u1806\u180B-\u180D\uFE00-\uFE0F"
     ].join + "]")
 
     # Characters that change how a label displays without being visible
     # themselves: controls, format characters such as bidi overrides and
     # isolates, and default ignorable code points, including those added to
-    # Unicode after the version nameprep is based on.
-    DISPLAY_CHANGING = /[\p{Cc}\p{Cf}\p{Default_Ignorable_Code_Point}]/
+    # Unicode after the version nameprep is based on. Format characters that
+    # are also default ignorable are left out of the second set, since Ruby
+    # warns about a duplicated range in a character class.
+    DISPLAY_CHANGING = /[\p{Cc}\p{Cf}[\p{Default_Ignorable_Code_Point}&&\P{Cf}]]/
 
     # :startdoc:
 
@@ -4465,50 +4471,50 @@ module Addressable
     def self.punycode_encode(unicode)
       unicode = unicode.to_s unless unicode.is_a?(String)
       input = unicode.unpack("U*")
-      output = [0] * (ACE_MAX_LENGTH + 1)
-      input_length = input.size
-      output_length = [ACE_MAX_LENGTH]
+      output = []
+      max_out = ACE_MAX_LENGTH
 
-      # Initialize the state
-      n = PUNYCODE_INITIAL_N
-      delta = out = 0
-      max_out = output_length[0]
-      bias = PUNYCODE_INITIAL_BIAS
+      # The positions of each non-basic code point, and a Fenwick tree of
+      # the positions of the code points handled so far, so that counting
+      # the handled code points before a position doesn't take a pass over
+      # the input.
+      positions = {}
+      handled = Array.new(input.size + 1, 0)
 
       # Handle the basic code points:
-      input_length.times do |j|
-        if punycode_basic?(input[j])
-          if max_out - out < 2
+      input.each_with_index do |codepoint, j|
+        if punycode_basic?(codepoint)
+          if max_out - output.size < 2
             raise PunycodeBigOutput,
               "Output would exceed the space provided."
           end
-          output[out] = input[j]
-          out += 1
+          output << codepoint
+          handled[j + 1] = 1
+        else
+          (positions[codepoint] ||= []) << j
         end
       end
+      (1..input.size).each do |i|
+        parent = i + (i & -i)
+        handled[parent] += handled[i] if parent <= input.size
+      end
 
-      h = b = out
+      h = b = output.size
 
       # h is the number of code points that have been handled, b is the
-      # number of basic code points, and out is the number of characters
-      # that have been output.
-
-      if b > 0
-        output[out] = PUNYCODE_DELIMITER
-        out += 1
-      end
+      # number of basic code points, and output.size is the number of
+      # characters that have been output.
 
-      # Main encoding loop:
+      output << PUNYCODE_DELIMITER if b > 0
 
-      while h < input_length
-        # All non-basic code points < n have been
-        # handled already.  Find the next larger one:
+      # Main encoding loop: handle each non-basic code point in ascending
+      # order.
 
-        m = PUNYCODE_MAXINT
-        input_length.times do |j|
-          m = input[j] if (n...m) === input[j]
-        end
+      n = PUNYCODE_INITIAL_N
+      delta = 0
+      bias = PUNYCODE_INITIAL_BIAS
 
+      positions.keys.sort.each do |m|
         # Increase delta enough to advance the decoder's
         # <n,i> state to <m,0>, but guard against overflow:
 
@@ -4518,47 +4524,56 @@ module Addressable
         delta += (m - n) * (h + 1)
         n = m
 
-        input_length.times do |j|
-          # Punycode does not need to check whether input[j] is basic:
-          if input[j] < n
-            delta += 1
-            if delta == 0
-              raise PunycodeOverflow,
-                "Input needs wider integers to process."
-            end
+        # Each occurrence of n adds the handled code points since the last
+        # one, which RFC 3492 counts as code points less than n.
+        handled_before_pass = h
+        counted = 0
+        positions[n].each do |position|
+          before = 0
+          i = position
+          while i > 0
+            before += handled[i]
+            i -= i & -i
           end
+          delta += before - counted
+          counted = before
 
-          if input[j] == n
-            # Represent delta as a generalized variable-length integer:
+          # Represent delta as a generalized variable-length integer:
 
-            q = delta; k = PUNYCODE_BASE
-            while true
-              if out >= max_out
-                raise PunycodeBigOutput,
-                  "Output would exceed the space provided."
-              end
-              t = (
-                if k <= bias
-                  PUNYCODE_TMIN
-                elsif k >= bias + PUNYCODE_TMAX
-                  PUNYCODE_TMAX
-                else
-                  k - bias
-                end
-              )
-              break if q < t
-              output[out] =
-                punycode_encode_digit(t + (q - t) % (PUNYCODE_BASE - t))
-              out += 1
-              q = (q - t) / (PUNYCODE_BASE - t)
-              k += PUNYCODE_BASE
+          q = delta; k = PUNYCODE_BASE
+          while true
+            if output.size >= max_out
+              raise PunycodeBigOutput,
+                "Output would exceed the space provided."
             end
+            t = (
+              if k <= bias
+                PUNYCODE_TMIN
+              elsif k >= bias + PUNYCODE_TMAX
+                PUNYCODE_TMAX
+              else
+                k - bias
+              end
+            )
+            break if q < t
+            output <<
+              punycode_encode_digit(t + (q - t) % (PUNYCODE_BASE - t))
+            q = (q - t) / (PUNYCODE_BASE - t)
+            k += PUNYCODE_BASE
+          end
 
-            output[out] = punycode_encode_digit(q)
-            out += 1
-            bias = punycode_adapt(delta, h + 1, h == b)
-            delta = 0
-            h += 1
+          output << punycode_encode_digit(q)
+          bias = punycode_adapt(delta, h + 1, h == b)
+          delta = 0
+          h += 1
+        end
+        delta += handled_before_pass - counted
+
+        positions[n].each do |position|
+          i = position + 1
+          while i <= input.size
+            handled[i] += 1
+            i += i & -i
           end
         end
 
@@ -4566,20 +4581,7 @@ module Addressable
         n += 1
       end
 
-      output_length[0] = out
-
-      outlen = out
-      outlen.times do |j|
-        c = output[j]
-        unless c >= 0 && c <= 127
-          raise StandardError, "Invalid output char."
-        end
-        unless PUNYCODE_PRINT_ASCII[c]
-          raise PunycodeBadInput, "Input is invalid."
-        end
-      end
-
-      output[0..outlen].map { |x| x.chr }.join("").sub(/\0+\z/, "")
+      output.pack("C*").force_encoding(Encoding::US_ASCII)
     end
     private_class_method :punycode_encode
 
@@ -4724,11 +4726,11 @@ module Addressable
     # (for use in representing integers) in the range 0 to
     # base - 1, or PUNYCODE_BASE if codepoint does not represent a value.
     def self.punycode_decode_digit(codepoint)
-      if codepoint - 48 < 10
+      if codepoint >= 48 && codepoint <= 57
         codepoint - 22
-      elsif codepoint - 65 < 26
+      elsif codepoint >= 65 && codepoint <= 90
         codepoint - 65
-      elsif codepoint - 97 < 26
+      elsif codepoint >= 97 && codepoint <= 122
         codepoint - 97
       else
         PUNYCODE_BASE

data/lib/addressable/template.rb

@@ -910,7 +910,7 @@ module Addressable
     def normalize_value(value)
       # Handle unicode normalization
       if value.respond_to?(:to_ary)
-        value.to_ary.map! { |val| normalize_value(val) }
+        value = value.to_ary.map { |val| normalize_value(val) }
       elsif value.kind_of?(Hash)
         value = value.inject({}) { |acc, (k, v)|
           acc[normalize_value(k)] = normalize_value(v)
@@ -1085,10 +1085,10 @@ module Addressable
         first_explode = explodes.index(true)
         not_after_value =
           "(?<![#{Addressable::URI::CharacterClasses::UNRESERVED}])"
-        combined = varspecs.each_with_index.map do |varspec, index|
+        combined = varspecs.each_with_index.map do |varspec, position|
           _, name, modifier = *varspec.match(VARSPEC)
 
-          result = results[index]
+          result = results[position]
           if result
             "(?<#{name}>#{ result })"
           else
@@ -1130,7 +1130,7 @@ module Addressable
               # TruffleRuby).
               value = "#{seg}(?:#{joiner}#{seg})*"
             end
-            if plain && first_explode && index > first_explode &&
+            if plain && first_explode && position > first_explode &&
                 (operator == '+' || operator == '#' || operator == ';')
               # Exploded values were tried longest first, so whatever this
               # variable could match after the first exploded one, that one
@@ -1146,7 +1146,7 @@ module Addressable
                 # 2.9.0 skipped the variable when it couldn't be empty.
                 "(?:(?<#{name}>)(?!#{RESERVED_NO_COMMA}))?"
               end
-            elsif plain && modifier == '*' && explodes[(index + 1)..-1].any? &&
+            elsif plain && modifier == '*' && explodes[(position + 1)..-1].any? &&
                 (operator.nil? || operator == '/' || operator == '.')
               # Exploded values were tried shortest first, and a later
               # exploded variable can match whatever this one leaves, so once
@@ -1154,7 +1154,7 @@ module Addressable
               # fails too. Of the values tried, only the leading joiners are
               # shorter than every value tried before them.
               "(?<#{name}>(?:#{joiner})*)"
-            elsif plain && index > 0 && explodes[index - 1] &&
+            elsif plain && position > 0 && explodes[position - 1] &&
                 (operator == '?' || operator == '&')
               # Whatever this variable could match after an exploded one,
               # that one already tried matching itself, unless it couldn't:
@@ -1162,7 +1162,7 @@ module Addressable
               # start right after an empty one.
               "(?<#{name}>(?<=#{leader}#{joiner}|#{joiner}#{joiner})" \
                 "#{value || group})?"
-            elsif operator == ';' && plain && index > 0
+            elsif operator == ';' && plain && position > 0
               # Values were tried longest first, and splitting an earlier
               # variable's run of characters with this one never gave a
               # different result, so this one may only start after that run.
@@ -1172,7 +1172,7 @@ module Addressable
             elsif varspecs.size > 1 && (operator == '+' || operator == '#') &&
                   varspec != varspecs.last
               "(?<#{name}>#{RESERVED_NO_COMMA}*+)?"
-            elsif plain && index < varspecs.size - 1 &&
+            elsif plain && position < varspecs.size - 1 &&
                   (operator.nil? || operator == '/' || operator == '.')
               # Values were tried shortest first, so a run of characters
               # without a joiner went to a later variable. The only other

data/lib/addressable/uri.rb

@@ -928,6 +928,11 @@ module Addressable
 
       # Reset dependent values
       @normalized_scheme = NONE
+      @normalized_user = NONE
+      @normalized_password = NONE
+      @normalized_userinfo = NONE
+      @normalized_port = NONE
+      @normalized_path = nil
       remove_composite_values
 
       # Ensure we haven't created an invalid URI
@@ -983,6 +988,7 @@ module Addressable
       @normalized_userinfo = NONE
       @authority = nil
       @normalized_user = NONE
+      @normalized_password = NONE
       remove_composite_values
 
       # Ensure we haven't created an invalid URI
@@ -1038,6 +1044,7 @@ module Addressable
       @normalized_userinfo = NONE
       @authority = nil
       @normalized_password = NONE
+      @normalized_user = NONE
       remove_composite_values
 
       # Ensure we haven't created an invalid URI
@@ -1616,11 +1623,8 @@ module Addressable
     # @return [String] The query component, normalized.
     def normalized_query(*flags)
       return nil unless self.query
-      return @normalized_query unless @normalized_query == NONE
-      @normalized_query = begin
-        modified_query_class = Addressable::URI::CharacterClasses::QUERY.dup
-        # Make sure possible key-value pair delimiters are escaped.
-        modified_query_class.sub!("\\&", "").sub!("\\;", "")
+      return @normalized_query if flags.empty? && @normalized_query != NONE
+      normalized_query = begin
         pairs = (query || "").split("&", -1)
         pairs.delete_if(&:empty?).uniq! if flags.include?(:compacted)
         pairs.sort! if flags.include?(:sorted)
@@ -1634,8 +1638,9 @@ module Addressable
         component == "" ? nil : component
       end
       # All normalized values should be UTF-8
-      force_utf8_encoding_if_needed(@normalized_query)
-      @normalized_query
+      force_utf8_encoding_if_needed(normalized_query)
+      @normalized_query = normalized_query if flags.empty?
+      normalized_query
     end
 
     ##
@@ -2403,7 +2408,8 @@ module Addressable
     # @param [Proc] block
     #   A set of operations to perform on a given URI.
     def defer_validation
-      validation_was_deferred = !!@validation_deferred
+      validation_was_deferred =
+        !!(defined?(@validation_deferred) && @validation_deferred)
       raise LocalJumpError, "No block given." unless block_given?
       @validation_deferred = true
       yield
@@ -2581,6 +2587,9 @@ module Addressable
     def remove_composite_values
       @uri_string = nil
       @hash = nil
+      @site = nil
+      @normalized_site = nil
+      @normalized_authority = nil
     end
 
     ##
@@ -2595,11 +2604,21 @@ module Addressable
 
     private
 
+    def initialize_copy(other)
+      super
+      instance_variables.each do |ivar|
+        value = instance_variable_get(ivar)
+        instance_variable_set(ivar, value.dup) if value.kind_of?(String)
+      end
+    end
+
     ##
     # Resets instance variables
     #
     # @api private
     def reset_ivs
+      @site = nil
+      @normalized_site = nil
       @scheme = nil
       @user = nil
       @normalized_scheme = NONE

data/lib/addressable/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: addressable
 version: !ruby/object:Gem::Version
-  version: 2.9.1
+  version: 2.9.2
 platform: ruby
 authors:
 - Bob Aman
@@ -53,7 +53,7 @@ homepage: https://github.com/sporkmonger/addressable
 licenses:
 - Apache-2.0
 metadata:
-  changelog_uri: https://github.com/sporkmonger/addressable/blob/main/CHANGELOG.md#v2.9.1
+  changelog_uri: https://github.com/sporkmonger/addressable/blob/main/CHANGELOG.md#v2.9.2
 rdoc_options:
 - "--main"
 - README.md
@@ -70,7 +70,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.20
 specification_version: 4
 summary: URI Implementation
 test_files: []