addressable 2.5.0 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7327067f0dbb5a74d2da6ddff4227408af2f91aa
-  data.tar.gz: a2d86db5e9be6a83ba2e17c825fe4d30bfbac28f
+  metadata.gz: afa411655b3715e655e0cdca551d20df31b83491
+  data.tar.gz: 0cd2871c45abb19f6b6238ad202856e7afb8619d
 SHA512:
-  metadata.gz: afd48eec1e6c38e64f34834cbac4af4f59464f66c9616a95ec74fc0f2c005d2c1c27046d6eccbdafb81d4e0bd974d9cd9fc40beb534911f2943f56c9bcc4da7b
-  data.tar.gz: 6a4de13abead387b0f31861e16887181a8fd686dcdb37f82f04a2fe69be91bdde5b34436269677b47477061d66d98192fbb31c67c1114b10e205c8f23b542d2b
+  metadata.gz: 16274bd51d38c58b3712dbbdad1368417051937dbe33d74fa73951a39b71d824092c0ecd50005d467db9c914cc074fd0344282df2e23e1182c764b1a1da9750a
+  data.tar.gz: c53ff1d0e09a5e3d997a13a464d50c45fd7d548326f94d3ad40dc97753ce3a47aad4804a62faea48b89775394538982e70ac22d7488fab8ee6594b6816d8ff28

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+# Addressable 2.6.0
+- added `tld=` method to allow assignment to the public suffix
+- most `heuristic_parse` patterns are now case-insensitive
+- `heuristic_parse` handles more `file://` URI variations
+- fixes bug in `heuristic_parse` when uri starts with digit
+- fixes bug in `request_uri=` with query strings
+- fixes template issues with `nil` and `?` operator
+- `frozen_string_literal` pragmas added
+- minor performance improvements in regexps
+- fixes to eliminate warnings
+
+# Addressable 2.5.2
+- better support for frozen string literals
+- fixed bug w/ uppercase characters in scheme
+- IDNA errors w/ emoji URLs
+- compatibility w/ public_suffix 3.x
+
+# Addressable 2.5.1
+- allow unicode normalization to be disabled for URI Template expansion
+- removed duplicate test
+
 # Addressable 2.5.0
 - dropping support for Ruby 1.9
 - adding support for Ruby 2.4 preview

data/Gemfile

@@ -3,7 +3,7 @@ source 'https://rubygems.org'
 gemspec
 
 group :test do
-  gem 'rspec', '~> 3.0'
+  gem 'rspec', '~> 3.5'
   gem 'rspec-its', '~> 1.1'
 end
 
@@ -29,4 +29,4 @@ group :test, :development do
   end
 end
 
-gem 'idn-ruby', :platform => [:mri_20, :mri_21, :mri_22]
+gem 'idn-ruby', :platform => [:mri_20, :mri_21, :mri_22, :mri_23, :mri_24]

data/README.md

@@ -8,15 +8,12 @@
 </dl>
 
 [![Gem Version](http://img.shields.io/gem/dt/addressable.svg)][gem]
-[![Build Status](https://secure.travis-ci.org/sporkmonger/addressable.png?branch=master)][travis]
-[![Dependency Status](https://gemnasium.com/sporkmonger/addressable.png?travis)][gemnasium]
+[![Build Status](https://secure.travis-ci.org/sporkmonger/addressable.svg?branch=master)][travis]
 [![Test Coverage Status](https://img.shields.io/coveralls/sporkmonger/addressable.svg)][coveralls]
 [![Documentation Coverage Status](http://inch-ci.org/github/sporkmonger/addressable.svg?branch=master)][inch]
-[![Gittip Donate](http://img.shields.io/gittip/sporkmonger.png)](https://www.gittip.com/sporkmonger/ "Support Open Source Development w/ Gittip")
 
 [gem]: https://rubygems.org/gems/addressable
 [travis]: http://travis-ci.org/sporkmonger/addressable
-[gemnasium]: https://gemnasium.com/sporkmonger/addressable
 [coveralls]: https://coveralls.io/r/sporkmonger/addressable
 [inch]: http://inch-ci.org/github/sporkmonger/addressable
 
@@ -59,7 +56,7 @@ For more details, see [RFC 6570](https://www.rfc-editor.org/rfc/rfc6570.txt).
 
 require "addressable/template"
 
-template = Addressable::Template.new("http://example.com/{?query*}/")
+template = Addressable::Template.new("http://example.com/{?query*}")
 template.expand({
   "query" => {
     'foo' => 'bar',
@@ -106,7 +103,7 @@ $ gem install idn-ruby
 
 # Semantic Versioning
 
-This project uses sementic versioning. You can (and should) specify your
+This project uses [Semantic Versioning](https://semver.org/). You can (and should) specify your
 dependency using a pessimistic version constraint covering the major and minor
 values:
 

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rubygems'
 require 'rake'
 

data/lib/addressable.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require 'addressable/uri'
 require 'addressable/template'

data/lib/addressable/idna.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # encoding:utf-8
 #--
 # Copyright (C) Bob Aman

data/lib/addressable/idna/native.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # encoding:utf-8
 #--
 # Copyright (C) Bob Aman
@@ -35,7 +37,7 @@ module Addressable
     def self.to_ascii(value)
       value.to_s.split('.', -1).map do |segment|
         if segment.size > 0 && segment.size < 64
-          IDN::Idna.toASCII(segment)
+          IDN::Idna.toASCII(segment, IDN::Idna::ALLOW_UNASSIGNED)
         elsif segment.size >= 64
           segment
         else
@@ -47,7 +49,7 @@ module Addressable
     def self.to_unicode(value)
       value.to_s.split('.', -1).map do |segment|
         if segment.size > 0 && segment.size < 64
-          IDN::Idna.toUnicode(segment)
+          IDN::Idna.toUnicode(segment, IDN::Idna::ALLOW_UNASSIGNED)
         elsif segment.size >= 64
           segment
         else

data/lib/addressable/idna/pure.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # encoding:utf-8
 #--
 # Copyright (C) Bob Aman
@@ -146,16 +148,13 @@ module Addressable
       starter_cc = 256 if starter_cc != 0
       for i in 1...length
         ch = unpacked[i]
-        cc = lookup_unicode_combining_class(ch)
 
         if (starter_cc == 0 &&
             (composite = unicode_compose_pair(starter, ch)) != nil)
           starter = composite
-          startercc = lookup_unicode_combining_class(composite)
         else
           unpacked_result << starter
           starter = ch
-          startercc = cc
         end
       end
       unpacked_result << starter

data/lib/addressable/template.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # encoding:utf-8
 #--
 # Copyright (C) Bob Aman
@@ -488,6 +490,8 @@ module Addressable
     # @param [Hash] mapping The mapping that corresponds to the pattern.
     # @param [#validate, #transform] processor
     #   An optional processor object may be supplied.
+    # @param [Boolean] normalize_values
+    #   Optional flag to enable/disable unicode normalization. Default: true
     #
     # The object should respond to either the <tt>validate</tt> or
     # <tt>transform</tt> messages or both. Both the <tt>validate</tt> and
@@ -518,11 +522,11 @@ module Addressable
     #     "http://example.com/{?one,two,three}/"
     #   ).partial_expand({"one" => "1", "three" => 3}).pattern
     #   #=> "http://example.com/?one=1{&two}&three=3"
-    def partial_expand(mapping, processor=nil)
+    def partial_expand(mapping, processor=nil, normalize_values=true)
       result = self.pattern.dup
       mapping = normalize_keys(mapping)
       result.gsub!( EXPRESSION ) do |capture|
-        transform_partial_capture(mapping, capture, processor)
+        transform_partial_capture(mapping, capture, processor, normalize_values)
       end
       return Addressable::Template.new(result)
     end
@@ -533,6 +537,8 @@ module Addressable
     # @param [Hash] mapping The mapping that corresponds to the pattern.
     # @param [#validate, #transform] processor
     #   An optional processor object may be supplied.
+    # @param [Boolean] normalize_values
+    #   Optional flag to enable/disable unicode normalization. Default: true
     #
     # The object should respond to either the <tt>validate</tt> or
     # <tt>transform</tt> messages or both. Both the <tt>validate</tt> and
@@ -583,11 +589,11 @@ module Addressable
     #     ExampleProcessor
     #   ).to_str
     #   #=> Addressable::Template::InvalidTemplateValueError
-    def expand(mapping, processor=nil)
+    def expand(mapping, processor=nil, normalize_values=true)
       result = self.pattern.dup
       mapping = normalize_keys(mapping)
       result.gsub!( EXPRESSION ) do |capture|
-        transform_capture(mapping, capture, processor)
+        transform_capture(mapping, capture, processor, normalize_values)
       end
       return Addressable::URI.parse(result)
     end
@@ -704,6 +710,8 @@ module Addressable
     #   The expression to expand
     # @param [#validate, #transform] processor
     #   An optional processor object may be supplied.
+    # @param [Boolean] normalize_values
+    #   Optional flag to enable/disable unicode normalization. Default: true
     #
     # The object should respond to either the <tt>validate</tt> or
     # <tt>transform</tt> messages or both. Both the <tt>validate</tt> and
@@ -718,56 +726,36 @@ module Addressable
     # after sending the value to the transform method.
     #
     # @return [String] The expanded expression
-    def transform_partial_capture(mapping, capture, processor = nil)
+    def transform_partial_capture(mapping, capture, processor = nil,
+                                  normalize_values = true)
       _, operator, varlist = *capture.match(EXPRESSION)
 
-      vars = varlist.split(',')
+      vars = varlist.split(",")
 
-      if '?' == operator
+      if operator == "?"
         # partial expansion of form style query variables sometimes requires a
         # slight reordering of the variables to produce a valid url.
         first_to_expand = vars.find { |varspec|
           _, name, _ =  *varspec.match(VARSPEC)
-          mapping.key? name
+          mapping.key?(name) && !mapping[name].nil?
         }
 
         vars = [first_to_expand] + vars.reject {|varspec| varspec == first_to_expand}  if first_to_expand
       end
 
-      vars
-        .zip(operator_sequence(operator).take(vars.length))
-        .reduce("") do |acc, (varspec, op)|
+      vars.
+        inject("".dup) do |acc, varspec|
           _, name, _ =  *varspec.match(VARSPEC)
-
-          acc << if mapping.key? name
-                   transform_capture(mapping, "{#{op}#{varspec}}", processor)
-                 else
-                   "{#{op}#{varspec}}"
-                 end
-      end
-    end
-
-    ##
-    # Creates a lazy Enumerator of the operators that should be used to expand
-    # variables in a varlist starting with `operator`. For example, an operator
-    # `"?"` results in the sequence `"?","&","&"...`
-    #
-    # @param [String] operator from which to generate a sequence
-    #
-    # @return [Enumerator] sequence of operators
-    def operator_sequence(operator)
-      rest_operator = if "?" == operator
-                        "&"
-                      else
-                        operator
-                      end
-      head_operator = operator
-
-      Enumerator.new do |y|
-        y << head_operator.to_s
-        while true
-          y << rest_operator.to_s
-        end
+          next_val = if mapping.key? name
+                       transform_capture(mapping, "{#{operator}#{varspec}}",
+                                         processor, normalize_values)
+                     else
+                       "{#{operator}#{varspec}}"
+                     end
+          # If we've already expanded at least one '?' operator with non-empty
+          # value, change to '&'
+          operator = "&" if (operator == "?") && (next_val != "")
+          acc << next_val
       end
     end
 
@@ -780,6 +768,9 @@ module Addressable
     #   The expression to replace
     # @param [#validate, #transform] processor
     #   An optional processor object may be supplied.
+    # @param [Boolean] normalize_values
+    #   Optional flag to enable/disable unicode normalization. Default: true
+    #
     #
     # The object should respond to either the <tt>validate</tt> or
     # <tt>transform</tt> messages or both. Both the <tt>validate</tt> and
@@ -794,7 +785,8 @@ module Addressable
     # after sending the value to the transform method.
     #
     # @return [String] The expanded expression
-    def transform_capture(mapping, capture, processor=nil)
+    def transform_capture(mapping, capture, processor=nil,
+                          normalize_values=true)
       _, operator, varlist = *capture.match(EXPRESSION)
       return_value = varlist.split(',').inject([]) do |acc, varspec|
         _, name, modifier = *varspec.match(VARSPEC)
@@ -814,7 +806,7 @@ module Addressable
               "Can't convert #{value.class} into String or Array."
           end
 
-          value = normalize_value(value)
+          value = normalize_value(value) if normalize_values
 
           if processor == nil || !processor.respond_to?(:transform)
             # Handle percent escaping
@@ -877,7 +869,9 @@ module Addressable
             end
             if processor.respond_to?(:transform)
               transformed_value = processor.transform(name, value)
-              transformed_value = normalize_value(transformed_value)
+              if normalize_values
+                transformed_value = normalize_value(transformed_value)
+              end
             end
           end
           acc << [name, transformed_value]

data/lib/addressable/uri.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # encoding:utf-8
 #--
 # Copyright (C) Bob Aman
@@ -122,9 +124,9 @@ module Addressable
           user = userinfo.strip[/^([^:]*):?/, 1]
           password = userinfo.strip[/:(.*)$/, 1]
         end
-        host = authority.gsub(
+        host = authority.sub(
           /^([^\[\]]*)@/, EMPTY_STR
-        ).gsub(
+        ).sub(
           /:([^:@\[\]]*?)$/, EMPTY_STR
         )
         port = authority[/:([^:@\[\]]*?)$/, 1]
@@ -182,18 +184,24 @@ module Addressable
         :scheme => "http"
       }.merge(hints)
       case uri
-      when /^http:\/+/
-        uri.gsub!(/^http:\/+/, "http://")
-      when /^https:\/+/
-        uri.gsub!(/^https:\/+/, "https://")
-      when /^feed:\/+http:\/+/
-        uri.gsub!(/^feed:\/+http:\/+/, "feed:http://")
-      when /^feed:\/+/
-        uri.gsub!(/^feed:\/+/, "feed://")
-      when /^file:\/+/
-        uri.gsub!(/^file:\/+/, "file:///")
+      when /^http:\//i
+        uri.sub!(/^http:\/+/i, "http://")
+      when /^https:\//i
+        uri.sub!(/^https:\/+/i, "https://")
+      when /^feed:\/+http:\//i
+        uri.sub!(/^feed:\/+http:\/+/i, "feed:http://")
+      when /^feed:\//i
+        uri.sub!(/^feed:\/+/i, "feed://")
+      when %r[^file:/{4}]i
+        uri.sub!(%r[^file:/+]i, "file:////")
+      when %r[^file://localhost/]i
+        uri.sub!(%r[^file://localhost/+]i, "file:///")
+      when %r[^file:/+]i
+        uri.sub!(%r[^file:/+]i, "file:///")
       when /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/
-        uri.gsub!(/^/, hints[:scheme] + "://")
+        uri.sub!(/^/, hints[:scheme] + "://")
+      when /\A\d+\..*:\d+\z/
+        uri = "#{hints[:scheme]}://#{uri}"
       end
       match = uri.match(URIREGEX)
       fragments = match.captures
@@ -202,6 +210,7 @@ module Addressable
         new_authority = authority.gsub(/\\/, '/').gsub(/ /, '%20')
         # NOTE: We want offset 4, not 3!
         offset = match.offset(4)
+        uri = uri.dup
         uri[offset[0]...offset[1]] = new_authority
       end
       parsed = self.parse(uri)
@@ -212,7 +221,7 @@ module Addressable
         new_host = parsed.path[/^([^\/]+\.[^\/]*)/, 1]
         if new_host
           parsed.defer_validation do
-            new_path = parsed.path.gsub(
+            new_path = parsed.path.sub(
               Regexp.new("^" + Regexp.escape(new_host)), EMPTY_STR)
             parsed.host = new_host
             parsed.path = new_path
@@ -263,19 +272,19 @@ module Addressable
       # Otherwise, convert to a String
       path = path.to_str.strip
 
-      path.gsub!(/^file:\/?\/?/, EMPTY_STR) if path =~ /^file:\/?\/?/
+      path.sub!(/^file:\/?\/?/, EMPTY_STR) if path =~ /^file:\/?\/?/
       path = SLASH + path if path =~ /^([a-zA-Z])[\|:]/
       uri = self.parse(path)
 
       if uri.scheme == nil
         # Adjust windows-style uris
-        uri.path.gsub!(/^\/?([a-zA-Z])[\|:][\\\/]/) do
+        uri.path.sub!(/^\/?([a-zA-Z])[\|:][\\\/]/) do
           "/#{$1.downcase}:/"
         end
         uri.path.gsub!(/\\/, SLASH)
         if File.exist?(uri.path) &&
             File.stat(uri.path).directory?
-          uri.path.gsub!(/\/$/, EMPTY_STR)
+          uri.path.sub!(/\/$/, EMPTY_STR)
           uri.path = uri.path + '/'
         end
 
@@ -436,7 +445,7 @@ module Addressable
       uri = uri.dup
       # Seriously, only use UTF-8. I'm really not kidding!
       uri.force_encoding("utf-8")
-      leave_encoded.force_encoding("utf-8")
+      leave_encoded = leave_encoded.dup.force_encoding("utf-8")
       result = uri.gsub(/%[0-9a-f]{2}/iu) do |sequence|
         c = sequence[1..3].to_i(16).chr
         c.force_encoding("utf-8")
@@ -847,7 +856,7 @@ module Addressable
       return nil unless self.scheme
       @normalized_scheme ||= begin
         if self.scheme =~ /^\s*ssh\+svn\s*$/i
-          "svn+ssh"
+          "svn+ssh".dup
         else
           Addressable::URI.normalize_component(
             self.scheme.strip.downcase,
@@ -1032,9 +1041,9 @@ module Addressable
         if !current_user && !current_password
           nil
         elsif current_user && current_password
-          "#{current_user}:#{current_password}"
+          "#{current_user}:#{current_password}".dup
         elsif current_user && !current_password
-          "#{current_user}"
+          "#{current_user}".dup
         end
       end
       # All normalized values should be UTF-8
@@ -1101,7 +1110,7 @@ module Addressable
             CharacterClasses::HOST)
           result
         else
-          EMPTY_STR
+          EMPTY_STR.dup
         end
       end
       # All normalized values should be UTF-8
@@ -1168,6 +1177,15 @@ module Addressable
       PublicSuffix.parse(self.host, ignore_private: true).tld
     end
 
+    ##
+    # Sets the top-level domain for this URI.
+    #
+    # @param [String, #to_str] new_tld The new top-level domain.
+    def tld=(new_tld)
+      replaced_tld = domain.sub(/#{tld}\z/, new_tld)
+      self.host = PublicSuffix::Domain.new(replaced_tld).to_s
+    end
+
     ##
     # Returns the public suffix domain for this host.
     #
@@ -1235,9 +1253,9 @@ module Addressable
           new_user = new_userinfo.strip[/^([^:]*):?/, 1]
           new_password = new_userinfo.strip[/:(.*)$/, 1]
         end
-        new_host = new_authority.gsub(
+        new_host = new_authority.sub(
           /^([^\[\]]*)@/, EMPTY_STR
-        ).gsub(
+        ).sub(
           /:([^:@\[\]]*?)$/, EMPTY_STR
         )
         new_port =
@@ -1421,7 +1439,7 @@ module Addressable
     # @return [String] The components that identify a site.
     def site
       (self.scheme || self.authority) && @site ||= begin
-        site_string = ""
+        site_string = "".dup
         site_string << "#{self.scheme}:" if self.scheme != nil
         site_string << "//#{self.authority}" if self.authority != nil
         site_string
@@ -1440,7 +1458,7 @@ module Addressable
     def normalized_site
       return nil unless self.site
       @normalized_site ||= begin
-        site_string = ""
+        site_string = "".dup
         if self.normalized_scheme != nil
           site_string << "#{self.normalized_scheme}:"
         end
@@ -1508,7 +1526,7 @@ module Addressable
         result = URI.normalize_path(result)
         if result.empty? &&
             ["http", "https", "ftp", "tftp"].include?(self.normalized_scheme)
-          result = SLASH
+          result = SLASH.dup
         end
         result
       end
@@ -1544,7 +1562,7 @@ module Addressable
     # @return [String] The path's basename.
     def basename
       # Path cannot be nil
-      return File.basename(self.path).gsub(/;[^\/]*$/, EMPTY_STR)
+      return File.basename(self.path).sub(/;[^\/]*$/, EMPTY_STR)
     end
 
     ##
@@ -1694,7 +1712,7 @@ module Addressable
       end
 
       # new_query_values have form [['key1', 'value1'], ['key2', 'value2']]
-      buffer = ""
+      buffer = "".dup
       new_query_values.each do |key, value|
         encoded_key = URI.encode_component(
           key, CharacterClasses::UNRESERVED
@@ -1724,7 +1742,7 @@ module Addressable
     #
     # @return [String] The request URI required for an HTTP request.
     def request_uri
-      return nil if self.absolute? && self.scheme !~ /^https?$/
+      return nil if self.absolute? && self.scheme !~ /^https?$/i
       return (
         (!self.path.empty? ? self.path : SLASH) +
         (self.query ? "?#{self.query}" : EMPTY_STR)
@@ -1739,12 +1757,12 @@ module Addressable
       if !new_request_uri.respond_to?(:to_str)
         raise TypeError, "Can't convert #{new_request_uri.class} into String."
       end
-      if self.absolute? && self.scheme !~ /^https?$/
+      if self.absolute? && self.scheme !~ /^https?$/i
         raise InvalidURIError,
           "Cannot set an HTTP request URI for a non-HTTP URI."
       end
       new_request_uri = new_request_uri.to_str
-      path_component = new_request_uri[/^([^\?]*)\?(?:.*)$/, 1]
+      path_component = new_request_uri[/^([^\?]*)\??(?:.*)$/, 1]
       query_component = new_request_uri[/^(?:[^\?]*)\?(.*)$/, 1]
       path_component = path_component.to_s
       path_component = (!path_component.empty? ? path_component : SLASH)
@@ -1900,7 +1918,7 @@ module Addressable
               #
               # Removes the right-most path segment from the base path.
               if base_path =~ /\//
-                base_path.gsub!(/\/[^\/]+$/, SLASH)
+                base_path.sub!(/\/[^\/]+$/, SLASH)
               else
                 base_path = EMPTY_STR
               end

data/lib/addressable/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # encoding:utf-8
 #--
 # Copyright (C) Bob Aman
@@ -21,7 +23,7 @@ if !defined?(Addressable::VERSION)
   module Addressable
     module VERSION
       MAJOR = 2
-      MINOR = 5
+      MINOR = 6
       TINY  = 0
 
       STRING = [MAJOR, MINOR, TINY].join('.')

data/spec/addressable/idna_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # coding: utf-8
 # Copyright (C) Bob Aman
 #
@@ -26,9 +28,9 @@ shared_examples_for "converting from unicode to ASCII" do
     expect(Addressable::IDNA.to_ascii("www.google.com")).to eq("www.google.com")
   end
 
-  LONG = 'AcinusFallumTrompetumNullunCreditumVisumEstAtCuadLongumEtCefallum.com'
-  it "should convert '#{LONG}' correctly" do
-    expect(Addressable::IDNA.to_ascii(LONG)).to eq(LONG)
+  long = 'AcinusFallumTrompetumNullunCreditumVisumEstAtCuadLongumEtCefallum.com'
+  it "should convert '#{long}' correctly" do
+    expect(Addressable::IDNA.to_ascii(long)).to eq(long)
   end
 
   it "should convert 'www.詹姆斯.com' correctly" do
@@ -134,6 +136,12 @@ shared_examples_for "converting from unicode to ASCII" do
     )).to eq("xn--4ud")
   end
 
+  it "should convert '🌹🌹🌹.ws' correctly" do
+    expect(Addressable::IDNA.to_ascii(
+      "\360\237\214\271\360\237\214\271\360\237\214\271.ws"
+    )).to eq("xn--2h8haa.ws")
+  end
+
   it "should handle two adjacent '.'s correctly" do
     expect(Addressable::IDNA.to_ascii(
       "example..host"
@@ -142,9 +150,9 @@ shared_examples_for "converting from unicode to ASCII" do
 end
 
 shared_examples_for "converting from ASCII to unicode" do
-  LONG = 'AcinusFallumTrompetumNullunCreditumVisumEstAtCuadLongumEtCefallum.com'
-  it "should convert '#{LONG}' correctly" do
-    expect(Addressable::IDNA.to_unicode(LONG)).to eq(LONG)
+  long = 'AcinusFallumTrompetumNullunCreditumVisumEstAtCuadLongumEtCefallum.com'
+  it "should convert '#{long}' correctly" do
+    expect(Addressable::IDNA.to_unicode(long)).to eq(long)
   end
 
   it "should return the identity conversion when punycode decode fails" do
@@ -231,6 +239,12 @@ shared_examples_for "converting from ASCII to unicode" do
     )).to eq("\341\206\265")
   end
 
+  it "should convert '🌹🌹🌹.ws' correctly" do
+    expect(Addressable::IDNA.to_unicode(
+      "xn--2h8haa.ws"
+    )).to eq("\360\237\214\271\360\237\214\271\360\237\214\271.ws")
+  end
+
   it "should handle two adjacent '.'s correctly" do
     expect(Addressable::IDNA.to_unicode(
       "example..host"

data/spec/addressable/net_http_compat_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # coding: utf-8
 # Copyright (C) Bob Aman
 #

data/spec/addressable/rack_mount_compat_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # coding: utf-8
 # Copyright (C) Bob Aman
 #

data/spec/addressable/security_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # coding: utf-8
 # Copyright (C) Bob Aman
 #

data/spec/addressable/template_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # coding: utf-8
 # Copyright (C) Bob Aman
 #
@@ -82,7 +84,7 @@ describe "Type conversion" do
       :hello => 1234,
       :nothing => nil,
       :sym => :symbolic,
-      :decimal => BigDecimal.new('1')
+      :decimal => BigDecimal('1')
     }
   }
 
@@ -91,7 +93,7 @@ describe "Type conversion" do
     '{hello}' => '1234',
     '{nothing}' => '',
     '{sym}' => 'symbolic',
-    '{decimal}' => '0.1E1'
+    '{decimal}' => RUBY_VERSION < '2.4.0' ? '0.1E1' : '0.1e1'
   }
 end
 
@@ -949,6 +951,36 @@ describe Addressable::Template do
         )
       end
     end
+    context "issue #307 - partial_expand form query with nil params" do
+      subject do
+        Addressable::Template.new("http://example.com/{?one,two,three}/")
+      end
+      it "builds a new pattern with two=nil" do
+        expect(subject.partial_expand(two: nil).pattern).to eq(
+          "http://example.com/{?one}{&three}/"
+        )
+      end
+      it "builds a new pattern with one=nil and two=nil" do
+        expect(subject.partial_expand(one: nil, two: nil).pattern).to eq(
+          "http://example.com/{?three}/"
+        )
+      end
+      it "builds a new pattern with one=1 and two=nil" do
+        expect(subject.partial_expand(one: 1, two: nil).pattern).to eq(
+          "http://example.com/?one=1{&three}/"
+        )
+      end
+      it "builds a new pattern with one=nil and two=2" do
+        expect(subject.partial_expand(one: nil, two: 2).pattern).to eq(
+          "http://example.com/?two=2{&three}/"
+        )
+      end
+      it "builds a new pattern with one=nil" do
+        expect(subject.partial_expand(one: nil).pattern).to eq(
+          "http://example.com/{?two}{&three}/"
+        )
+      end
+    end
     context "partial_expand with query string" do
       subject {
         Addressable::Template.new("http://example.com/{?two,one}/")
@@ -969,6 +1001,24 @@ describe Addressable::Template do
         )
       end
     end
+    context "partial expand with unicode values" do
+      subject do
+        Addressable::Template.new("http://example.com/{resource}/{query}/")
+      end
+      it "normalizes unicode by default" do
+        template = subject.partial_expand("query" => "Cafe\u0301")
+        expect(template.pattern).to eq(
+          "http://example.com/{resource}/Caf%C3%A9/"
+        )
+      end
+
+      it "does not normalize unicode when byte semantics requested" do
+        template = subject.partial_expand({"query" => "Cafe\u0301"}, nil, false)
+        expect(template.pattern).to eq(
+          "http://example.com/{resource}/Cafe%CC%81/"
+        )
+      end
+    end
   end
   describe "Partial expand with strings" do
     context "partial_expand with two simple values" do
@@ -1013,6 +1063,20 @@ describe Addressable::Template do
     end
   end
   describe "Expand" do
+    context "expand with unicode values" do
+      subject do
+        Addressable::Template.new("http://example.com/search/{query}/")
+      end
+      it "normalizes unicode by default" do
+        uri = subject.expand("query" => "Cafe\u0301").to_str
+        expect(uri).to eq("http://example.com/search/Caf%C3%A9/")
+      end
+
+      it "does not normalize unicode when byte semantics requested" do
+        uri = subject.expand({ "query" => "Cafe\u0301" }, nil, false).to_str
+        expect(uri).to eq("http://example.com/search/Cafe%CC%81/")
+      end
+    end
     context "expand with a processor" do
       subject {
         Addressable::Template.new("http://example.com/search/{query}/")

data/spec/addressable/uri_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # coding: utf-8
 # Copyright (C) Bob Aman
 #
@@ -125,14 +127,6 @@ describe Addressable::URI, "when created with a non-string authority" do
   end
 end
 
-describe Addressable::URI, "when created with a non-string authority" do
-  it "should raise an error" do
-    expect(lambda do
-      Addressable::URI.new(:authority => :bogus)
-    end).to raise_error(TypeError)
-  end
-end
-
 describe Addressable::URI, "when created with a non-string path" do
   it "should raise an error" do
     expect(lambda do
@@ -963,6 +957,10 @@ describe Addressable::URI, "when frozen" do
     expect(@uri.normalize.query).to eq("a=1")
   end
 
+  it "returns '/%70a%74%68?a=%31' for #request_uri" do
+    expect(@uri.request_uri).to eq("/%70a%74%68?a=%31")
+  end
+
   it "returns '1%323' for #fragment" do
     expect(@uri.fragment).to eq("1%323")
   end
@@ -1979,15 +1977,29 @@ end
 
 # Section 5.1.2 of RFC 2616
 describe Addressable::URI, "when parsed from " +
-    "'http://www.w3.org/pub/WWW/TheProject.html'" do
+    "'HTTP://www.w3.org/pub/WWW/TheProject.html'" do
   before do
-    @uri = Addressable::URI.parse("http://www.w3.org/pub/WWW/TheProject.html")
+    @uri = Addressable::URI.parse("HTTP://www.w3.org/pub/WWW/TheProject.html")
   end
 
   it "should have the correct request URI" do
     expect(@uri.request_uri).to eq("/pub/WWW/TheProject.html")
   end
 
+  it "should have the correct request URI after assignment" do
+    @uri.request_uri = "/pub/WWW/TheProject.html?"
+    expect(@uri.request_uri).to eq("/pub/WWW/TheProject.html?")
+    expect(@uri.path).to eq("/pub/WWW/TheProject.html")
+    expect(@uri.query).to eq("")
+  end
+
+  it "should have the correct request URI after assignment" do
+    @uri.request_uri = "/some/where/else.html"
+    expect(@uri.request_uri).to eq("/some/where/else.html")
+    expect(@uri.path).to eq("/some/where/else.html")
+    expect(@uri.query).to eq(nil)
+  end
+
   it "should have the correct request URI after assignment" do
     @uri.request_uri = "/some/where/else.html?query?string"
     expect(@uri.request_uri).to eq("/some/where/else.html?query?string")
@@ -2016,7 +2028,7 @@ describe Addressable::URI, "when parsed from " +
 
   it "should correctly convert to a hash" do
     expect(@uri.to_hash).to eq({
-      :scheme => "http",
+      :scheme => "HTTP",
       :user => nil,
       :password => nil,
       :host => "www.w3.org",
@@ -5494,6 +5506,31 @@ describe Addressable::URI, "when given the path '/one/two/'" do
   end
 end
 
+describe Addressable::URI, "when given the tld " do
+  it "'uk' should have a tld of 'uk'" do
+    uri = Addressable::URI.parse("http://example.com")
+    uri.tld = "uk"
+
+    expect(uri.tld).to eq("uk")
+  end
+
+  context "which " do
+    let (:uri) { Addressable::URI.parse("http://comrade.net/path/to/source/") }
+
+    it "contains a subdomain" do
+      uri.tld = "co.uk"
+
+      expect(uri.to_s).to eq("http://comrade.co.uk/path/to/source/")
+    end
+
+    it "is part of the domain" do
+      uri.tld = "com"
+
+      expect(uri.to_s).to eq("http://comrade.com/path/to/source/")
+    end
+  end
+end
+
 describe Addressable::URI, "when given the path " +
     "'c:\\windows\\My Documents 100%20\\foo.txt'" do
   before do
@@ -6231,6 +6268,18 @@ describe Addressable::URI, "when given the input " +
   end
 end
 
+describe Addressable::URI, "when given the input which "\
+  "start with digits and has specified port" do
+  before do
+    @input = "7777.example.org:8089"
+  end
+
+  it "should heuristically parse to 'http://7777.example.org:8089'" do
+    uri = Addressable::URI.heuristic_parse(@input)
+    expect(uri.to_s).to eq("http://7777.example.org:8089")
+  end
+end
+
 describe Addressable::URI, "when given the input " +
     "'feed:///example.com'" do
   before do
@@ -6243,6 +6292,18 @@ describe Addressable::URI, "when given the input " +
   end
 end
 
+describe Addressable::URI, "when given the input " +
+    "'file://localhost/path/to/resource/'" do
+  before do
+    @input = "file://localhost/path/to/resource/"
+  end
+
+  it "should heuristically parse to 'file:///path/to/resource/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.to_s).to eq("file:///path/to/resource/")
+  end
+end
+
 describe Addressable::URI, "when given the input " +
     "'file://path/to/resource/'" do
   before do
@@ -6255,6 +6316,18 @@ describe Addressable::URI, "when given the input " +
   end
 end
 
+describe Addressable::URI, "when given the input " +
+    "'file://///path/to/resource/'" do
+  before do
+    @input = "file:///////path/to/resource/"
+  end
+
+  it "should heuristically parse to 'file:////path/to/resource/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.to_s).to eq("file:////path/to/resource/")
+  end
+end
+
 describe Addressable::URI, "when given the input " +
     "'feed://http://example.com'" do
   before do

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bundler/setup'
 require 'rspec/its'
 
@@ -18,4 +20,5 @@ end
 
 RSpec.configure do |config|
   config.warnings = true
+  config.filter_run_when_matching :focus
 end

data/tasks/clobber.rake

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 desc "Remove all build products"
 task "clobber"

data/tasks/gem.rake

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rubygems/package_task"
 
 namespace :gem do
@@ -20,8 +22,8 @@ namespace :gem do
 
     s.required_ruby_version = '>= 2.0'
 
-    s.add_runtime_dependency 'public_suffix', '~> 2.0', '>= 2.0.2'
-    s.add_development_dependency 'bundler', '~> 1.0'
+    s.add_runtime_dependency 'public_suffix', '>= 2.0.2', '< 4.0'
+    s.add_development_dependency 'bundler', '>= 1.0', '< 3.0'
 
     s.require_path = "lib"
 

data/tasks/git.rake

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 namespace :git do
   namespace :tag do
     desc "List tags from the Git repository"

data/tasks/metrics.rake

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 namespace :metrics do
   task :lines do
     lines, codelines, total_lines, total_codelines = 0, 0, 0, 0

data/tasks/rspec.rake

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rspec/core/rake_task"
 
 namespace :spec do

data/tasks/yard.rake

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rake"
 
 begin

metadata

@@ -1,49 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: addressable
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.6.0
 platform: ruby
 authors:
 - Bob Aman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-04 00:00:00.000000000 Z
+date: 2019-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: public_suffix
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.0.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.0.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 description: |
   Addressable is a replacement for the URI implementation that is part of
   Ruby's standard library. It more closely conforms to the relevant RFCs and