addressable 2.2.4 → 2.2.5

data/lib/addressable/template.rb

@@ -1,27 +1,21 @@
 # encoding:utf-8
 #--
-# Addressable, Copyright (c) 2006-2010 Bob Aman
+# Copyright (C) 2006-2011 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/uri"
 
@@ -63,7 +57,7 @@ module Addressable
       #
       # @param [Addressable::URI] uri
       #   The URI that the template was matched against.
-      def initialize(uri, template, mapping) # :nodoc:
+      def initialize(uri, template, mapping)
         @uri = uri.dup.freeze
         @template = template
         @mapping = mapping.dup.freeze
@@ -154,20 +148,22 @@ module Addressable
     #
     # @param [#restore, #match] processor
     #   A template processor object may optionally be supplied.
-    #
-    # The object should respond to either the <tt>restore</tt> or
-    # <tt>match</tt> messages or both.  The <tt>restore</tt> method should take
-    # two parameters: [String] name and [String] value.  The <tt>restore</tt>
-    # method should reverse any transformations that have been performed on the
-    # value to ensure a valid URI.  The <tt>match</tt> method should take a
-    # single parameter: [String] name.  The <tt>match</tt> method should return
-    # a <tt>String</tt> containing a regular expression capture group for
-    # matching on that particular variable.  The default value is ".*?".  The
-    # <tt>match</tt> method has no effect on multivariate operator expansions.
+    #   
+    #   The object should respond to either the <tt>restore</tt> or
+    #   <tt>match</tt> messages or both. The <tt>restore</tt> method should
+    #   take two parameters: `[String] name` and `[String] value`.
+    #   The <tt>restore</tt> method should reverse any transformations that
+    #   have been performed on the value to ensure a valid URI.
+    #   The <tt>match</tt> method should take a single
+    #   parameter: `[String] name`.  The <tt>match</tt> method should return
+    #   a <tt>String</tt> containing a regular expression capture group for
+    #   matching on that particular variable. The default value is `".*?"`.
+    #   The <tt>match</tt> method has no effect on multivariate operator
+    #   expansions.
     #
     # @return [Hash, NilClass]
-    # The <tt>Hash</tt> mapping that was extracted from the URI, or
-    # <tt>nil</tt> if the URI didn't match the template.
+    #   The <tt>Hash</tt> mapping that was extracted from the URI, or
+    #   <tt>nil</tt> if the URI didn't match the template.
     #
     # @example
     #   class ExampleProcessor
@@ -214,20 +210,22 @@ module Addressable
     #
     # @param [#restore, #match] processor
     #   A template processor object may optionally be supplied.
-    #
-    # The object should respond to either the <tt>restore</tt> or
-    # <tt>match</tt> messages or both. The <tt>restore</tt> method should take
-    # two parameters: [String] name and [String] value. The <tt>restore</tt>
-    # method should reverse any transformations that have been performed on the
-    # value to ensure a valid URI. The <tt>match</tt> method should take a
-    # single parameter: [String] name. The <tt>match</tt> method should return
-    # a <tt>String</tt> containing a regular expression capture group for
-    # matching on that particular variable. The default value is ".*?". The
-    # <tt>match</tt> method has no effect on multivariate operator expansions.
+    #   
+    #   The object should respond to either the <tt>restore</tt> or
+    #   <tt>match</tt> messages or both. The <tt>restore</tt> method should
+    #   take two parameters: `[String] name` and `[String] value`.
+    #   The <tt>restore</tt> method should reverse any transformations that
+    #   have been performed on the value to ensure a valid URI.
+    #   The <tt>match</tt> method should take a single
+    #   parameter: `[String] name`. The <tt>match</tt> method should return
+    #   a <tt>String</tt> containing a regular expression capture group for
+    #   matching on that particular variable. The default value is `".*?"`.
+    #   The <tt>match</tt> method has no effect on multivariate operator
+    #   expansions.
     #
     # @return [Hash, NilClass]
-    # The <tt>Hash</tt> mapping that was extracted from the URI, or
-    # <tt>nil</tt> if the URI didn't match the template.
+    #   The <tt>Hash</tt> mapping that was extracted from the URI, or
+    #   <tt>nil</tt> if the URI didn't match the template.
     #
     # @example
     #   class ExampleProcessor

data/lib/addressable/uri.rb

@@ -1,30 +1,26 @@
 # encoding:utf-8
 #--
-# Addressable, Copyright (c) 2006-2010 Bob Aman
+# Copyright (C) 2006-2011 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"
 
+##
+# Addressable is a library for processing links and URIs.
 module Addressable
   ##
   # This is an implementation of a URI parser based on
@@ -54,6 +50,11 @@ module Addressable
       FRAGMENT = PCHAR + "\\/\\?"
     end
 
+    SLASH = '/'
+    EMPTYSTR = ''
+
+    URIREGEX = /^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/
+
     ##
     # Returns a URI object based on the parsed string.
     #
@@ -67,7 +68,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 +78,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,10 +104,10 @@ module Addressable
           user = userinfo.strip[/^([^:]*):?/, 1]
           password = userinfo.strip[/:(.*)$/, 1]
         end
-        host = authority.gsub(/^([^\[\]]*)@/, "").gsub(/:([^:@\[\]]*?)$/, "")
+        host = authority.gsub(/^([^\[\]]*)@/, EMPTYSTR).gsub(/:([^:@\[\]]*?)$/, EMPTYSTR)
         port = authority[/:([^:@\[\]]*?)$/, 1]
       end
-      if port == ""
+      if port == EMPTYSTR
         port = nil
       end
 
@@ -141,7 +141,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 !uri.respond_to?(:to_str)
         raise TypeError, "Can't convert #{uri.class} into String."
       end
@@ -169,7 +169,7 @@ module Addressable
         if new_host
           parsed.defer_validation do
             new_path = parsed.path.gsub(
-              Regexp.new("^" + Regexp.escape(new_host)), "")
+              Regexp.new("^" + Regexp.escape(new_host)), EMPTYSTR)
             parsed.host = new_host
             parsed.path = new_path
             parsed.scheme = hints[:scheme] unless parsed.scheme
@@ -219,8 +219,8 @@ 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.gsub!(/^file:\/?\/?/, EMPTYSTR) if path =~ /^file:\/?\/?/
+      path = SLASH + path if path =~ /^([a-zA-Z])[\|:]/
       uri = self.parse(path)
 
       if uri.scheme == nil
@@ -228,17 +228,17 @@ module Addressable
         uri.path.gsub!(/^\/?([a-zA-Z])[\|:][\\\/]/) do
           "/#{$1.downcase}:/"
         end
-        uri.path.gsub!(/\\/, "/")
+        uri.path.gsub!(/\\/, SLASH)
         if File.exists?(uri.path) &&
             File.stat(uri.path).directory?
-          uri.path.gsub!(/\/$/, "")
+          uri.path.gsub!(/\/$/, EMPTYSTR)
           uri.path = uri.path + '/'
         end
 
         # If the path is absolute, set the scheme and host.
         if uri.path =~ /^\//
           uri.scheme = "file"
-          uri.host = ""
+          uri.host = EMPTYSTR
         end
         uri.normalize!
       end
@@ -305,10 +305,13 @@ module Addressable
     def self.encode_component(component, character_class=
         CharacterClasses::RESERVED + CharacterClasses::UNRESERVED)
       return nil if component.nil?
-      if !component.respond_to?(:to_str)
+
+      begin
+        component = component.to_str
+      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}"
@@ -323,7 +326,7 @@ module Addressable
         component.force_encoding(Encoding::ASCII_8BIT)
       end
       return component.gsub(character_class) do |sequence|
-        (sequence.unpack('C*').map { |c| "%" + ("%02x" % c).upcase }).join("")
+        (sequence.unpack('C*').map { |c| "%" + ("%02x" % c).upcase }).join
       end
     end
 
@@ -351,15 +354,18 @@ module Addressable
     #   The return type is determined by the <code>returning</code> parameter.
     def self.unencode(uri, returning=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
+      end if !uri.is_a? String
       if ![String, ::Addressable::URI].include?(returning)
         raise TypeError,
           "Expected Class (String or Addressable::URI), " +
           "got #{returning.inspect}"
       end
-      result = uri.to_str.gsub(/%[0-9a-f]{2}/i) do |sequence|
+      result = uri.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)
@@ -387,10 +393,10 @@ 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>.
@@ -412,10 +418,13 @@ module Addressable
     def self.normalize_component(component, character_class=
         CharacterClasses::RESERVED + CharacterClasses::UNRESERVED)
       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}"
@@ -458,15 +467,19 @@ module Addressable
     #   The return type is determined by the <code>returning</code> parameter.
     def self.encode(uri, returning=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
+      end if !uri.is_a? String
+
       if ![String, ::Addressable::URI].include?(returning)
         raise TypeError,
           "Expected Class (String or Addressable::URI), " +
           "got #{returning.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),
@@ -507,15 +520,18 @@ module Addressable
     #   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)
+      begin
+        uri = uri.to_str
+      rescue NoMethodError, TypeError
         raise TypeError, "Can't convert #{uri.class} into String."
-      end
+      end if !uri.is_a? String
+
       if ![String, ::Addressable::URI].include?(returning)
         raise TypeError,
           "Expected Class (String or Addressable::URI), " +
           "got #{returning.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),
@@ -719,9 +735,6 @@ 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
@@ -731,7 +744,7 @@ module Addressable
         raise InvalidURIError, "Invalid scheme format."
       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
@@ -757,8 +770,8 @@ module Addressable
     def normalized_user
       @normalized_user ||= (begin
         if self.user
-          if normalized_scheme =~ /https?/ && self.user.strip == "" &&
-              (!self.password || self.password.strip == "")
+          if normalized_scheme =~ /https?/ && self.user.strip.empty? &&
+              (!self.password || self.password.strip.empty?)
             nil
           else
             Addressable::URI.normalize_component(
@@ -777,9 +790,6 @@ 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
@@ -788,7 +798,7 @@ module Addressable
       # You can't have a nil user with a non-nil password
       @password ||= nil
       if @password != nil
-        @user = "" if @user.nil?
+        @user = EMPTYSTR if @user.nil?
       end
 
       # Reset dependant values
@@ -818,8 +828,8 @@ module Addressable
     def normalized_password
       @normalized_password ||= (begin
         if self.password
-          if normalized_scheme =~ /https?/ && self.password.strip == "" &&
-              (!self.user || self.user.strip == "")
+          if normalized_scheme =~ /https?/ && self.password.strip.empty? &&
+              (!self.user || self.user.strip.empty?)
             nil
           else
             Addressable::URI.normalize_component(
@@ -838,9 +848,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,7 +857,7 @@ module Addressable
       @password ||= nil
       @user ||= nil
       if @password != nil
-        @user = "" if @user.nil?
+        @user = EMPTYSTR if @user.nil?
       end
 
       # Reset dependant values
@@ -907,9 +914,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
@@ -950,9 +954,9 @@ module Addressable
     def normalized_host
       @normalized_host ||= (begin
         if self.host != nil
-          if self.host.strip != ""
+          if !self.host.strip.empty?
             result = ::Addressable::IDNA.to_ascii(
-              self.class.unencode_component(self.host.strip.downcase)
+              URI.unencode_component(self.host.strip.downcase)
             )
             if result[-1..-1] == "."
               # Trailing dots are unnecessary
@@ -960,7 +964,7 @@ module Addressable
             end
             result
           else
-            ""
+            EMPTYSTR
           end
         else
           nil
@@ -973,9 +977,6 @@ 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
@@ -1041,9 +1042,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."
@@ -1055,7 +1053,7 @@ module Addressable
           new_password = new_userinfo.strip[/:(.*)$/, 1]
         end
         new_host =
-          new_authority.gsub(/^([^\[\]]*)@/, "").gsub(/:([^:@\[\]]*?)$/, "")
+          new_authority.gsub(/^([^\[\]]*)@/, EMPTYSTR).gsub(/:([^:@\[\]]*?)$/, EMPTYSTR)
         new_port =
           new_authority[/:([^:@\[\]]*?)$/, 1]
       end
@@ -1141,7 +1139,7 @@ module Addressable
     # @return [Integer] The port component, normalized.
     def normalized_port
       @normalized_port ||= (begin
-        if self.class.port_mapping[normalized_scheme] == self.port
+        if URI.port_mapping[normalized_scheme] == self.port
           nil
         else
           self.port
@@ -1154,9 +1152,6 @@ 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
@@ -1189,7 +1184,7 @@ module Addressable
       @inferred_port ||= (begin
         if port.to_i == 0
           if scheme
-            self.class.port_mapping[scheme.strip.downcase]
+            URI.port_mapping[scheme.strip.downcase]
           else
             nil
           end
@@ -1274,33 +1269,35 @@ module Addressable
     #
     # @return [String] The path component.
     def path
-      @path ||= ""
+      @path ||= EMPTYSTR
       return @path
     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 =~ /^(?!\/)[^\/:]*:.*$/
+        if self.scheme == nil && self.path != nil && !self.path.empty? &&
+            self.path =~ NORMPATH
           # Relative paths with colons in the first segment are ambiguous.
           self.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 = (self.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
         end
         result
       end)
@@ -1311,14 +1308,11 @@ 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 || EMPTYSTR).to_str
+      if !@path.empty? && @path[0..0] != SLASH && host != nil
         @path = "/#{@path}"
       end
 
@@ -1334,7 +1328,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).gsub(/;[^\/]*$/, EMPTYSTR)
     end
 
     ##
@@ -1362,10 +1356,12 @@ module Addressable
     def normalized_query
       @normalized_query ||= (begin
         if self.query
-          Addressable::URI.normalize_component(
-            self.query.strip,
-            Addressable::URI::CharacterClasses::QUERY
-          )
+          (self.query.split("&", -1).map do |pair|
+            Addressable::URI.normalize_component(
+              pair,
+              Addressable::URI::CharacterClasses::QUERY.sub("\\&", "")
+            )
+          end).join("&")
         else
           nil
         end
@@ -1377,9 +1373,6 @@ 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
@@ -1450,12 +1443,12 @@ module Addressable
       return nil if self.query == nil
       empty_accumulator = :flat_array == options[:notation] ? [] : {}
       return ((self.query.split("&").map do |pair|
-        pair.split("=", 2) if pair && pair != ""
+        pair.split("=", 2) if pair && !pair.empty?
       end).compact.inject(empty_accumulator.dup) do |accumulator, (key, value)|
         value = true if value.nil?
-        key = self.class.unencode_component(key)
+        key = URI.unencode_component(key)
         if value != true
-          value = self.class.unencode_component(value.gsub(/\+/, " "))
+          value = URI.unencode_component(value.gsub(/\+/, " "))
         end
         if options[:notation] == :flat
           if accumulator[key]
@@ -1503,8 +1496,6 @@ module Addressable
     #
     # @param [Hash, #to_hash, Array] new_query_values The new query values.
     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
@@ -1531,7 +1522,7 @@ module Addressable
       stack = []
       e = lambda do |component|
         component = component.to_s if component.kind_of?(Symbol)
-        self.class.encode_component(component, CharacterClasses::UNRESERVED)
+        URI.encode_component(component, CharacterClasses::UNRESERVED)
       end
       new_query_values.each do |key, value|
         if value.kind_of?(Hash)
@@ -1569,8 +1560,8 @@ module Addressable
     def request_uri
       return nil if self.absolute? && self.scheme !~ /^https?$/
       return (
-        (self.path != "" ? self.path : "/") +
-        (self.query ? "?#{self.query}" : "")
+        (!self.path.empty? ? self.path : SLASH) +
+        (self.query ? "?#{self.query}" : EMPTYSTR)
       )
     end
 
@@ -1590,7 +1581,7 @@ module Addressable
       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
 
@@ -1629,9 +1620,6 @@ 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
@@ -1654,7 +1642,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
@@ -1690,11 +1678,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
 
@@ -1714,7 +1702,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
@@ -1722,10 +1710,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
@@ -1733,29 +1721,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 = EMPTYSTR 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!(/\/[^\/]+$/, "/")
+                base_path.gsub!(/\/[^\/]+$/, SLASH)
               else
-                base_path = ""
+                base_path = EMPTYSTR
               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
@@ -1883,7 +1871,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}"
@@ -1908,9 +1896,9 @@ module Addressable
               components[:query] = nil
             end
           else
-            if uri.path != "/"
+            if uri.path != SLASH
               components[:path].gsub!(
-                Regexp.new("^" + Regexp.escape(uri.path)), "")
+                Regexp.new("^" + Regexp.escape(uri.path)), EMPTYSTR)
             end
           end
         end
@@ -1941,7 +1929,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
 
     ##
@@ -1959,7 +1947,7 @@ 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
@@ -2030,7 +2018,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
 
@@ -2044,7 +2032,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
 
@@ -2075,28 +2063,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.
     #
@@ -2185,7 +2151,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
 
     ##
@@ -2212,30 +2178,34 @@ module Addressable
     # @param [String] path The path to normalize.
     #
     # @return [String] The normalized path.
+
+    PARENT1 = '.'
+    PARENT2 = '..'
+
+    NPATH1 = /\/\.\/|\/\.$/
+    NPATH2 = /\/([^\/]+)\/\.\.\/|\/([^\/]+)\/\.\.$/
+    NPATH3 = /^\.\.?\/?/
+    NPATH4 = /^\/\.\.?\/|^(\/\.\.?)+\/?$/
+
     def self.normalize_path(path)
       # Section 5.2.4 of RFC 3986
 
       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!(NPATH1, SLASH)
+
+        parent = normalized_path.match(NPATH2)
+        if parent && ((parent[1] != PARENT1 && parent[1] != PARENT2) \
+                      || (parent[2] != PARENT1 && parent[2] != PARENT2))
+          mod ||= normalized_path.gsub!(/\/#{parent[1]}\/\.\.\/|(\/#{parent[2]}\/\.\.$)/, SLASH)
         end
-        normalized_path.gsub!(/^\.\.?\/?/, "")
-        normalized_path.gsub!(/^\/\.\.?\//, "/")
 
-        # Non-standard
-        normalized_path.gsub!(/^(\/\.\.?)+\/?$/, "/")
-      end until previous_state == normalized_path
+        mod ||= normalized_path.gsub!(NPATH3, EMPTYSTR)
+        mod ||= normalized_path.gsub!(NPATH4, SLASH)
+      end until mod.nil?
+
       return normalized_path
     end
 
@@ -2244,8 +2214,8 @@ module Addressable
     def validate
       return if !!@validation_deferred
       if self.scheme != nil &&
-          (self.host == nil || self.host == "") &&
-          (self.path == nil || self.path == "")
+          (self.host == nil || self.host.empty?) &&
+          (self.path == nil || self.path.empty?)
         raise InvalidURIError,
           "Absolute URI missing hierarchical segment: '#{self.to_s}'"
       end
@@ -2256,7 +2226,7 @@ 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}'"