addressable 2.2.3 → 2.7.0

data/lib/addressable/uri.rb

@@ -1,30 +1,29 @@
+# frozen_string_literal: true
+
 # encoding:utf-8
 #--
-# Addressable, Copyright (c) 2006-2010 Bob Aman
+# Copyright (C) Bob Aman
 #
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
 #
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
+#        http://www.apache.org/licenses/LICENSE-2.0
 #
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
 #++
 
+
 require "addressable/version"
 require "addressable/idna"
+require "public_suffix"
 
+##
+# Addressable is a library for processing links and URIs.
 module Addressable
   ##
   # This is an implementation of a URI parser based on
@@ -48,12 +47,34 @@ module Addressable
       UNRESERVED = ALPHA + DIGIT + "\\-\\.\\_\\~"
       PCHAR = UNRESERVED + SUB_DELIMS + "\\:\\@"
       SCHEME = ALPHA + DIGIT + "\\-\\+\\."
+      HOST = UNRESERVED + SUB_DELIMS + "\\[\\:\\]"
       AUTHORITY = PCHAR
       PATH = PCHAR + "\\/"
       QUERY = PCHAR + "\\/\\?"
       FRAGMENT = PCHAR + "\\/\\?"
     end
 
+    SLASH = '/'
+    EMPTY_STR = ''
+
+    URIREGEX = /^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/
+
+    PORT_MAPPING = {
+      "http" => 80,
+      "https" => 443,
+      "ftp" => 21,
+      "tftp" => 69,
+      "sftp" => 22,
+      "ssh" => 22,
+      "svn+ssh" => 22,
+      "telnet" => 23,
+      "nntp" => 119,
+      "gopher" => 70,
+      "wais" => 210,
+      "ldap" => 389,
+      "prospero" => 1525
+    }
+
     ##
     # Returns a URI object based on the parsed string.
     #
@@ -67,7 +88,7 @@ module Addressable
       # If we were given nil, return nil.
       return nil unless uri
       # If a URI object is passed, just return itself.
-      return uri if uri.kind_of?(self)
+      return uri.dup if uri.kind_of?(self)
 
       # If a URI object of the Ruby standard library variety is passed,
       # convert it to a string, then parse the string.
@@ -77,16 +98,15 @@ module Addressable
         uri = uri.to_s
       end
 
-      if !uri.respond_to?(:to_str)
-        raise TypeError, "Can't convert #{uri.class} into String."
-      end
       # Otherwise, convert to a String
-      uri = uri.to_str
+      begin
+        uri = uri.to_str
+      rescue TypeError, NoMethodError
+        raise TypeError, "Can't convert #{uri.class} into String."
+      end if not uri.is_a? String
 
       # This Regexp supplied as an example in RFC 3986, and it works great.
-      uri_regex =
-        /^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/
-      scan = uri.scan(uri_regex)
+      scan = uri.scan(URIREGEX)
       fragments = scan[0]
       scheme = fragments[1]
       authority = fragments[3]
@@ -104,14 +124,18 @@ module Addressable
           user = userinfo.strip[/^([^:]*):?/, 1]
           password = userinfo.strip[/:(.*)$/, 1]
         end
-        host = authority.gsub(/^([^\[\]]*)@/, "").gsub(/:([^:@\[\]]*?)$/, "")
+        host = authority.sub(
+          /^([^\[\]]*)@/, EMPTY_STR
+        ).sub(
+          /:([^:@\[\]]*?)$/, EMPTY_STR
+        )
         port = authority[/:([^:@\[\]]*?)$/, 1]
       end
-      if port == ""
+      if port == EMPTY_STR
         port = nil
       end
 
-      return Addressable::URI.new(
+      return new(
         :scheme => scheme,
         :user => user,
         :password => password,
@@ -141,35 +165,65 @@ module Addressable
       # If we were given nil, return nil.
       return nil unless uri
       # If a URI object is passed, just return itself.
-      return uri if uri.kind_of?(self)
+      return uri.dup if uri.kind_of?(self)
+
+      # If a URI object of the Ruby standard library variety is passed,
+      # convert it to a string, then parse the string.
+      # We do the check this way because we don't want to accidentally
+      # cause a missing constant exception to be thrown.
+      if uri.class.name =~ /^URI\b/
+        uri = uri.to_s
+      end
+
       if !uri.respond_to?(:to_str)
         raise TypeError, "Can't convert #{uri.class} into String."
       end
       # Otherwise, convert to a String
-      uri = uri.to_str.dup
+      uri = uri.to_str.dup.strip
       hints = {
         :scheme => "http"
       }.merge(hints)
       case uri
-      when /^http:\/+/
-        uri.gsub!(/^http:\/+/, "http://")
-      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.sub!(/^/, hints[:scheme] + "://")
+      when /\A\d+\..*:\d+\z/
+        uri = "#{hints[:scheme]}://#{uri}"
+      end
+      match = uri.match(URIREGEX)
+      fragments = match.captures
+      authority = fragments[3]
+      if authority && authority.length > 0
+        new_authority = authority.tr("\\", "/").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)
       if parsed.scheme =~ /^[^\/?#\.]+\.[^\/?#]+$/
         parsed = self.parse(hints[:scheme] + "://" + uri)
       end
       if parsed.path.include?(".")
-        new_host = parsed.path[/^([^\/]+\.[^\/]*)/, 1]
-        if new_host
+        if parsed.path[/\b@\b/]
+          parsed.scheme = "mailto" unless parsed.scheme
+        elsif new_host = parsed.path[/^([^\/]+\.[^\/]*)/, 1]
           parsed.defer_validation do
-            new_path = parsed.path.gsub(
-              Regexp.new("^" + Regexp.escape(new_host)), "")
+            new_path = parsed.path.sub(
+              Regexp.new("^" + Regexp.escape(new_host)), EMPTY_STR)
             parsed.host = new_host
             parsed.path = new_path
             parsed.scheme = hints[:scheme] unless parsed.scheme
@@ -219,26 +273,26 @@ module Addressable
       # Otherwise, convert to a String
       path = path.to_str.strip
 
-      path.gsub!(/^file:\/?\/?/, "") if path =~ /^file:\/?\/?/
-      path = "/" + path if path =~ /^([a-zA-Z])[\|:]/
+      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!(/\\/, "/")
-        if File.exists?(uri.path) &&
+        uri.path.tr!("\\", SLASH)
+        if File.exist?(uri.path) &&
             File.stat(uri.path).directory?
-          uri.path.gsub!(/\/$/, "")
+          uri.path.chomp!(SLASH)
           uri.path = uri.path + '/'
         end
 
         # If the path is absolute, set the scheme and host.
-        if uri.path =~ /^\//
+        if uri.path.start_with?(SLASH)
           uri.scheme = "file"
-          uri.host = ""
+          uri.host = EMPTY_STR
         end
         uri.normalize!
       end
@@ -273,6 +327,21 @@ module Addressable
       return result
     end
 
+    ##
+    # Tables used to optimize encoding operations in `self.encode_component`
+    # and `self.normalize_component`
+    SEQUENCE_ENCODING_TABLE = Hash.new do |hash, sequence|
+      hash[sequence] = sequence.unpack("C*").map do |c|
+        format("%02x", c)
+      end.join
+    end
+
+    SEQUENCE_UPCASED_PERCENT_ENCODING_TABLE = Hash.new do |hash, sequence|
+      hash[sequence] = sequence.unpack("C*").map do |c|
+        format("%%%02X", c)
+      end.join
+    end
+
     ##
     # Percent encodes a URI component.
     #
@@ -291,6 +360,12 @@ module Addressable
     #   value is the reserved plus unreserved character classes specified in
     #   <a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>.
     #
+    # @param [Regexp] upcase_encoded
+    #   A string of characters that may already be percent encoded, and whose
+    #   encodings should be upcased. This allows normalization of percent
+    #   encodings for characters not included in the
+    #   <code>character_class</code>.
+    #
     # @return [String] The encoded component.
     #
     # @example
@@ -303,12 +378,23 @@ module Addressable
     #   )
     #   => "simple%2Fexample"
     def self.encode_component(component, character_class=
-        CharacterClasses::RESERVED + CharacterClasses::UNRESERVED)
+        CharacterClasses::RESERVED + CharacterClasses::UNRESERVED,
+        upcase_encoded='')
       return nil if component.nil?
-      if !component.respond_to?(:to_str)
+
+      begin
+        if component.kind_of?(Symbol) ||
+            component.kind_of?(Numeric) ||
+            component.kind_of?(TrueClass) ||
+            component.kind_of?(FalseClass)
+          component = component.to_s
+        else
+          component = component.to_str
+        end
+      rescue TypeError, NoMethodError
         raise TypeError, "Can't convert #{component.class} into String."
-      end
-      component = component.to_str
+      end if !component.is_a? String
+
       if ![String, Regexp].include?(character_class.class)
         raise TypeError,
           "Expected String or Regexp, got #{character_class.inspect}"
@@ -316,15 +402,22 @@ module Addressable
       if character_class.kind_of?(String)
         character_class = /[^#{character_class}]/
       end
-      if component.respond_to?(:force_encoding)
-        # We can't perform regexps on invalid UTF sequences, but
-        # here we need to, so switch to ASCII.
-        component = component.dup
-        component.force_encoding(Encoding::ASCII_8BIT)
-      end
-      return component.gsub(character_class) do |sequence|
-        (sequence.unpack('C*').map { |c| "%" + ("%02x" % c).upcase }).join("")
+      # We can't perform regexps on invalid UTF sequences, but
+      # here we need to, so switch to ASCII.
+      component = component.dup
+      component.force_encoding(Encoding::ASCII_8BIT)
+      # Avoiding gsub! because there are edge cases with frozen strings
+      component = component.gsub(character_class) do |sequence|
+        SEQUENCE_UPCASED_PERCENT_ENCODING_TABLE[sequence]
+      end
+      if upcase_encoded.length > 0
+        upcase_encoded_chars = upcase_encoded.chars.map do |char|
+          SEQUENCE_ENCODING_TABLE[char]
+        end
+        component = component.gsub(/%(#{upcase_encoded_chars.join('|')})/,
+                                   &:upcase)
       end
+      return component
     end
 
     class << self
@@ -340,32 +433,46 @@ module Addressable
     # @param [String, Addressable::URI, #to_str] uri
     #   The URI or component to unencode.
     #
-    # @param [Class] returning
+    # @param [Class] return_type
     #   The type of object to return.
     #   This value may only be set to <code>String</code> or
     #   <code>Addressable::URI</code>. All other values are invalid. Defaults
     #   to <code>String</code>.
     #
+    # @param [String] leave_encoded
+    #   A string of characters to leave encoded. If a percent encoded character
+    #   in this list is encountered then it will remain percent encoded.
+    #
     # @return [String, Addressable::URI]
     #   The unencoded component or URI.
-    #   The return type is determined by the <code>returning</code> parameter.
-    def self.unencode(uri, returning=String)
+    #   The return type is determined by the <code>return_type</code>
+    #   parameter.
+    def self.unencode(uri, return_type=String, leave_encoded='')
       return nil if uri.nil?
-      if !uri.respond_to?(:to_str)
+
+      begin
+        uri = uri.to_str
+      rescue NoMethodError, TypeError
         raise TypeError, "Can't convert #{uri.class} into String."
-      end
-      if ![String, ::Addressable::URI].include?(returning)
+      end if !uri.is_a? String
+      if ![String, ::Addressable::URI].include?(return_type)
         raise TypeError,
           "Expected Class (String or Addressable::URI), " +
-          "got #{returning.inspect}"
-      end
-      result = uri.to_str.gsub(/%[0-9a-f]{2}/i) do |sequence|
-        sequence[1..3].to_i(16).chr
-      end
-      result.force_encoding("utf-8") if result.respond_to?(:force_encoding)
-      if returning == String
+          "got #{return_type.inspect}"
+      end
+      uri = uri.dup
+      # Seriously, only use UTF-8. I'm really not kidding!
+      uri.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")
+        leave_encoded.include?(c) ? sequence : c
+      end
+      result.force_encoding("utf-8")
+      if return_type == String
         return result
-      elsif returning == ::Addressable::URI
+      elsif return_type == ::Addressable::URI
         return ::Addressable::URI.parse(result)
       end
     end
@@ -387,14 +494,21 @@ module Addressable
     #   is passed, the <code>String</code> must be formatted as a regular
     #   expression character class. (Do not include the surrounding square
     #   brackets.)  For example, <code>"b-zB-Z0-9"</code> would cause
-    #   everything but the letters 'b' through 'z' and the numbers '0' through
-    #  '9' to be percent encoded. If a <code>Regexp</code> is passed, the
-    #   value <code>/[^b-zB-Z0-9]/</code> would have the same effect. A set of
-    #   useful <code>String</code> values may be found in the
+    #   everything but the letters 'b' through 'z' and the numbers '0'
+    #   through '9' to be percent encoded. If a <code>Regexp</code> is passed,
+    #   the value <code>/[^b-zB-Z0-9]/</code> would have the same effect. A
+    #   set of useful <code>String</code> values may be found in the
     #   <code>Addressable::URI::CharacterClasses</code> module. The default
     #   value is the reserved plus unreserved character classes specified in
     #   <a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>.
     #
+    # @param [String] leave_encoded
+    #   When <code>character_class</code> is a <code>String</code> then
+    #   <code>leave_encoded</code> is a string of characters that should remain
+    #   percent encoded while normalizing the component; if they appear percent
+    #   encoded in the original component, then they will be upcased ("%2f"
+    #   normalized to "%2F") but otherwise left alone.
+    #
     # @return [String] The normalized component.
     #
     # @example
@@ -409,35 +523,54 @@ module Addressable
     #     Addressable::URI::CharacterClasses::UNRESERVED
     #   )
     #   => "simple%2Fexample"
+    #   Addressable::URI.normalize_component(
+    #     "one%20two%2fthree%26four",
+    #     "0-9a-zA-Z &/",
+    #     "/"
+    #   )
+    #   => "one two%2Fthree&four"
     def self.normalize_component(component, character_class=
-        CharacterClasses::RESERVED + CharacterClasses::UNRESERVED)
+        CharacterClasses::RESERVED + CharacterClasses::UNRESERVED,
+        leave_encoded='')
       return nil if component.nil?
-      if !component.respond_to?(:to_str)
+
+      begin
+        component = component.to_str
+      rescue NoMethodError, TypeError
         raise TypeError, "Can't convert #{component.class} into String."
-      end
-      component = component.to_str
+      end if !component.is_a? String
+
       if ![String, Regexp].include?(character_class.class)
         raise TypeError,
           "Expected String or Regexp, got #{character_class.inspect}"
       end
       if character_class.kind_of?(String)
-        character_class = /[^#{character_class}]/
-      end
-      if component.respond_to?(:force_encoding)
-        # We can't perform regexps on invalid UTF sequences, but
-        # here we need to, so switch to ASCII.
-        component = component.dup
-        component.force_encoding(Encoding::ASCII_8BIT)
+        leave_re = if leave_encoded.length > 0
+          character_class = "#{character_class}%" unless character_class.include?('%')
+
+          "|%(?!#{leave_encoded.chars.map do |char|
+            seq = SEQUENCE_ENCODING_TABLE[char]
+            [seq.upcase, seq.downcase]
+          end.flatten.join('|')})"
+        end
+
+        character_class = /[^#{character_class}]#{leave_re}/
       end
-      unencoded = self.unencode_component(component)
+      # We can't perform regexps on invalid UTF sequences, but
+      # here we need to, so switch to ASCII.
+      component = component.dup
+      component.force_encoding(Encoding::ASCII_8BIT)
+      unencoded = self.unencode_component(component, String, leave_encoded)
       begin
         encoded = self.encode_component(
           Addressable::IDNA.unicode_normalize_kc(unencoded),
-          character_class
+          character_class,
+          leave_encoded
         )
       rescue ArgumentError
         encoded = self.encode_component(unencoded)
       end
+      encoded.force_encoding(Encoding::UTF_8)
       return encoded
     end
 
@@ -447,7 +580,7 @@ module Addressable
     # @param [String, Addressable::URI, #to_str] uri
     #   The URI to encode.
     #
-    # @param [Class] returning
+    # @param [Class] return_type
     #   The type of object to return.
     #   This value may only be set to <code>String</code> or
     #   <code>Addressable::URI</code>. All other values are invalid. Defaults
@@ -455,18 +588,23 @@ module Addressable
     #
     # @return [String, Addressable::URI]
     #   The encoded URI.
-    #   The return type is determined by the <code>returning</code> parameter.
-    def self.encode(uri, returning=String)
+    #   The return type is determined by the <code>return_type</code>
+    #   parameter.
+    def self.encode(uri, return_type=String)
       return nil if uri.nil?
-      if !uri.respond_to?(:to_str)
+
+      begin
+        uri = uri.to_str
+      rescue NoMethodError, TypeError
         raise TypeError, "Can't convert #{uri.class} into String."
-      end
-      if ![String, ::Addressable::URI].include?(returning)
+      end if !uri.is_a? String
+
+      if ![String, ::Addressable::URI].include?(return_type)
         raise TypeError,
           "Expected Class (String or Addressable::URI), " +
-          "got #{returning.inspect}"
+          "got #{return_type.inspect}"
       end
-      uri_object = uri.kind_of?(self) ? uri : self.parse(uri.to_str)
+      uri_object = uri.kind_of?(self) ? uri : self.parse(uri)
       encoded_uri = Addressable::URI.new(
         :scheme => self.encode_component(uri_object.scheme,
           Addressable::URI::CharacterClasses::SCHEME),
@@ -479,9 +617,9 @@ module Addressable
         :fragment => self.encode_component(uri_object.fragment,
           Addressable::URI::CharacterClasses::FRAGMENT)
       )
-      if returning == String
+      if return_type == String
         return encoded_uri.to_s
-      elsif returning == ::Addressable::URI
+      elsif return_type == ::Addressable::URI
         return encoded_uri
       end
     end
@@ -497,7 +635,7 @@ module Addressable
     # @param [String, Addressable::URI, #to_str] uri
     #   The URI to encode.
     #
-    # @param [Class] returning
+    # @param [Class] return_type
     #   The type of object to return.
     #   This value may only be set to <code>String</code> or
     #   <code>Addressable::URI</code>. All other values are invalid. Defaults
@@ -505,23 +643,27 @@ module Addressable
     #
     # @return [String, Addressable::URI]
     #   The encoded URI.
-    #   The return type is determined by the <code>returning</code> parameter.
-    def self.normalized_encode(uri, returning=String)
-      if !uri.respond_to?(:to_str)
+    #   The return type is determined by the <code>return_type</code>
+    #   parameter.
+    def self.normalized_encode(uri, return_type=String)
+      begin
+        uri = uri.to_str
+      rescue NoMethodError, TypeError
         raise TypeError, "Can't convert #{uri.class} into String."
-      end
-      if ![String, ::Addressable::URI].include?(returning)
+      end if !uri.is_a? String
+
+      if ![String, ::Addressable::URI].include?(return_type)
         raise TypeError,
           "Expected Class (String or Addressable::URI), " +
-          "got #{returning.inspect}"
+          "got #{return_type.inspect}"
       end
-      uri_object = uri.kind_of?(self) ? uri : self.parse(uri.to_str)
+      uri_object = uri.kind_of?(self) ? uri : self.parse(uri)
       components = {
         :scheme => self.unencode_component(uri_object.scheme),
         :user => self.unencode_component(uri_object.user),
         :password => self.unencode_component(uri_object.password),
         :host => self.unencode_component(uri_object.host),
-        :port => uri_object.port,
+        :port => (uri_object.port.nil? ? nil : uri_object.port.to_s),
         :path => self.unencode_component(uri_object.path),
         :query => self.unencode_component(uri_object.query),
         :fragment => self.unencode_component(uri_object.fragment)
@@ -553,9 +695,9 @@ module Addressable
         :fragment => self.encode_component(components[:fragment],
           Addressable::URI::CharacterClasses::FRAGMENT)
       )
-      if returning == String
+      if return_type == String
         return encoded_uri.to_s
-      elsif returning == ::Addressable::URI
+      elsif return_type == ::Addressable::URI
         return encoded_uri
       end
     end
@@ -581,9 +723,18 @@ module Addressable
       else
         raise TypeError, "Can't convert #{form_values.class} into Array."
       end
-      form_values = form_values.map do |(key, value)|
-        [key.to_s, value.to_s]
+
+      form_values = form_values.inject([]) do |accu, (key, value)|
+        if value.kind_of?(Array)
+          value.each do |v|
+            accu << [key.to_s, v.to_s]
+          end
+        else
+          accu << [key.to_s, value.to_s]
+        end
+        accu
       end
+
       if sort
         # Useful for OAuth and optimizing caching systems
         form_values = form_values.sort
@@ -601,9 +752,9 @@ module Addressable
           ).gsub("%20", "+")
         ]
       end
-      return (escaped_form_values.map do |(key, value)|
+      return escaped_form_values.map do |(key, value)|
         "#{key}=#{value}"
-      end).join("&")
+      end.join("&")
     end
 
     ##
@@ -681,8 +832,30 @@ module Addressable
         self.authority = options[:authority] if options[:authority]
         self.path = options[:path] if options[:path]
         self.query = options[:query] if options[:query]
+        self.query_values = options[:query_values] if options[:query_values]
         self.fragment = options[:fragment] if options[:fragment]
       end
+      self.to_s
+    end
+
+    ##
+    # Freeze URI, initializing instance variables.
+    #
+    # @return [Addressable::URI] The frozen URI object.
+    def freeze
+      self.normalized_scheme
+      self.normalized_user
+      self.normalized_password
+      self.normalized_userinfo
+      self.normalized_host
+      self.normalized_port
+      self.normalized_authority
+      self.normalized_site
+      self.normalized_path
+      self.normalized_query
+      self.normalized_fragment
+      self.hash
+      super
     end
 
     ##
@@ -690,7 +863,7 @@ module Addressable
     #
     # @return [String] The scheme component.
     def scheme
-      return @scheme ||= nil
+      return defined?(@scheme) ? @scheme : nil
     end
 
     ##
@@ -698,20 +871,20 @@ module Addressable
     #
     # @return [String] The scheme component, normalized.
     def normalized_scheme
-      @normalized_scheme ||= (begin
-        if self.scheme != nil
-          if self.scheme =~ /^\s*ssh\+svn\s*$/i
-            "svn+ssh"
-          else
-            Addressable::URI.normalize_component(
-              self.scheme.strip.downcase,
-              Addressable::URI::CharacterClasses::SCHEME
-            )
-          end
+      return nil unless self.scheme
+      @normalized_scheme ||= begin
+        if self.scheme =~ /^\s*ssh\+svn\s*$/i
+          "svn+ssh".dup
         else
-          nil
+          Addressable::URI.normalize_component(
+            self.scheme.strip.downcase,
+            Addressable::URI::CharacterClasses::SCHEME
+          )
         end
-      end)
+      end
+      # All normalized values should be UTF-8
+      @normalized_scheme.force_encoding(Encoding::UTF_8) if @normalized_scheme
+      @normalized_scheme
     end
 
     ##
@@ -719,24 +892,20 @@ module Addressable
     #
     # @param [String, #to_str] new_scheme The new scheme component.
     def scheme=(new_scheme)
-      # Check for frozenness
-      raise TypeError, "Can't modify frozen URI." if self.frozen?
-
       if new_scheme && !new_scheme.respond_to?(:to_str)
         raise TypeError, "Can't convert #{new_scheme.class} into String."
       elsif new_scheme
         new_scheme = new_scheme.to_str
       end
-      if new_scheme && new_scheme !~ /[a-z][a-z0-9\.\+\-]*/i
-        raise InvalidURIError, "Invalid scheme format."
+      if new_scheme && new_scheme !~ /\A[a-z][a-z0-9\.\+\-]*\z/i
+        raise InvalidURIError, "Invalid scheme format: #{new_scheme}"
       end
       @scheme = new_scheme
-      @scheme = nil if @scheme.to_s.strip == ""
+      @scheme = nil if @scheme.to_s.strip.empty?
 
-      # Reset dependant values
-      @normalized_scheme = nil
-      @uri_string = nil
-      @hash = nil
+      # Reset dependent values
+      remove_instance_variable(:@normalized_scheme) if defined?(@normalized_scheme)
+      remove_composite_values
 
       # Ensure we haven't created an invalid URI
       validate()
@@ -747,7 +916,7 @@ module Addressable
     #
     # @return [String] The user component.
     def user
-      return @user ||= nil
+      return defined?(@user) ? @user : nil
     end
 
     ##
@@ -755,21 +924,22 @@ module Addressable
     #
     # @return [String] The user component, normalized.
     def normalized_user
-      @normalized_user ||= (begin
-        if self.user
-          if normalized_scheme =~ /https?/ && self.user.strip == "" &&
-              (!self.password || self.password.strip == "")
-            nil
-          else
-            Addressable::URI.normalize_component(
-              self.user.strip,
-              Addressable::URI::CharacterClasses::UNRESERVED
-            )
-          end
-        else
+      return nil unless self.user
+      return @normalized_user if defined?(@normalized_user)
+      @normalized_user ||= begin
+        if normalized_scheme =~ /https?/ && self.user.strip.empty? &&
+            (!self.password || self.password.strip.empty?)
           nil
+        else
+          Addressable::URI.normalize_component(
+            self.user.strip,
+            Addressable::URI::CharacterClasses::UNRESERVED
+          )
         end
-      end)
+      end
+      # All normalized values should be UTF-8
+      @normalized_user.force_encoding(Encoding::UTF_8) if @normalized_user
+      @normalized_user
     end
 
     ##
@@ -777,27 +947,22 @@ module Addressable
     #
     # @param [String, #to_str] new_user The new user component.
     def user=(new_user)
-      # Check for frozenness
-      raise TypeError, "Can't modify frozen URI." if self.frozen?
-
       if new_user && !new_user.respond_to?(:to_str)
         raise TypeError, "Can't convert #{new_user.class} into String."
       end
       @user = new_user ? new_user.to_str : nil
 
       # You can't have a nil user with a non-nil password
-      @password ||= nil
-      if @password != nil
-        @user = "" if @user.nil?
+      if password != nil
+        @user = EMPTY_STR if @user.nil?
       end
 
-      # Reset dependant values
-      @userinfo = nil
-      @normalized_userinfo = nil
-      @authority = nil
-      @normalized_user = nil
-      @uri_string = nil
-      @hash = nil
+      # Reset dependent values
+      remove_instance_variable(:@userinfo) if defined?(@userinfo)
+      remove_instance_variable(:@normalized_userinfo) if defined?(@normalized_userinfo)
+      remove_instance_variable(:@authority) if defined?(@authority)
+      remove_instance_variable(:@normalized_user) if defined?(@normalized_user)
+      remove_composite_values
 
       # Ensure we haven't created an invalid URI
       validate()
@@ -808,7 +973,7 @@ module Addressable
     #
     # @return [String] The password component.
     def password
-      return @password ||= nil
+      return defined?(@password) ? @password : nil
     end
 
     ##
@@ -816,21 +981,24 @@ module Addressable
     #
     # @return [String] The password component, normalized.
     def normalized_password
-      @normalized_password ||= (begin
-        if self.password
-          if normalized_scheme =~ /https?/ && self.password.strip == "" &&
-              (!self.user || self.user.strip == "")
-            nil
-          else
-            Addressable::URI.normalize_component(
-              self.password.strip,
-              Addressable::URI::CharacterClasses::UNRESERVED
-            )
-          end
-        else
+      return nil unless self.password
+      return @normalized_password if defined?(@normalized_password)
+      @normalized_password ||= begin
+        if self.normalized_scheme =~ /https?/ && self.password.strip.empty? &&
+            (!self.user || self.user.strip.empty?)
           nil
+        else
+          Addressable::URI.normalize_component(
+            self.password.strip,
+            Addressable::URI::CharacterClasses::UNRESERVED
+          )
         end
-      end)
+      end
+      # All normalized values should be UTF-8
+      if @normalized_password
+        @normalized_password.force_encoding(Encoding::UTF_8)
+      end
+      @normalized_password
     end
 
     ##
@@ -838,9 +1006,6 @@ module Addressable
     #
     # @param [String, #to_str] new_password The new password component.
     def password=(new_password)
-      # Check for frozenness
-      raise TypeError, "Can't modify frozen URI." if self.frozen?
-
       if new_password && !new_password.respond_to?(:to_str)
         raise TypeError, "Can't convert #{new_password.class} into String."
       end
@@ -850,16 +1015,15 @@ module Addressable
       @password ||= nil
       @user ||= nil
       if @password != nil
-        @user = "" if @user.nil?
+        @user = EMPTY_STR if @user.nil?
       end
 
-      # Reset dependant values
-      @userinfo = nil
-      @normalized_userinfo = nil
-      @authority = nil
-      @normalized_password = nil
-      @uri_string = nil
-      @hash = nil
+      # Reset dependent values
+      remove_instance_variable(:@userinfo) if defined?(@userinfo)
+      remove_instance_variable(:@normalized_userinfo) if defined?(@normalized_userinfo)
+      remove_instance_variable(:@authority) if defined?(@authority)
+      remove_instance_variable(:@normalized_password) if defined?(@normalized_password)
+      remove_composite_values
 
       # Ensure we haven't created an invalid URI
       validate()
@@ -871,17 +1035,15 @@ module Addressable
     #
     # @return [String] The userinfo component.
     def userinfo
-      @userinfo ||= (begin
-        current_user = self.user
-        current_password = self.password
-        if !current_user && !current_password
-          nil
-        elsif current_user && current_password
+      current_user = self.user
+      current_password = self.password
+      (current_user || current_password) && @userinfo ||= begin
+        if current_user && current_password
           "#{current_user}:#{current_password}"
         elsif current_user && !current_password
           "#{current_user}"
         end
-      end)
+      end
     end
 
     ##
@@ -889,17 +1051,24 @@ module Addressable
     #
     # @return [String] The userinfo component, normalized.
     def normalized_userinfo
-      @normalized_userinfo ||= (begin
+      return nil unless self.userinfo
+      return @normalized_userinfo if defined?(@normalized_userinfo)
+      @normalized_userinfo ||= begin
         current_user = self.normalized_user
         current_password = self.normalized_password
         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)
+      end
+      # All normalized values should be UTF-8
+      if @normalized_userinfo
+        @normalized_userinfo.force_encoding(Encoding::UTF_8)
+      end
+      @normalized_userinfo
     end
 
     ##
@@ -907,9 +1076,6 @@ module Addressable
     #
     # @param [String, #to_str] new_userinfo The new userinfo component.
     def userinfo=(new_userinfo)
-      # Check for frozenness
-      raise TypeError, "Can't modify frozen URI." if self.frozen?
-
       if new_userinfo && !new_userinfo.respond_to?(:to_str)
         raise TypeError, "Can't convert #{new_userinfo.class} into String."
       end
@@ -926,10 +1092,9 @@ module Addressable
       self.password = new_password
       self.user = new_user
 
-      # Reset dependant values
-      @authority = nil
-      @uri_string = nil
-      @hash = nil
+      # Reset dependent values
+      remove_instance_variable(:@authority) if defined?(@authority)
+      remove_composite_values
 
       # Ensure we haven't created an invalid URI
       validate()
@@ -940,7 +1105,7 @@ module Addressable
     #
     # @return [String] The host component.
     def host
-      return @host ||= nil
+      return defined?(@host) ? @host : nil
     end
 
     ##
@@ -948,24 +1113,27 @@ module Addressable
     #
     # @return [String] The host component, normalized.
     def normalized_host
-      @normalized_host ||= (begin
-        if self.host != nil
-          if self.host.strip != ""
-            result = ::Addressable::IDNA.to_ascii(
-              self.class.unencode_component(self.host.strip.downcase)
-            )
-            if result[-1..-1] == "."
-              # Trailing dots are unnecessary
-              result = result[0...-1]
-            end
-            result
-          else
-            ""
+      return nil unless self.host
+      @normalized_host ||= begin
+        if !self.host.strip.empty?
+          result = ::Addressable::IDNA.to_ascii(
+            URI.unencode_component(self.host.strip.downcase)
+          )
+          if result =~ /[^\.]\.$/
+            # Single trailing dots are unnecessary.
+            result = result[0...-1]
           end
+          result = Addressable::URI.normalize_component(
+            result,
+            CharacterClasses::HOST)
+          result
         else
-          nil
+          EMPTY_STR.dup
         end
-      end)
+      end
+      # All normalized values should be UTF-8
+      @normalized_host.force_encoding(Encoding::UTF_8) if @normalized_host
+      @normalized_host
     end
 
     ##
@@ -973,45 +1141,95 @@ module Addressable
     #
     # @param [String, #to_str] new_host The new host component.
     def host=(new_host)
-      # Check for frozenness
-      raise TypeError, "Can't modify frozen URI." if self.frozen?
-
       if new_host && !new_host.respond_to?(:to_str)
         raise TypeError, "Can't convert #{new_host.class} into String."
       end
       @host = new_host ? new_host.to_str : nil
 
-      # Reset dependant values
-      @authority = nil
-      @normalized_host = nil
-      @uri_string = nil
-      @hash = nil
+      # Reset dependent values
+      remove_instance_variable(:@authority) if defined?(@authority)
+      remove_instance_variable(:@normalized_host) if defined?(@normalized_host)
+      remove_composite_values
 
       # Ensure we haven't created an invalid URI
       validate()
     end
 
+    ##
+    # This method is same as URI::Generic#host except
+    # brackets for IPv6 (and 'IPvFuture') addresses are removed.
+    #
+    # @see Addressable::URI#host
+    #
+    # @return [String] The hostname for this URI.
+    def hostname
+      v = self.host
+      /\A\[(.*)\]\z/ =~ v ? $1 : v
+    end
+
+    ##
+    # This method is same as URI::Generic#host= except
+    # the argument can be a bare IPv6 address (or 'IPvFuture').
+    #
+    # @see Addressable::URI#host=
+    #
+    # @param [String, #to_str] new_hostname The new hostname for this URI.
+    def hostname=(new_hostname)
+      if new_hostname &&
+          (new_hostname.respond_to?(:ipv4?) || new_hostname.respond_to?(:ipv6?))
+        new_hostname = new_hostname.to_s
+      elsif new_hostname && !new_hostname.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{new_hostname.class} into String."
+      end
+      v = new_hostname ? new_hostname.to_str : nil
+      v = "[#{v}]" if /\A\[.*\]\z/ !~ v && /:/ =~ v
+      self.host = v
+    end
+
+    ##
+    # Returns the top-level domain for this host.
+    #
+    # @example
+    #   Addressable::URI.parse("http://www.example.co.uk").tld # => "co.uk"
+    def tld
+      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 = host.sub(/#{tld}\z/, new_tld)
+      self.host = PublicSuffix::Domain.new(replaced_tld).to_s
+    end
+
+    ##
+    # Returns the public suffix domain for this host.
+    #
+    # @example
+    #   Addressable::URI.parse("http://www.example.co.uk").domain # => "example.co.uk"
+    def domain
+      PublicSuffix.domain(self.host, ignore_private: true)
+    end
+
     ##
     # The authority component for this URI.
     # Combines the user, password, host, and port components.
     #
     # @return [String] The authority component.
     def authority
-      @authority ||= (begin
-        if self.host.nil?
-          nil
-        else
-          authority = ""
-          if self.userinfo != nil
-            authority << "#{self.userinfo}@"
-          end
-          authority << self.host
-          if self.port != nil
-            authority << ":#{self.port}"
-          end
-          authority
+      self.host && @authority ||= begin
+        authority = String.new
+        if self.userinfo != nil
+          authority << "#{self.userinfo}@"
+        end
+        authority << self.host
+        if self.port != nil
+          authority << ":#{self.port}"
         end
-      end)
+        authority
+      end
     end
 
     ##
@@ -1019,21 +1237,23 @@ module Addressable
     #
     # @return [String] The authority component, normalized.
     def normalized_authority
-      @normalized_authority ||= (begin
-        if self.normalized_host.nil?
-          nil
-        else
-          authority = ""
-          if self.normalized_userinfo != nil
-            authority << "#{self.normalized_userinfo}@"
-          end
-          authority << self.normalized_host
-          if self.normalized_port != nil
-            authority << ":#{self.normalized_port}"
-          end
-          authority
+      return nil unless self.authority
+      @normalized_authority ||= begin
+        authority = String.new
+        if self.normalized_userinfo != nil
+          authority << "#{self.normalized_userinfo}@"
         end
-      end)
+        authority << self.normalized_host
+        if self.normalized_port != nil
+          authority << ":#{self.normalized_port}"
+        end
+        authority
+      end
+      # All normalized values should be UTF-8
+      if @normalized_authority
+        @normalized_authority.force_encoding(Encoding::UTF_8)
+      end
+      @normalized_authority
     end
 
     ##
@@ -1041,9 +1261,6 @@ module Addressable
     #
     # @param [String, #to_str] new_authority The new authority component.
     def authority=(new_authority)
-      # Check for frozenness
-      raise TypeError, "Can't modify frozen URI." if self.frozen?
-
       if new_authority
         if !new_authority.respond_to?(:to_str)
           raise TypeError, "Can't convert #{new_authority.class} into String."
@@ -1054,8 +1271,11 @@ module Addressable
           new_user = new_userinfo.strip[/^([^:]*):?/, 1]
           new_password = new_userinfo.strip[/:(.*)$/, 1]
         end
-        new_host =
-          new_authority.gsub(/^([^\[\]]*)@/, "").gsub(/:([^:@\[\]]*?)$/, "")
+        new_host = new_authority.sub(
+          /^([^\[\]]*)@/, EMPTY_STR
+        ).sub(
+          /:([^:@\[\]]*?)$/, EMPTY_STR
+        )
         new_port =
           new_authority[/:([^:@\[\]]*?)$/, 1]
       end
@@ -1066,12 +1286,67 @@ module Addressable
       self.host = defined?(new_host) ? new_host : nil
       self.port = defined?(new_port) ? new_port : nil
 
-      # Reset dependant values
-      @inferred_port = nil
-      @userinfo = nil
-      @normalized_userinfo = nil
-      @uri_string = nil
-      @hash = nil
+      # Reset dependent values
+      remove_instance_variable(:@userinfo) if defined?(@userinfo)
+      remove_instance_variable(:@normalized_userinfo) if defined?(@normalized_userinfo)
+      remove_composite_values
+
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+
+    ##
+    # The origin for this URI, serialized to ASCII, as per
+    # RFC 6454, section 6.2.
+    #
+    # @return [String] The serialized origin.
+    def origin
+      if self.scheme && self.authority
+        if self.normalized_port
+          "#{self.normalized_scheme}://#{self.normalized_host}" +
+          ":#{self.normalized_port}"
+        else
+          "#{self.normalized_scheme}://#{self.normalized_host}"
+        end
+      else
+        "null"
+      end
+    end
+
+    ##
+    # Sets the origin for this URI, serialized to ASCII, as per
+    # RFC 6454, section 6.2. This assignment will reset the `userinfo`
+    # component.
+    #
+    # @param [String, #to_str] new_origin The new origin component.
+    def origin=(new_origin)
+      if new_origin
+        if !new_origin.respond_to?(:to_str)
+          raise TypeError, "Can't convert #{new_origin.class} into String."
+        end
+        new_origin = new_origin.to_str
+        new_scheme = new_origin[/^([^:\/?#]+):\/\//, 1]
+        unless new_scheme
+          raise InvalidURIError, 'An origin cannot omit the scheme.'
+        end
+        new_host = new_origin[/:\/\/([^\/?#:]+)/, 1]
+        unless new_host
+          raise InvalidURIError, 'An origin cannot omit the host.'
+        end
+        new_port = new_origin[/:([^:@\[\]\/]*?)$/, 1]
+      end
+
+      self.scheme = defined?(new_scheme) ? new_scheme : nil
+      self.host = defined?(new_host) ? new_host : nil
+      self.port = defined?(new_port) ? new_port : nil
+      self.userinfo = nil
+
+      # Reset dependent values
+      remove_instance_variable(:@userinfo) if defined?(@userinfo)
+      remove_instance_variable(:@normalized_userinfo) if defined?(@normalized_userinfo)
+      remove_instance_variable(:@authority) if defined?(@authority)
+      remove_instance_variable(:@normalized_authority) if defined?(@normalized_authority)
+      remove_composite_values
 
       # Ensure we haven't created an invalid URI
       validate()
@@ -1088,21 +1363,7 @@ module Addressable
     # numbers. Adding new schemes to this hash, as necessary, will allow
     # for better URI normalization.
     def self.port_mapping
-      @port_mapping ||= {
-        "http" => 80,
-        "https" => 443,
-        "ftp" => 21,
-        "tftp" => 69,
-        "sftp" => 22,
-        "ssh" => 22,
-        "svn+ssh" => 22,
-        "telnet" => 23,
-        "nntp" => 119,
-        "gopher" => 70,
-        "wais" => 210,
-        "ldap" => 389,
-        "prospero" => 1525
-      }
+      PORT_MAPPING
     end
 
     ##
@@ -1112,7 +1373,7 @@ module Addressable
     #
     # @return [Integer] The port component.
     def port
-      return @port ||= nil
+      return defined?(@port) ? @port : nil
     end
 
     ##
@@ -1120,13 +1381,15 @@ module Addressable
     #
     # @return [Integer] The port component, normalized.
     def normalized_port
-      @normalized_port ||= (begin
-        if self.class.port_mapping[normalized_scheme] == self.port
+      return nil unless self.port
+      return @normalized_port if defined?(@normalized_port)
+      @normalized_port ||= begin
+        if URI.port_mapping[self.normalized_scheme] == self.port
           nil
         else
           self.port
         end
-      end)
+      end
     end
 
     ##
@@ -1134,12 +1397,14 @@ module Addressable
     #
     # @param [String, Integer, #to_s] new_port The new port component.
     def port=(new_port)
-      # Check for frozenness
-      raise TypeError, "Can't modify frozen URI." if self.frozen?
-
       if new_port != nil && new_port.respond_to?(:to_str)
         new_port = Addressable::URI.unencode_component(new_port.to_str)
       end
+
+      if new_port.respond_to?(:valid_encoding?) && !new_port.valid_encoding?
+        raise InvalidURIError, "Invalid encoding in port"
+      end
+
       if new_port != nil && !(new_port.to_s =~ /^\d+$/)
         raise InvalidURIError,
           "Invalid port number: #{new_port.inspect}"
@@ -1148,12 +1413,10 @@ module Addressable
       @port = new_port.to_s.to_i
       @port = nil if @port == 0
 
-      # Reset dependant values
-      @authority = nil
-      @inferred_port = nil
-      @normalized_port = nil
-      @uri_string = nil
-      @hash = nil
+      # Reset dependent values
+      remove_instance_variable(:@authority) if defined?(@authority)
+      remove_instance_variable(:@normalized_port) if defined?(@normalized_port)
+      remove_composite_values
 
       # Ensure we haven't created an invalid URI
       validate()
@@ -1166,17 +1429,21 @@ module Addressable
     #
     # @return [Integer] The inferred port component.
     def inferred_port
-      @inferred_port ||= (begin
-        if port.to_i == 0
-          if scheme
-            self.class.port_mapping[scheme.strip.downcase]
-          else
-            nil
-          end
-        else
-          port.to_i
-        end
-      end)
+      if self.port.to_i == 0
+        self.default_port
+      else
+        self.port.to_i
+      end
+    end
+
+    ##
+    # The default port for this URI's scheme.
+    # This method will always returns the default port for the URI's scheme
+    # regardless of the presence of an explicit port in the URI.
+    #
+    # @return [Integer] The default port.
+    def default_port
+      URI.port_mapping[self.scheme.strip.downcase] if self.scheme
     end
 
     ##
@@ -1189,16 +1456,12 @@ module Addressable
     #
     # @return [String] The components that identify a site.
     def site
-      @site ||= (begin
-        if self.scheme || self.authority
-          site_string = ""
-          site_string << "#{self.scheme}:" if self.scheme != nil
-          site_string << "//#{self.authority}" if self.authority != nil
-          site_string
-        else
-          nil
-        end
-      end)
+      (self.scheme || self.authority) && @site ||= begin
+        site_string = "".dup
+        site_string << "#{self.scheme}:" if self.scheme != nil
+        site_string << "//#{self.authority}" if self.authority != nil
+        site_string
+      end
     end
 
     ##
@@ -1211,20 +1474,20 @@ module Addressable
     #
     # @return [String] The normalized components that identify a site.
     def normalized_site
-      @site ||= (begin
-        if self.normalized_scheme || self.normalized_authority
-          site_string = ""
-          if self.normalized_scheme != nil
-            site_string << "#{self.normalized_scheme}:"
-          end
-          if self.normalized_authority != nil
-            site_string << "//#{self.normalized_authority}"
-          end
-          site_string
-        else
-          nil
+      return nil unless self.site
+      @normalized_site ||= begin
+        site_string = "".dup
+        if self.normalized_scheme != nil
+          site_string << "#{self.normalized_scheme}:"
         end
-      end)
+        if self.normalized_authority != nil
+          site_string << "//#{self.normalized_authority}"
+        end
+        site_string
+      end
+      # All normalized values should be UTF-8
+      @normalized_site.force_encoding(Encoding::UTF_8) if @normalized_site
+      @normalized_site
     end
 
     ##
@@ -1254,36 +1517,40 @@ module Addressable
     #
     # @return [String] The path component.
     def path
-      @path ||= ""
-      return @path
+      return defined?(@path) ? @path : EMPTY_STR
     end
 
+    NORMPATH = /^(?!\/)[^\/:]*:.*$/
     ##
     # The path component for this URI, normalized.
     #
     # @return [String] The path component, normalized.
     def normalized_path
-      @normalized_path ||= (begin
-        if self.scheme == nil && self.path != nil && self.path != "" &&
-            self.path =~ /^(?!\/)[^\/:]*:.*$/
+      @normalized_path ||= begin
+        path = self.path.to_s
+        if self.scheme == nil && path =~ NORMPATH
           # Relative paths with colons in the first segment are ambiguous.
-          self.path.sub!(":", "%2F")
+          path = path.sub(":", "%2F")
         end
         # String#split(delimeter, -1) uses the more strict splitting behavior
         # found by default in Python.
-        result = (self.path.strip.split("/", -1).map do |segment|
+        result = path.strip.split(SLASH, -1).map do |segment|
           Addressable::URI.normalize_component(
             segment,
             Addressable::URI::CharacterClasses::PCHAR
           )
-        end).join("/")
-        result = self.class.normalize_path(result)
-        if result == "" &&
+        end.join(SLASH)
+
+        result = URI.normalize_path(result)
+        if result.empty? &&
             ["http", "https", "ftp", "tftp"].include?(self.normalized_scheme)
-          result = "/"
+          result = SLASH.dup
         end
         result
-      end)
+      end
+      # All normalized values should be UTF-8
+      @normalized_path.force_encoding(Encoding::UTF_8) if @normalized_path
+      @normalized_path
     end
 
     ##
@@ -1291,21 +1558,20 @@ module Addressable
     #
     # @param [String, #to_str] new_path The new path component.
     def path=(new_path)
-      # Check for frozenness
-      raise TypeError, "Can't modify frozen URI." if self.frozen?
-
       if new_path && !new_path.respond_to?(:to_str)
         raise TypeError, "Can't convert #{new_path.class} into String."
       end
-      @path = (new_path || "").to_str
-      if @path != "" && @path[0..0] != "/" && host != nil
+      @path = (new_path || EMPTY_STR).to_str
+      if !@path.empty? && @path[0..0] != SLASH && host != nil
         @path = "/#{@path}"
       end
 
-      # Reset dependant values
-      @normalized_path = nil
-      @uri_string = nil
-      @hash = nil
+      # Reset dependent values
+      remove_instance_variable(:@normalized_path) if defined?(@normalized_path)
+      remove_composite_values
+
+      # Ensure we haven't created an invalid URI
+      validate()
     end
 
     ##
@@ -1314,7 +1580,7 @@ module Addressable
     # @return [String] The path's basename.
     def basename
       # Path cannot be nil
-      return File.basename(self.path).gsub(/;[^\/]*$/, "")
+      return File.basename(self.path).sub(/;[^\/]*$/, EMPTY_STR)
     end
 
     ##
@@ -1332,24 +1598,31 @@ module Addressable
     #
     # @return [String] The query component.
     def query
-      return @query ||= nil
+      return defined?(@query) ? @query : nil
     end
 
     ##
     # The query component for this URI, normalized.
     #
     # @return [String] The query component, normalized.
-    def normalized_query
-      @normalized_query ||= (begin
-        if self.query
-          Addressable::URI.normalize_component(
-            self.query.strip,
-            Addressable::URI::CharacterClasses::QUERY
-          )
-        else
-          nil
-        end
-      end)
+    def normalized_query(*flags)
+      return nil unless self.query
+      return @normalized_query if defined?(@normalized_query)
+      @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!("\\;", "")
+        pairs = (self.query || "").split("&", -1)
+        pairs.delete_if(&:empty?) if flags.include?(:compacted)
+        pairs.sort! if flags.include?(:sorted)
+        component = pairs.map do |pair|
+          Addressable::URI.normalize_component(pair, modified_query_class, "+")
+        end.join("&")
+        component == "" ? nil : component
+      end
+      # All normalized values should be UTF-8
+      @normalized_query.force_encoding(Encoding::UTF_8) if @normalized_query
+      @normalized_query
     end
 
     ##
@@ -1357,134 +1630,86 @@ module Addressable
     #
     # @param [String, #to_str] new_query The new query component.
     def query=(new_query)
-      # Check for frozenness
-      raise TypeError, "Can't modify frozen URI." if self.frozen?
-
       if new_query && !new_query.respond_to?(:to_str)
         raise TypeError, "Can't convert #{new_query.class} into String."
       end
       @query = new_query ? new_query.to_str : nil
 
-      # Reset dependant values
-      @normalized_query = nil
-      @uri_string = nil
-      @hash = nil
+      # Reset dependent values
+      remove_instance_variable(:@normalized_query) if defined?(@normalized_query)
+      remove_composite_values
     end
 
     ##
     # Converts the query component to a Hash value.
     #
-    # @option [Symbol] notation
-    #   May be one of <code>:flat</code>, <code>:dot</code>, or
-    #   <code>:subscript</code>. The <code>:dot</code> notation is not
-    #   supported for assignment. Default value is <code>:subscript</code>.
+    # @param [Class] return_type The return type desired. Value must be either
+    #   `Hash` or `Array`.
     #
-    # @return [Hash, Array] The query string parsed as a Hash or Array object.
+    # @return [Hash, Array, nil] The query string parsed as a Hash or Array
+    #   or nil if the query string is blank.
     #
     # @example
     #   Addressable::URI.parse("?one=1&two=2&three=3").query_values
     #   #=> {"one" => "1", "two" => "2", "three" => "3"}
-    #   Addressable::URI.parse("?one[two][three]=four").query_values
-    #   #=> {"one" => {"two" => {"three" => "four"}}}
-    #   Addressable::URI.parse("?one.two.three=four").query_values(
-    #     :notation => :dot
-    #   )
-    #   #=> {"one" => {"two" => {"three" => "four"}}}
-    #   Addressable::URI.parse("?one[two][three]=four").query_values(
-    #     :notation => :flat
-    #   )
-    #   #=> {"one[two][three]" => "four"}
-    #   Addressable::URI.parse("?one.two.three=four").query_values(
-    #     :notation => :flat
-    #   )
-    #   #=> {"one.two.three" => "four"}
-    #   Addressable::URI.parse(
-    #     "?one[two][three][]=four&one[two][three][]=five"
-    #   ).query_values
-    #   #=> {"one" => {"two" => {"three" => ["four", "five"]}}}
-    #   Addressable::URI.parse(
-    #     "?one=two&one=three").query_values(:notation => :flat_array)
-    #   #=> [['one', 'two'], ['one', 'three']]
-    def query_values(options={})
-      defaults = {:notation => :subscript}
-      options = defaults.merge(options)
-      if ![:flat, :dot, :subscript, :flat_array].include?(options[:notation])
-        raise ArgumentError,
-          "Invalid notation. Must be one of: " +
-          "[:flat, :dot, :subscript, :flat_array]."
-      end
-      dehash = lambda do |hash|
-        hash.each do |(key, value)|
-          if value.kind_of?(Hash)
-            hash[key] = dehash.call(value)
-          end
-        end
-        if hash != {} && hash.keys.all? { |key| key =~ /^\d+$/ }
-          hash.sort.inject([]) do |accu, (key, value)|
-            accu << value; accu
-          end
-        else
-          hash
-        end
+    #   Addressable::URI.parse("?one=two&one=three").query_values(Array)
+    #   #=> [["one", "two"], ["one", "three"]]
+    #   Addressable::URI.parse("?one=two&one=three").query_values(Hash)
+    #   #=> {"one" => "three"}
+    #   Addressable::URI.parse("?").query_values
+    #   #=> {}
+    #   Addressable::URI.parse("").query_values
+    #   #=> nil
+    def query_values(return_type=Hash)
+      empty_accumulator = Array == return_type ? [] : {}
+      if return_type != Hash && return_type != Array
+        raise ArgumentError, "Invalid return type. Must be Hash or Array."
       end
       return nil if self.query == nil
-      empty_accumulator = :flat_array == options[:notation] ? [] : {}
-      return ((self.query.split("&").map do |pair|
-        pair.split("=", -1) if pair && pair != ""
-      end).compact.inject(empty_accumulator.dup) do |accumulator, (key, value)|
-        value = true if value.nil?
-        key = self.class.unencode_component(key)
-        if value != true
-          value = self.class.unencode_component(value.gsub(/\+/, " "))
+      split_query = self.query.split("&").map do |pair|
+        pair.split("=", 2) if pair && !pair.empty?
+      end.compact
+      return split_query.inject(empty_accumulator.dup) do |accu, pair|
+        # I'd rather use key/value identifiers instead of array lookups,
+        # but in this case I really want to maintain the exact pair structure,
+        # so it's best to make all changes in-place.
+        pair[0] = URI.unencode_component(pair[0])
+        if pair[1].respond_to?(: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("+", " "))
         end
-        if options[:notation] == :flat
-          if accumulator[key]
-            raise ArgumentError, "Key was repeated: #{key.inspect}"
-          end
-          accumulator[key] = value
-        elsif options[:notation] == :flat_array
-          accumulator << [key, value]
+        if return_type == Hash
+          accu[pair[0]] = pair[1]
         else
-          if options[:notation] == :dot
-            array_value = false
-            subkeys = key.split(".")
-          elsif options[:notation] == :subscript
-            array_value = !!(key =~ /\[\]$/)
-            subkeys = key.split(/[\[\]]+/)
-          end
-          current_hash = accumulator
-          for i in 0...(subkeys.size - 1)
-            subkey = subkeys[i]
-            current_hash[subkey] = {} unless current_hash[subkey]
-            current_hash = current_hash[subkey]
-          end
-          if array_value
-            current_hash[subkeys.last] = [] unless current_hash[subkeys.last]
-            current_hash[subkeys.last] << value
-          else
-            current_hash[subkeys.last] = value
-          end
+          accu << pair
         end
-        accumulator
-      end).inject(empty_accumulator.dup) do |accumulator, (key, value)|
-        if options[:notation] == :flat_array
-          accumulator << [key, value]
-        else
-          accumulator[key] = value.kind_of?(Hash) ? dehash.call(value) : value
-        end
-        accumulator
+        accu
       end
     end
 
     ##
     # Sets the query component for this URI from a Hash object.
-    # This method produces a query string using the :subscript notation.
-    # An empty Hash will result in a nil query.
+    # An empty Hash or Array will result in an empty query string.
     #
     # @param [Hash, #to_hash, Array] new_query_values The new query values.
+    #
+    # @example
+    #   uri.query_values = {:a => "a", :b => ["c", "d", "e"]}
+    #   uri.query
+    #   # => "a=a&b=c&b=d&b=e"
+    #   uri.query_values = [['a', 'a'], ['b', 'c'], ['b', 'd'], ['b', 'e']]
+    #   uri.query
+    #   # => "a=a&b=c&b=d&b=e"
+    #   uri.query_values = [['a', 'a'], ['b', ['c', 'd', 'e']]]
+    #   uri.query
+    #   # => "a=a&b=c&b=d&b=e"
+    #   uri.query_values = [['flag'], ['key', 'value']]
+    #   uri.query
+    #   # => "flag&key=value"
     def query_values=(new_query_values)
-      # Check for frozenness
-      raise TypeError, "Can't modify frozen URI." if self.frozen?
       if new_query_values == nil
         self.query = nil
         return nil
@@ -1504,38 +1729,27 @@ module Addressable
         # Only to be used for non-Array inputs. Arrays should preserve order.
         new_query_values.sort!
       end
-      # new_query_values have form [['key1', 'value1'], ['key2', 'value2']]
 
-      # Algorithm shamelessly stolen from Julien Genestoux, slightly modified
-      buffer = ""
-      stack = []
-      e = lambda do |component|
-        component = component.to_s if component.kind_of?(Symbol)
-        self.class.encode_component(component, CharacterClasses::UNRESERVED)
-      end
+      # new_query_values have form [['key1', 'value1'], ['key2', 'value2']]
+      buffer = "".dup
       new_query_values.each do |key, value|
-        if value.kind_of?(Hash)
-          stack << [key, value]
+        encoded_key = URI.encode_component(
+          key, CharacterClasses::UNRESERVED
+        )
+        if value == nil
+          buffer << "#{encoded_key}&"
         elsif value.kind_of?(Array)
-          stack << [
-            key,
-            value.inject({}) { |accu, x| accu[accu.size.to_s] = x; accu }
-          ]
-        elsif value == true
-          buffer << "#{e.call(key)}&"
-        else
-          buffer << "#{e.call(key)}=#{e.call(value)}&"
-        end
-      end
-      stack.each do |(parent, hash)|
-        (hash.sort_by { |key| key.to_s }).each do |(key, value)|
-          if value.kind_of?(Hash)
-            stack << ["#{parent}[#{key}]", value]
-          elsif value == true
-            buffer << "#{parent}[#{e.call(key)}]&"
-          else
-            buffer << "#{parent}[#{e.call(key)}]=#{e.call(value)}&"
+          value.each do |sub_value|
+            encoded_value = URI.encode_component(
+              sub_value, CharacterClasses::UNRESERVED
+            )
+            buffer << "#{encoded_key}=#{encoded_value}&"
           end
+        else
+          encoded_value = URI.encode_component(
+            value, CharacterClasses::UNRESERVED
+          )
+          buffer << "#{encoded_key}=#{encoded_value}&"
         end
       end
       self.query = buffer.chop
@@ -1547,10 +1761,10 @@ 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 != "" ? self.path : "/") +
-        (self.query ? "?#{self.query}" : "")
+        (!self.path.empty? ? self.path : SLASH) +
+        (self.query ? "?#{self.query}" : EMPTY_STR)
       )
     end
 
@@ -1562,21 +1776,20 @@ 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 != "" ? path_component : "/")
+      path_component = (!path_component.empty? ? path_component : SLASH)
       self.path = path_component
       self.query = query_component
 
-      # Reset dependant values
-      @uri_string = nil
-      @hash = nil
+      # Reset dependent values
+      remove_composite_values
     end
 
     ##
@@ -1584,7 +1797,7 @@ module Addressable
     #
     # @return [String] The fragment component.
     def fragment
-      return @fragment ||= nil
+      return defined?(@fragment) ? @fragment : nil
     end
 
     ##
@@ -1592,16 +1805,20 @@ module Addressable
     #
     # @return [String] The fragment component, normalized.
     def normalized_fragment
-      @normalized_fragment ||= (begin
-        if self.fragment
-          Addressable::URI.normalize_component(
-            self.fragment.strip,
-            Addressable::URI::CharacterClasses::FRAGMENT
-          )
-        else
-          nil
-        end
-      end)
+      return nil unless self.fragment
+      return @normalized_fragment if defined?(@normalized_fragment)
+      @normalized_fragment ||= begin
+        component = Addressable::URI.normalize_component(
+          self.fragment,
+          Addressable::URI::CharacterClasses::FRAGMENT
+        )
+        component == "" ? nil : component
+      end
+      # All normalized values should be UTF-8
+      if @normalized_fragment
+        @normalized_fragment.force_encoding(Encoding::UTF_8)
+      end
+      @normalized_fragment
     end
 
     ##
@@ -1609,18 +1826,14 @@ module Addressable
     #
     # @param [String, #to_str] new_fragment The new fragment component.
     def fragment=(new_fragment)
-      # Check for frozenness
-      raise TypeError, "Can't modify frozen URI." if self.frozen?
-
       if new_fragment && !new_fragment.respond_to?(:to_str)
         raise TypeError, "Can't convert #{new_fragment.class} into String."
       end
       @fragment = new_fragment ? new_fragment.to_str : nil
 
-      # Reset dependant values
-      @normalized_fragment = nil
-      @uri_string = nil
-      @hash = nil
+      # Reset dependent values
+      remove_instance_variable(:@normalized_fragment) if defined?(@normalized_fragment)
+      remove_composite_values
 
       # Ensure we haven't created an invalid URI
       validate()
@@ -1634,7 +1847,7 @@ module Addressable
     #   <code>false</code> otherwise.
     def ip_based?
       if self.scheme
-        return self.class.ip_based_schemes.include?(
+        return URI.ip_based_schemes.include?(
           self.scheme.strip.downcase)
       end
       return false
@@ -1670,11 +1883,11 @@ module Addressable
       if !uri.respond_to?(:to_str)
         raise TypeError, "Can't convert #{uri.class} into String."
       end
-      if !uri.kind_of?(self.class)
+      if !uri.kind_of?(URI)
         # Otherwise, convert to a String, then parse.
-        uri = self.class.parse(uri.to_str)
+        uri = URI.parse(uri.to_str)
       end
-      if uri.to_s == ""
+      if uri.to_s.empty?
         return self.dup
       end
 
@@ -1694,7 +1907,7 @@ module Addressable
         joined_password = uri.password
         joined_host = uri.host
         joined_port = uri.port
-        joined_path = self.class.normalize_path(uri.path)
+        joined_path = URI.normalize_path(uri.path)
         joined_query = uri.query
       else
         if uri.authority != nil
@@ -1702,10 +1915,10 @@ module Addressable
           joined_password = uri.password
           joined_host = uri.host
           joined_port = uri.port
-          joined_path = self.class.normalize_path(uri.path)
+          joined_path = URI.normalize_path(uri.path)
           joined_query = uri.query
         else
-          if uri.path == nil || uri.path == ""
+          if uri.path == nil || uri.path.empty?
             joined_path = self.path
             if uri.query != nil
               joined_query = uri.query
@@ -1713,29 +1926,29 @@ module Addressable
               joined_query = self.query
             end
           else
-            if uri.path[0..0] == "/"
-              joined_path = self.class.normalize_path(uri.path)
+            if uri.path[0..0] == SLASH
+              joined_path = URI.normalize_path(uri.path)
             else
               base_path = self.path.dup
-              base_path = "" if base_path == nil
-              base_path = self.class.normalize_path(base_path)
+              base_path = EMPTY_STR if base_path == nil
+              base_path = URI.normalize_path(base_path)
 
               # Section 5.2.3 of RFC 3986
               #
               # Removes the right-most path segment from the base path.
-              if base_path =~ /\//
-                base_path.gsub!(/\/[^\/]+$/, "/")
+              if base_path.include?(SLASH)
+                base_path.sub!(/\/[^\/]+$/, SLASH)
               else
-                base_path = ""
+                base_path = EMPTY_STR
               end
 
               # If the base path is empty and an authority segment has been
-              # defined, use a base path of "/"
-              if base_path == "" && self.authority != nil
-                base_path = "/"
+              # defined, use a base path of SLASH
+              if base_path.empty? && self.authority != nil
+                base_path = SLASH
               end
 
-              joined_path = self.class.normalize_path(base_path + uri.path)
+              joined_path = URI.normalize_path(base_path + uri.path)
             end
             joined_query = uri.query
           end
@@ -1748,7 +1961,7 @@ module Addressable
       end
       joined_fragment = uri.fragment
 
-      return Addressable::URI.new(
+      return self.class.new(
         :scheme => joined_scheme,
         :user => joined_user,
         :password => joined_password,
@@ -1804,7 +2017,7 @@ module Addressable
         end
       end
 
-      uri = Addressable::URI.new
+      uri = self.class.new
       uri.defer_validation do
         # Bunch of crazy logic required because of the composite components
         # like userinfo and authority.
@@ -1863,7 +2076,7 @@ module Addressable
     # @return [Addressable::URI]
     #   The normalized relative URI that is equivalent to the original URI.
     def route_from(uri)
-      uri = self.class.parse(uri).normalize
+      uri = URI.parse(uri).normalize
       normalized_self = self.normalize
       if normalized_self.relative?
         raise ArgumentError, "Expected absolute URI, got: #{self.to_s}"
@@ -1888,9 +2101,16 @@ module Addressable
               components[:query] = nil
             end
           else
-            if uri.path != "/"
-              components[:path].gsub!(
-                Regexp.new("^" + Regexp.escape(uri.path)), "")
+            if uri.path != SLASH and components[:path]
+              self_splitted_path = split_path(components[:path])
+              uri_splitted_path = split_path(uri.path)
+              self_dir = self_splitted_path.shift
+              uri_dir = uri_splitted_path.shift
+              while !self_splitted_path.empty? && !uri_splitted_path.empty? and self_dir == uri_dir
+                self_dir = self_splitted_path.shift
+                uri_dir = uri_splitted_path.shift
+              end
+              components[:path] = (uri_splitted_path.fill('..') + [self_dir] + self_splitted_path).join(SLASH)
             end
           end
         end
@@ -1921,7 +2141,7 @@ module Addressable
     # @return [Addressable::URI]
     #   The normalized relative URI that is equivalent to the supplied URI.
     def route_to(uri)
-      return self.class.parse(uri).route_from(self)
+      return URI.parse(uri).route_from(self)
     end
 
     ##
@@ -1939,13 +2159,13 @@ module Addressable
       # URI scheme.
       if normalized_scheme == "feed"
         if self.to_s =~ /^feed:\/*http:\/*/
-          return self.class.parse(
+          return URI.parse(
             self.to_s[/^feed:\/*(http:\/*.*)/, 1]
           ).normalize
         end
       end
 
-      return Addressable::URI.new(
+      return self.class.new(
         :scheme => normalized_scheme,
         :authority => normalized_authority,
         :path => normalized_path,
@@ -2010,7 +2230,7 @@ module Addressable
     #   <code>true</code> if the URIs are equivalent, <code>false</code>
     #   otherwise.
     def ==(uri)
-      return false unless uri.kind_of?(self.class)
+      return false unless uri.kind_of?(URI)
       return self.normalize.to_s == uri.normalize.to_s
     end
 
@@ -2024,7 +2244,7 @@ module Addressable
     #   <code>true</code> if the URIs are equivalent, <code>false</code>
     #   otherwise.
     def eql?(uri)
-      return false unless uri.kind_of?(self.class)
+      return false unless uri.kind_of?(URI)
       return self.to_s == uri.to_s
     end
 
@@ -2034,7 +2254,7 @@ module Addressable
     #
     # @return [Integer] A hash of the URI.
     def hash
-      return @hash ||= (self.to_s.hash * -1)
+      @hash ||= self.to_s.hash * -1
     end
 
     ##
@@ -2042,7 +2262,7 @@ module Addressable
     #
     # @return [Addressable::URI] The cloned URI.
     def dup
-      duplicated_uri = Addressable::URI.new(
+      duplicated_uri = self.class.new(
         :scheme => self.scheme ? self.scheme.dup : nil,
         :user => self.user ? self.user.dup : nil,
         :password => self.password ? self.password.dup : nil,
@@ -2055,28 +2275,6 @@ module Addressable
       return duplicated_uri
     end
 
-    ##
-    # Freezes the URI object.
-    #
-    # @return [Addressable::URI] The frozen URI.
-    def freeze
-      # Unfortunately, because of the memoized implementation of many of the
-      # URI methods, the default freeze method will cause unexpected errors.
-      # As an alternative, we freeze the string representation of the URI
-      # instead. This should generally produce the desired effect.
-      self.to_s.freeze
-      return self
-    end
-
-    ##
-    # Determines if the URI is frozen.
-    #
-    # @return [TrueClass, FalseClass]
-    #   <code>true</code> if the URI is frozen, <code>false</code> otherwise.
-    def frozen?
-      self.to_s.frozen?
-    end
-
     ##
     # Omits components from a URI.
     #
@@ -2120,23 +2318,35 @@ module Addressable
       replace_self(self.omit(*components))
     end
 
+    ##
+    # Determines if the URI is an empty string.
+    #
+    # @return [TrueClass, FalseClass]
+    #   Returns <code>true</code> if empty, <code>false</code> otherwise.
+    def empty?
+      return self.to_s.empty?
+    end
+
     ##
     # Converts the URI to a <code>String</code>.
     #
     # @return [String] The URI's <code>String</code> representation.
     def to_s
-      @uri_string ||= (begin
-        uri_string = ""
+      if self.scheme == nil && self.path != nil && !self.path.empty? &&
+          self.path =~ NORMPATH
+        raise InvalidURIError,
+          "Cannot assemble URI string with ambiguous path: '#{self.path}'"
+      end
+      @uri_string ||= begin
+        uri_string = String.new
         uri_string << "#{self.scheme}:" if self.scheme != nil
         uri_string << "//#{self.authority}" if self.authority != nil
         uri_string << self.path.to_s
         uri_string << "?#{self.query}" if self.query != nil
         uri_string << "##{self.fragment}" if self.fragment != nil
-        if uri_string.respond_to?(:force_encoding)
-          uri_string.force_encoding(Encoding::UTF_8)
-        end
+        uri_string.force_encoding(Encoding::UTF_8)
         uri_string
-      end)
+      end
     end
 
     ##
@@ -2165,7 +2375,7 @@ module Addressable
     #
     # @return [String] The URI object's state, as a <code>String</code>.
     def inspect
-      sprintf("#<%s:%#0x URI:%s>", self.class.to_s, self.object_id, self.to_s)
+      sprintf("#<%s:%#0x URI:%s>", URI.to_s, self.object_id, self.to_s)
     end
 
     ##
@@ -2176,16 +2386,24 @@ module Addressable
     #
     # @param [Proc] block
     #   A set of operations to perform on a given URI.
-    def defer_validation(&block)
-      raise LocalJumpError, "No block given." unless block
+    def defer_validation
+      raise LocalJumpError, "No block given." unless block_given?
       @validation_deferred = true
-      block.call()
+      yield
       @validation_deferred = false
       validate
       return nil
     end
 
-  private
+  protected
+    SELF_REF = '.'
+    PARENT = '..'
+
+    RULE_2A = /\/\.\/|\/\.$/
+    RULE_2B_2C = /\/([^\/]*)\/\.\.\/|\/([^\/]*)\/\.\.$/
+    RULE_2D = /^\.\.?\/?/
+    RULE_PREFIXED_PARENT = /^\/\.\.?\/|^(\/\.\.?)+\/?$/
+
     ##
     # Resolves paths to their simplest form.
     #
@@ -2197,22 +2415,27 @@ module Addressable
 
       return nil if path.nil?
       normalized_path = path.dup
-      previous_state = normalized_path.dup
       begin
-        previous_state = normalized_path.dup
-        normalized_path.gsub!(/\/\.\//, "/")
-        normalized_path.gsub!(/\/\.$/, "/")
-        parent = normalized_path[/\/([^\/]+)\/\.\.\//, 1]
-        if parent != "." && parent != ".."
-          normalized_path.gsub!(/\/#{parent}\/\.\.\//, "/")
-        end
-        parent = normalized_path[/\/([^\/]+)\/\.\.$/, 1]
-        if parent != "." && parent != ".."
-          normalized_path.gsub!(/\/#{parent}\/\.\.$/, "/")
+        mod = nil
+        mod ||= normalized_path.gsub!(RULE_2A, SLASH)
+
+        pair = normalized_path.match(RULE_2B_2C)
+        parent, current = pair[1], pair[2] if pair
+        if pair && ((parent != SELF_REF && parent != PARENT) ||
+            (current != SELF_REF && current != PARENT))
+          mod ||= normalized_path.gsub!(
+            Regexp.new(
+              "/#{Regexp.escape(parent.to_s)}/\\.\\./|" +
+              "(/#{Regexp.escape(current.to_s)}/\\.\\.$)"
+            ), SLASH
+          )
         end
-        normalized_path.gsub!(/^\.\.?\/?/, "")
-        normalized_path.gsub!(/^\/\.\.?\//, "/")
-      end until previous_state == normalized_path
+
+        mod ||= normalized_path.gsub!(RULE_2D, EMPTY_STR)
+        # Non-standard, removes prefixed dotted segments from path.
+        mod ||= normalized_path.gsub!(RULE_PREFIXED_PARENT, SLASH)
+      end until mod.nil?
+
       return normalized_path
     end
 
@@ -2220,9 +2443,9 @@ module Addressable
     # Ensures that the URI is valid.
     def validate
       return if !!@validation_deferred
-      if self.scheme != nil &&
-          (self.host == nil || self.host == "") &&
-          (self.path == nil || self.path == "")
+      if self.scheme != nil && self.ip_based? &&
+          (self.host == nil || self.host.empty?) &&
+          (self.path == nil || self.path.empty?)
         raise InvalidURIError,
           "Absolute URI missing hierarchical segment: '#{self.to_s}'"
       end
@@ -2233,11 +2456,24 @@ module Addressable
           raise InvalidURIError, "Hostname not supplied: '#{self.to_s}'"
         end
       end
-      if self.path != nil && self.path != "" && self.path[0..0] != "/" &&
+      if self.path != nil && !self.path.empty? && self.path[0..0] != SLASH &&
           self.authority != nil
         raise InvalidURIError,
           "Cannot have a relative path with an authority set: '#{self.to_s}'"
       end
+      if self.path != nil && !self.path.empty? &&
+          self.path[0..1] == SLASH + SLASH && self.authority == nil
+        raise InvalidURIError,
+          "Cannot have a path with two leading slashes " +
+          "without an authority set: '#{self.to_s}'"
+      end
+      unreserved = CharacterClasses::UNRESERVED
+      sub_delims = CharacterClasses::SUB_DELIMS
+      if !self.host.nil? && (self.host =~ /[<>{}\/\\\?\#\@"[[:space:]]]/ ||
+          (self.host[/^\[(.*)\]$/, 1] != nil && self.host[/^\[(.*)\]$/, 1] !~
+          Regexp.new("^[#{unreserved}#{sub_delims}:]*$")))
+        raise InvalidURIError, "Invalid character in host: '#{self.host.to_s}'"
+      end
       return nil
     end
 
@@ -2249,9 +2485,11 @@ module Addressable
     #
     # @return [Addressable::URI] <code>self</code>.
     def replace_self(uri)
-      # Reset dependant values
+      # Reset dependent values
       instance_variables.each do |var|
-        instance_variable_set(var, nil)
+        if instance_variable_defined?(var) && var != :@validation_deferred
+          remove_instance_variable(var)
+        end
       end
 
       @scheme = uri.scheme
@@ -2264,5 +2502,28 @@ module Addressable
       @fragment = uri.fragment
       return self
     end
+
+    ##
+    # Splits path string with "/" (slash).
+    # It is considered that there is empty string after last slash when
+    # path ends with slash.
+    #
+    # @param [String] path The path to split.
+    #
+    # @return [Array<String>] An array of parts of path.
+    def split_path(path)
+      splitted = path.split(SLASH)
+      splitted << EMPTY_STR if path.end_with? SLASH
+      splitted
+    end
+
+    ##
+    # Resets composite values for the entire URI
+    #
+    # @api private
+    def remove_composite_values
+      remove_instance_variable(:@uri_string) if defined?(@uri_string)
+      remove_instance_variable(:@hash) if defined?(@hash)
+    end
   end
 end