honkster-addressable 2.1.2 → 2.2.3

data/CHANGELOG

@@ -1,86 +1,109 @@
+=== Addressable 2.2.5
+- 'parsing' a pre-parsed URI object is now a dup operation
+
+=== Addressable 2.2.4
+- added origin support from draft-ietf-websec-origin-00
+- resolved issue with attempting to navigate below root
+- fixed bug with string splitting in query strings
+
+=== Addressable 2.2.3
+- added :flat_array notation for query strings
+
+=== Addressable 2.2.2
+- fixed issue with percent escaping of '+' character in query strings
+
+=== Addressable 2.2.1
+- added support for application/x-www-form-urlencoded.
+
+=== Addressable 2.2.0
+- added site methods
+- improved documentation
+
 === Addressable 2.1.2
-  * added HTTP request URI methods
-  * better handling of Windows file paths
-  * validation_deferred boolean replaced with defer_validation block
-  * normalization of percent-encoded paths should now be correct
+- added HTTP request URI methods
+- better handling of Windows file paths
+- validation_deferred boolean replaced with defer_validation block
+- normalization of percent-encoded paths should now be correct
+- fixed issue with constructing URIs with relative paths
+- fixed warnings
 
 === Addressable 2.1.1
-  * more type checking changes
-  * fixed issue with unicode normalization
-  * added method to find template defaults
-  * symbolic keys are now allowed in template mappings
-  * numeric values and symbolic values are now allowed in template mappings
+- more type checking changes
+- fixed issue with unicode normalization
+- added method to find template defaults
+- symbolic keys are now allowed in template mappings
+- numeric values and symbolic values are now allowed in template mappings
 
 === Addressable 2.1.0
-  * refactored URI template support out into its own class
-  * removed extract method due to being useless and unreliable
-  * removed Addressable::URI.expand_template
-  * removed Addressable::URI#extract_mapping
-  * added partial template expansion
-  * fixed minor bugs in the parse and heuristic_parse methods
-  * fixed incompatibility with Ruby 1.9.1
-  * fixed bottleneck in Addressable::URI#hash and Addressable::URI#to_s
-  * fixed unicode normalization exception
-  * updated query_values methods to better handle subscript notation
-  * worked around issue with freezing URIs
-  * improved specs
+- refactored URI template support out into its own class
+- removed extract method due to being useless and unreliable
+- removed Addressable::URI.expand_template
+- removed Addressable::URI#extract_mapping
+- added partial template expansion
+- fixed minor bugs in the parse and heuristic_parse methods
+- fixed incompatibility with Ruby 1.9.1
+- fixed bottleneck in Addressable::URI#hash and Addressable::URI#to_s
+- fixed unicode normalization exception
+- updated query_values methods to better handle subscript notation
+- worked around issue with freezing URIs
+- improved specs
 
 === Addressable 2.0.2
-  * fixed issue with URI template expansion
-  * fixed issue with percent escaping characters 0-15
+- fixed issue with URI template expansion
+- fixed issue with percent escaping characters 0-15
 
 === Addressable 2.0.1
-  * fixed issue with query string assignment
-  * fixed issue with improperly encoded components
+- fixed issue with query string assignment
+- fixed issue with improperly encoded components
 
 === Addressable 2.0.0
-  * the initialize method now takes an options hash as its only parameter
-  * added query_values method to URI class
-  * completely replaced IDNA implementation with pure Ruby
-  * renamed Addressable::ADDRESSABLE_VERSION to Addressable::VERSION
-  * completely reworked the Rakefile
-  * changed the behavior of the port method significantly
-  * Addressable::URI.encode_segment, Addressable::URI.unencode_segment renamed
-  * documentation is now in YARD format
-  * more rigorous type checking
-  * to_str method implemented, implicit conversion to Strings now allowed
-  * Addressable::URI#omit method added, Addressable::URI#merge method replaced
-  * updated URI Template code to match v 03 of the draft spec
-  * added a bunch of new specifications
+- the initialize method now takes an options hash as its only parameter
+- added query_values method to URI class
+- completely replaced IDNA implementation with pure Ruby
+- renamed Addressable::ADDRESSABLE_VERSION to Addressable::VERSION
+- completely reworked the Rakefile
+- changed the behavior of the port method significantly
+- Addressable::URI.encode_segment, Addressable::URI.unencode_segment renamed
+- documentation is now in YARD format
+- more rigorous type checking
+- to_str method implemented, implicit conversion to Strings now allowed
+- Addressable::URI#omit method added, Addressable::URI#merge method replaced
+- updated URI Template code to match v 03 of the draft spec
+- added a bunch of new specifications
 
 === Addressable 1.0.4
-  * switched to using RSpec's pending system for specs that rely on IDN
-  * fixed issue with creating URIs with paths that are not prefixed with '/'
+- switched to using RSpec's pending system for specs that rely on IDN
+- fixed issue with creating URIs with paths that are not prefixed with '/'
 
 === Addressable 1.0.3
-  * implemented a hash method
+- implemented a hash method
 
 === Addressable 1.0.2
-  * fixed minor bug with the extract_mapping method
+- fixed minor bug with the extract_mapping method
 
 === Addressable 1.0.1
-  * fixed minor bug with the extract_mapping method
+- fixed minor bug with the extract_mapping method
 
 === Addressable 1.0.0
-  * heuristic parse method added
-  * parsing is slightly more strict
-  * replaced to_h with to_hash
-  * fixed routing methods
-  * improved specifications
-  * improved heckle rake task
-  * no surviving heckle mutations
+- heuristic parse method added
+- parsing is slightly more strict
+- replaced to_h with to_hash
+- fixed routing methods
+- improved specifications
+- improved heckle rake task
+- no surviving heckle mutations
 
 === Addressable 0.1.2
-  * improved normalization
-  * fixed bug in joining algorithm
-  * updated specifications
+- improved normalization
+- fixed bug in joining algorithm
+- updated specifications
   
 === Addressable 0.1.1
-  * updated documentation
-  * added URI Template variable extraction
+- updated documentation
+- added URI Template variable extraction
   
 === Addressable 0.1.0
-  * initial release
-  * implementation based on RFC 3986, 3987
-  * support for IRIs via libidn
-  * support for the URI Template draft spec
+- initial release
+- implementation based on RFC 3986, 3987
+- support for IRIs via libidn
+- support for the URI Template draft spec

data/LICENSE

@@ -1,4 +1,4 @@
-Addressable, Copyright (c) 2006-2008 Bob Aman
+Addressable, Copyright (c) 2006-2010 Bob Aman
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README

@@ -1,10 +1,20 @@
+== About
+
+Homepage::  Addressable[http://addressable.rubyforge.org/]
+Authors::   Bob Aman (mailto:bob@sporkmonger.com)
+Copyright:: Copyright 2010 Bob Aman
+License::   MIT
+
 Addressable is a replacement for the URI implementation that is part of
 Ruby's standard library. It more closely conforms to the relevant RFCs and
 adds support for IRIs and URI templates.  Additionally, it provides extensive
 support for URI templates.
 
-Example usage:
- 
+== Classes
+- {Addressable::URI}
+- {Addressable::Template}
+
+== Example usage
   require "addressable/uri"
 
   uri = Addressable::URI.parse("http://example.com/path/to/resource/")

data/Rakefile

@@ -27,38 +27,6 @@ Ruby's standard library. It more closely conforms to the relevant RFCs and
 adds support for IRIs and URI templates.
 TEXT
 
-desc "generates .gemspec file"
-task :gemspec do
-  spec = Gem::Specification.new do |p|
-    p.name = ENV["GEM_PREFIX"] ? "#{ENV["GEM_PREFIX"]}-addressable" : 'addressable'
-    p.version = PKG_VERSION
-
-    p.summary = PKG_SUMMARY
-    p.description = PKG_DESCRIPTION
-
-    p.author = 'Bob Aman'
-    p.email  = 'bob@sporkmonger.com'
-    p.homepage = 'http://github.com/mislav/addressable'
-    p.rubyforge_project = nil
-
-    p.files = FileList['Rakefile', '{bin,lib,tasks,spec}/**/*', 'README*', 'LICENSE*', 'CHANGELOG*'] & `git ls-files`.split
-
-    p.executables = Dir['bin/*'].map { |f| File.basename(f) }
-
-    p.has_rdoc = true
-  end
-
-  spec_string = spec.to_ruby
-
-  begin
-    Thread.new { eval("$SAFE = 3\n#{spec_string}", binding) }.join
-  rescue
-    abort "unsafe gemspec: #{$!}"
-  else
-    File.open("#{spec.name}.gemspec", 'w') { |file| file.write spec_string }
-  end
-end
-
 PKG_FILES = FileList[
     "lib/**/*", "spec/**/*", "vendor/**/*",
     "tasks/**/*", "website/**/*",

data/lib/addressable/template.rb

@@ -1,6 +1,6 @@
 # encoding:utf-8
 #--
-# Addressable, Copyright (c) 2006-2008 Bob Aman
+# Addressable, Copyright (c) 2006-2010 Bob Aman
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the

data/lib/addressable/uri.rb

@@ -1,6 +1,6 @@
 # encoding:utf-8
 #--
-# Addressable, Copyright (c) 2006-2008 Bob Aman
+# Addressable, Copyright (c) 2006-2010 Bob Aman
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -59,15 +59,15 @@ module Addressable
     #
     # @param [String, Addressable::URI, #to_str] uri
     #   The URI string to parse.
-    # No parsing is performed if the object is already an
-    # <tt>Addressable::URI</tt>.
+    #   No parsing is performed if the object is already an
+    #   <code>Addressable::URI</code>.
     #
     # @return [Addressable::URI] The parsed URI.
     def self.parse(uri)
       # 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.
@@ -130,18 +130,18 @@ module Addressable
     #
     # @param [String, Addressable::URI, #to_str] uri
     #   The URI string to parse.
-    # No parsing is performed if the object is already an
-    # <tt>Addressable::URI</tt>.
+    #   No parsing is performed if the object is already an
+    #   <code>Addressable::URI</code>.
     # @param [Hash] hints
-    #   A <tt>Hash</tt> of hints to the heuristic parser.
-    # Defaults to <tt>{:scheme => "http"}</tt>.
+    #   A <code>Hash</code> of hints to the heuristic parser.
+    #   Defaults to <code>{:scheme => "http"}</code>.
     #
     # @return [Addressable::URI] The parsed URI.
     def self.heuristic_parse(uri, hints={})
       # 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
@@ -167,11 +167,13 @@ module Addressable
       if parsed.path.include?(".")
         new_host = parsed.path[/^([^\/]+\.[^\/]*)/, 1]
         if new_host
-          new_path = parsed.path.gsub(
-            Regexp.new("^" + Regexp.escape(new_host)), "")
-          parsed.host = new_host
-          parsed.path = new_path
-          parsed.scheme = hints[:scheme] unless parsed.scheme
+          parsed.defer_validation do
+            new_path = parsed.path.gsub(
+              Regexp.new("^" + Regexp.escape(new_host)), "")
+            parsed.host = new_host
+            parsed.path = new_path
+            parsed.scheme = hints[:scheme] unless parsed.scheme
+          end
         end
       end
       return parsed
@@ -181,13 +183,13 @@ module Addressable
     # Converts a path to a file scheme URI. If the path supplied is
     # relative, it will be returned as a relative URI. If the path supplied
     # is actually a non-file URI, it will parse the URI as if it had been
-    # parsed with <tt>Addressable::URI.parse</tt>. Handles all of the
+    # parsed with <code>Addressable::URI.parse</code>. Handles all of the
     # various Microsoft-specific formats for specifying paths.
     #
     # @param [String, Addressable::URI, #to_str] path
-    #
-    # Typically a <tt>String</tt> path to a file or directory, but will return
-    # a sensible return value if an absolute URI is supplied instead.
+    #   Typically a <code>String</code> path to a file or directory, but
+    #   will return a sensible return value if an absolute URI is supplied
+    #   instead.
     #
     # @return [Addressable::URI]
     #   The parsed file scheme URI or the original URI if some other URI
@@ -277,17 +279,17 @@ module Addressable
     # @param [String, #to_str] component The URI component to encode.
     #
     # @param [String, Regexp] character_class
-    #
-    # The characters which are not percent encoded. If a <tt>String</tt> is
-    # passed, the <tt>String</tt> must be formatted as a regular expression
-    # character class. (Do not include the surrounding square brackets.)  For
-    # example, <tt>"b-zB-Z0-9"</tt> would cause everything but the letters 'b'
-    # through 'z' and the numbers '0' through '9' to be percent encoded. If a
-    # <tt>Regexp</tt> is passed, the value <tt>/[^b-zB-Z0-9]/</tt> would have
-    # the same effect. A set of useful <tt>String</tt> values may be found in
-    # the <tt>Addressable::URI::CharacterClasses</tt> 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>.
+    #   The characters which are not percent encoded. If a <code>String</code>
+    #   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
+    #   <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>.
     #
     # @return [String] The encoded component.
     #
@@ -332,21 +334,21 @@ module Addressable
     ##
     # Unencodes any percent encoded characters within a URI component.
     # This method may be used for unencoding either components or full URIs,
-    # however, it is recommended to use the <tt>unencode_component</tt> alias
-    # when unencoding components.
+    # however, it is recommended to use the <code>unencode_component</code>
+    # alias when unencoding components.
     #
     # @param [String, Addressable::URI, #to_str] uri
     #   The URI or component to unencode.
     #
     # @param [Class] returning
     #   The type of object to return.
-    # This value may only be set to <tt>String</tt> or
-    # <tt>Addressable::URI</tt>. All other values are invalid. Defaults to
-    # <tt>String</tt>.
+    #   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>.
     #
     # @return [String, Addressable::URI]
     #   The unencoded component or URI.
-    # The return type is determined by the <tt>returning</tt> parameter.
+    #   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)
@@ -381,17 +383,17 @@ module Addressable
     # @param [String, #to_str] component The URI component to encode.
     #
     # @param [String, Regexp] character_class
-    #
-    # The characters which are not percent encoded. If a <tt>String</tt> is
-    # passed, the <tt>String</tt> must be formatted as a regular expression
-    # character class. (Do not include the surrounding square brackets.)  For
-    # example, <tt>"b-zB-Z0-9"</tt> would cause everything but the letters 'b'
-    # through 'z' and the numbers '0' through '9' to be percent encoded. If a
-    # <tt>Regexp</tt> is passed, the value <tt>/[^b-zB-Z0-9]/</tt> would have
-    # the same effect. A set of useful <tt>String</tt> values may be found in
-    # the <tt>Addressable::URI::CharacterClasses</tt> 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>.
+    #   The characters which are not percent encoded. If a <code>String</code>
+    #   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
+    #   <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>.
     #
     # @return [String] The normalized component.
     #
@@ -447,13 +449,13 @@ module Addressable
     #
     # @param [Class] returning
     #   The type of object to return.
-    # This value may only be set to <tt>String</tt> or
-    # <tt>Addressable::URI</tt>. All other values are invalid. Defaults to
-    # <tt>String</tt>.
+    #   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>.
     #
     # @return [String, Addressable::URI]
     #   The encoded URI.
-    # The return type is determined by the <tt>returning</tt> parameter.
+    #   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)
@@ -497,13 +499,13 @@ module Addressable
     #
     # @param [Class] returning
     #   The type of object to return.
-    # This value may only be set to <tt>String</tt> or
-    # <tt>Addressable::URI</tt>. All other values are invalid. Defaults to
-    # <tt>String</tt>.
+    #   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>.
     #
     # @return [String, Addressable::URI]
     #   The encoded URI.
-    # The return type is determined by the <tt>returning</tt> parameter.
+    #   The return type is determined by the <code>returning</code> parameter.
     def self.normalized_encode(uri, returning=String)
       if !uri.respond_to?(:to_str)
         raise TypeError, "Can't convert #{uri.class} into String."
@@ -558,6 +560,81 @@ module Addressable
       end
     end
 
+    ##
+    # Encodes a set of key/value pairs according to the rules for the
+    # <code>application/x-www-form-urlencoded</code> MIME type.
+    #
+    # @param [#to_hash, #to_ary] form_values
+    #   The form values to encode.
+    #
+    # @param [TrueClass, FalseClass] sort
+    #   Sort the key/value pairs prior to encoding.
+    #   Defaults to <code>false</code>.
+    #
+    # @return [String]
+    #   The encoded value.
+    def self.form_encode(form_values, sort=false)
+      if form_values.respond_to?(:to_hash)
+        form_values = form_values.to_hash.to_a
+      elsif form_values.respond_to?(:to_ary)
+        form_values = form_values.to_ary
+      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]
+      end
+      if sort
+        # Useful for OAuth and optimizing caching systems
+        form_values = form_values.sort
+      end
+      escaped_form_values = form_values.map do |(key, value)|
+        # Line breaks are CRLF pairs
+        [
+          self.encode_component(
+            key.gsub(/(\r\n|\n|\r)/, "\r\n"),
+            CharacterClasses::UNRESERVED
+          ).gsub("%20", "+"),
+          self.encode_component(
+            value.gsub(/(\r\n|\n|\r)/, "\r\n"),
+            CharacterClasses::UNRESERVED
+          ).gsub("%20", "+")
+        ]
+      end
+      return (escaped_form_values.map do |(key, value)|
+        "#{key}=#{value}"
+      end).join("&")
+    end
+
+    ##
+    # Decodes a <code>String</code> according to the rules for the
+    # <code>application/x-www-form-urlencoded</code> MIME type.
+    #
+    # @param [String, #to_str] encoded_value
+    #   The form values to decode.
+    #
+    # @return [Array]
+    #   The decoded values.
+    #   This is not a <code>Hash</code> because of the possibility for
+    #   duplicate keys.
+    def self.form_unencode(encoded_value)
+      if !encoded_value.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{encoded_value.class} into String."
+      end
+      encoded_value = encoded_value.to_str
+      split_values = encoded_value.split("&").map do |pair|
+        pair.split("=", 2)
+      end
+      return split_values.map do |(key, value)|
+        [
+          key ? self.unencode_component(
+            key.gsub("+", "%20")).gsub(/(\r\n|\n|\r)/, "\n") : nil,
+          value ? (self.unencode_component(
+            value.gsub("+", "%20")).gsub(/(\r\n|\n|\r)/, "\n")) : nil
+        ]
+      end
+    end
+
     ##
     # Creates a new uri object from component parts.
     #
@@ -647,13 +724,19 @@ module Addressable
 
       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."
       end
-      @scheme = new_scheme ? new_scheme.to_str : nil
+      @scheme = new_scheme
       @scheme = nil if @scheme.to_s.strip == ""
 
       # Reset dependant values
       @normalized_scheme = nil
       @uri_string = nil
+      @hash = nil
 
       # Ensure we haven't created an invalid URI
       validate()
@@ -714,6 +797,7 @@ module Addressable
       @authority = nil
       @normalized_user = nil
       @uri_string = nil
+      @hash = nil
 
       # Ensure we haven't created an invalid URI
       validate()
@@ -775,6 +859,7 @@ module Addressable
       @authority = nil
       @normalized_password = nil
       @uri_string = nil
+      @hash = nil
 
       # Ensure we haven't created an invalid URI
       validate()
@@ -844,6 +929,7 @@ module Addressable
       # Reset dependant values
       @authority = nil
       @uri_string = nil
+      @hash = nil
 
       # Ensure we haven't created an invalid URI
       validate()
@@ -899,6 +985,7 @@ module Addressable
       @authority = nil
       @normalized_host = nil
       @uri_string = nil
+      @hash = nil
 
       # Ensure we haven't created an invalid URI
       validate()
@@ -984,14 +1071,35 @@ module Addressable
       @userinfo = nil
       @normalized_userinfo = nil
       @uri_string = nil
+      @hash = nil
 
       # Ensure we haven't created an invalid URI
       validate()
     end
 
+    ##
+    # The origin for this URI, serialized to ASCII, as per
+    # draft-ietf-websec-origin-00, section 5.2.
+    #
+    # @return [String] The serialized origin.
+    def origin
+      return (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
+
     # Returns an array of known ip-based schemes. These schemes typically
     # use a similar URI form:
-    # //<user>:<password>@<host>:<port>/<url-path>
+    # <code>//<user>:<password>@<host>:<port>/<url-path></code>
     def self.ip_based_schemes
       return self.port_mapping.keys
     end
@@ -1065,6 +1173,7 @@ module Addressable
       @inferred_port = nil
       @normalized_port = nil
       @uri_string = nil
+      @hash = nil
 
       # Ensure we haven't created an invalid URI
       validate()
@@ -1090,6 +1199,76 @@ module Addressable
       end)
     end
 
+    ##
+    # The combination of components that represent a site.
+    # Combines the scheme, user, password, host, and port components.
+    # Primarily useful for HTTP and HTTPS.
+    #
+    # For example, <code>"http://example.com/path?query"</code> would have a
+    # <code>site</code> value of <code>"http://example.com"</code>.
+    #
+    # @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)
+    end
+
+    ##
+    # The normalized combination of components that represent a site.
+    # Combines the scheme, user, password, host, and port components.
+    # Primarily useful for HTTP and HTTPS.
+    #
+    # For example, <code>"http://example.com/path?query"</code> would have a
+    # <code>site</code> value of <code>"http://example.com"</code>.
+    #
+    # @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
+        end
+      end)
+    end
+
+    ##
+    # Sets the site value for this URI.
+    #
+    # @param [String, #to_str] new_site The new site value.
+    def site=(new_site)
+      if new_site
+        if !new_site.respond_to?(:to_str)
+          raise TypeError, "Can't convert #{new_site.class} into String."
+        end
+        new_site = new_site.to_str
+        # These two regular expressions derived from the primary parsing
+        # expression
+        self.scheme = new_site[/^(?:([^:\/?#]+):)?(?:\/\/(?:[^\/?#]*))?$/, 1]
+        self.authority = new_site[
+          /^(?:(?:[^:\/?#]+):)?(?:\/\/([^\/?#]*))?$/, 1
+        ]
+      else
+        self.scheme = nil
+        self.authority = nil
+      end
+    end
+
     ##
     # The path component for this URI.
     #
@@ -1105,8 +1284,13 @@ module Addressable
     # @return [String] The path component, normalized.
     def normalized_path
       @normalized_path ||= (begin
+        if self.scheme == nil && self.path != nil && self.path != "" &&
+            self.path =~ /^(?!\/)[^\/:]*:.*$/
+          # 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 in Python.
+        # found by default in Python.
         result = (self.path.strip.split("/", -1).map do |segment|
           Addressable::URI.normalize_component(
             segment,
@@ -1141,6 +1325,7 @@ module Addressable
       # Reset dependant values
       @normalized_path = nil
       @uri_string = nil
+      @hash = nil
     end
 
     ##
@@ -1203,17 +1388,18 @@ module Addressable
       # Reset dependant values
       @normalized_query = nil
       @uri_string = nil
+      @hash = nil
     end
 
     ##
     # Converts the query component to a Hash value.
     #
     # @option [Symbol] notation
-    #   May be one of <tt>:flat</tt>, <tt>:dot</tt>, or <tt>:subscript</tt>.
-    # The <tt>:dot</tt> notation is not supported for assignment. Default
-    # value is <tt>:subscript</tt>.
+    #   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>.
     #
-    # @return [Hash] The query string parsed as a Hash object.
+    # @return [Hash, Array] The query string parsed as a Hash or Array object.
     #
     # @example
     #   Addressable::URI.parse("?one=1&two=2&three=3").query_values
@@ -1236,12 +1422,16 @@ module Addressable
     #     "?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].include?(options[:notation])
+      if ![:flat, :dot, :subscript, :flat_array].include?(options[:notation])
         raise ArgumentError,
-          "Invalid notation. Must be one of: [:flat, :dot, :subscript]."
+          "Invalid notation. Must be one of: " +
+          "[:flat, :dot, :subscript, :flat_array]."
       end
       dehash = lambda do |hash|
         hash.each do |(key, value)|
@@ -1258,19 +1448,22 @@ module Addressable
         end
       end
       return nil if self.query == nil
+      empty_accumulator = :flat_array == options[:notation] ? [] : {}
       return ((self.query.split("&").map do |pair|
-        pair.split("=")
-      end).inject({}) do |accumulator, (key, value)|
+        pair.split("=", 2) 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(/\+/, " ")
+          value = self.class.unencode_component(value.gsub(/\+/, " "))
         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]
         else
           if options[:notation] == :dot
             array_value = false
@@ -1293,8 +1486,12 @@ module Addressable
           end
         end
         accumulator
-      end).inject({}) do |accumulator, (key, value)|
-        accumulator[key] = value.kind_of?(Hash) ? dehash.call(value) : value
+      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
       end
     end
@@ -1302,15 +1499,32 @@ module Addressable
     ##
     # 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.
     #
-    # @param [Hash, #to_hash] new_query_values The new query values.
+    # @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.respond_to?(:to_hash)
-        raise TypeError, "Can't convert #{new_query_values.class} into Hash."
+      if new_query_values == nil
+        self.query = nil
+        return nil
+      end
+
+      if !new_query_values.is_a?(Array)
+        if !new_query_values.respond_to?(:to_hash)
+          raise TypeError,
+            "Can't convert #{new_query_values.class} into Hash."
+        end
+        new_query_values = new_query_values.to_hash
+        new_query_values = new_query_values.map do |key, value|
+          key = key.to_s if key.kind_of?(Symbol)
+          [key, value]
+        end
+        # Useful default for OAuth and caching.
+        # Only to be used for non-Array inputs. Arrays should preserve order.
+        new_query_values.sort!
       end
-      new_query_values = new_query_values.to_hash
+      # new_query_values have form [['key1', 'value1'], ['key2', 'value2']]
 
       # Algorithm shamelessly stolen from Julien Genestoux, slightly modified
       buffer = ""
@@ -1344,11 +1558,7 @@ module Addressable
           end
         end
       end
-      @query = buffer.chop
-
-      # Reset dependant values
-      @normalized_query = nil
-      @uri_string = nil
+      self.query = buffer.chop
     end
 
     ##
@@ -1386,6 +1596,7 @@ module Addressable
 
       # Reset dependant values
       @uri_string = nil
+      @hash = nil
     end
 
     ##
@@ -1429,6 +1640,7 @@ module Addressable
       # Reset dependant values
       @normalized_fragment = nil
       @uri_string = nil
+      @hash = nil
 
       # Ensure we haven't created an invalid URI
       validate()
@@ -1438,8 +1650,8 @@ module Addressable
     # Determines if the scheme indicates an IP-based protocol.
     #
     # @return [TrueClass, FalseClass]
-    # <tt>true</tt> if the scheme indicates an IP-based protocol.
-    # <tt>false</tt> otherwise.
+    #   <code>true</code> if the scheme indicates an IP-based protocol.
+    #   <code>false</code> otherwise.
     def ip_based?
       if self.scheme
         return self.class.ip_based_schemes.include?(
@@ -1452,7 +1664,8 @@ module Addressable
     # Determines if the URI is relative.
     #
     # @return [TrueClass, FalseClass]
-    # <tt>true</tt> if the URI is relative. <tt>false</tt> otherwise.
+    #   <code>true</code> if the URI is relative. <code>false</code>
+    #   otherwise.
     def relative?
       return self.scheme.nil?
     end
@@ -1461,7 +1674,8 @@ module Addressable
     # Determines if the URI is absolute.
     #
     # @return [TrueClass, FalseClass]
-    # <tt>true</tt> if the URI is absolute. <tt>false</tt> otherwise.
+    #   <code>true</code> if the URI is absolute. <code>false</code>
+    #   otherwise.
     def absolute?
       return !relative?
     end
@@ -1568,7 +1782,7 @@ module Addressable
     alias_method :+, :join
 
     ##
-    # Destructive form of <tt>join</tt>.
+    # Destructive form of <code>join</code>.
     #
     # @param [String, Addressable::URI, #to_str] The URI to join with.
     #
@@ -1580,10 +1794,10 @@ module Addressable
     end
 
     ##
-    # Merges a URI with a <tt>Hash</tt> of components.
-    # This method has different behavior from <tt>join</tt>. Any components
-    # present in the <tt>hash</tt> parameter will override the original
-    # components. The path component is not treated specially.
+    # Merges a URI with a <code>Hash</code> of components.
+    # This method has different behavior from <code>join</code>. Any
+    # components present in the <code>hash</code> parameter will override the
+    # original components. The path component is not treated specially.
     #
     # @param [Hash, Addressable::URI, #to_hash] The components to merge with.
     #
@@ -1648,7 +1862,7 @@ module Addressable
     end
 
     ##
-    # Destructive form of <tt>merge</tt>.
+    # Destructive form of <code>merge</code>.
     #
     # @param [Hash, Addressable::URI, #to_hash] The components to merge with.
     #
@@ -1662,7 +1876,7 @@ module Addressable
     ##
     # Returns the shortest normalized relative form of this URI that uses the
     # supplied URI as a base for resolution. Returns an absolute URI if
-    # necessary. This is effectively the opposite of <tt>route_to</tt>.
+    # necessary. This is effectively the opposite of <code>route_to</code>.
     #
     # @param [String, Addressable::URI, #to_str] uri The URI to route from.
     #
@@ -1720,7 +1934,7 @@ module Addressable
     ##
     # Returns the shortest normalized relative form of the supplied URI that
     # uses this URI as a base for resolution. Returns an absolute URI if
-    # necessary. This is effectively the opposite of <tt>route_from</tt>.
+    # necessary. This is effectively the opposite of <code>route_from</code>.
     #
     # @param [String, Addressable::URI, #to_str] uri The URI to route to.
     #
@@ -1784,14 +1998,15 @@ module Addressable
     end
 
     ##
-    # Returns <tt>true</tt> if the URI objects are equal. This method
+    # Returns <code>true</code> if the URI objects are equal. This method
     # normalizes both URIs before doing the comparison, and allows comparison
-    # against <tt>Strings</tt>.
+    # against <code>Strings</code>.
     #
     # @param [Object] uri The URI to compare.
     #
     # @return [TrueClass, FalseClass]
-    #   <tt>true</tt> if the URIs are equivalent, <tt>false</tt> otherwise.
+    #   <code>true</code> if the URIs are equivalent, <code>false</code>
+    #   otherwise.
     def ===(uri)
       if uri.respond_to?(:normalize)
         uri_string = uri.normalize.to_s
@@ -1806,26 +2021,28 @@ module Addressable
     end
 
     ##
-    # Returns <tt>true</tt> if the URI objects are equal. This method
+    # Returns <code>true</code> if the URI objects are equal. This method
     # normalizes both URIs before doing the comparison.
     #
     # @param [Object] uri The URI to compare.
     #
     # @return [TrueClass, FalseClass]
-    #   <tt>true</tt> if the URIs are equivalent, <tt>false</tt> otherwise.
+    #   <code>true</code> if the URIs are equivalent, <code>false</code>
+    #   otherwise.
     def ==(uri)
       return false unless uri.kind_of?(self.class)
       return self.normalize.to_s == uri.normalize.to_s
     end
 
     ##
-    # Returns <tt>true</tt> if the URI objects are equal. This method
+    # Returns <code>true</code> if the URI objects are equal. This method
     # does NOT normalize either URI before doing the comparison.
     #
     # @param [Object] uri The URI to compare.
     #
     # @return [TrueClass, FalseClass]
-    #   <tt>true</tt> if the URIs are equivalent, <tt>false</tt> otherwise.
+    #   <code>true</code> if the URIs are equivalent, <code>false</code>
+    #   otherwise.
     def eql?(uri)
       return false unless uri.kind_of?(self.class)
       return self.to_s == uri.to_s
@@ -1875,7 +2092,7 @@ module Addressable
     # Determines if the URI is frozen.
     #
     # @return [TrueClass, FalseClass]
-    #   True if the URI is frozen, false otherwise.
+    #   <code>true</code> if the URI is frozen, <code>false</code> otherwise.
     def frozen?
       self.to_s.frozen?
     end
@@ -1924,9 +2141,9 @@ module Addressable
     end
 
     ##
-    # Converts the URI to a <tt>String</tt>.
+    # Converts the URI to a <code>String</code>.
     #
-    # @return [String] The URI's <tt>String</tt> representation.
+    # @return [String] The URI's <code>String</code> representation.
     def to_s
       @uri_string ||= (begin
         uri_string = ""
@@ -1943,13 +2160,13 @@ module Addressable
     end
 
     ##
-    # URI's are glorified <tt>Strings</tt>. Allow implicit conversion.
+    # URI's are glorified <code>Strings</code>. Allow implicit conversion.
     alias_method :to_str, :to_s
 
     ##
     # Returns a Hash of the URI components.
     #
-    # @return [Hash] The URI as a <tt>Hash</tt> of components.
+    # @return [Hash] The URI as a <code>Hash</code> of components.
     def to_hash
       return {
         :scheme => self.scheme,
@@ -1964,9 +2181,9 @@ module Addressable
     end
 
     ##
-    # Returns a <tt>String</tt> representation of the URI object's state.
+    # Returns a <code>String</code> representation of the URI object's state.
     #
-    # @return [String] The URI object's state, as a <tt>String</tt>.
+    # @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)
     end
@@ -2015,6 +2232,9 @@ module Addressable
         end
         normalized_path.gsub!(/^\.\.?\/?/, "")
         normalized_path.gsub!(/^\/\.\.?\//, "/")
+
+        # Non-standard
+        normalized_path.gsub!(/^(\/\.\.?)+\/?$/, "/")
       end until previous_state == normalized_path
       return normalized_path
     end
@@ -2036,6 +2256,11 @@ module Addressable
           raise InvalidURIError, "Hostname not supplied: '#{self.to_s}'"
         end
       end
+      if self.path != nil && self.path != "" && self.path[0..0] != "/" &&
+          self.authority != nil
+        raise InvalidURIError,
+          "Cannot have a relative path with an authority set: '#{self.to_s}'"
+      end
       return nil
     end
 
@@ -2043,9 +2268,9 @@ module Addressable
     # Replaces the internal state of self with the specified URI's state.
     # Used in destructive operations to avoid massive code repetition.
     #
-    # @param [Addressable::URI] uri The URI to replace <tt>self</tt> with.
+    # @param [Addressable::URI] uri The URI to replace <code>self</code> with.
     #
-    # @return [Addressable::URI] <tt>self</tt>.
+    # @return [Addressable::URI] <code>self</code>.
     def replace_self(uri)
       # Reset dependant values
       instance_variables.each do |var|