honkster-addressable 2.1.2 → 2.2.3

data/lib/addressable/version.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
@@ -27,8 +27,8 @@ if !defined?(Addressable::VERSION)
   module Addressable
     module VERSION #:nodoc:
       MAJOR = 2
-      MINOR = 1
-      TINY  = 2
+      MINOR = 2
+      TINY  = 5
 
       STRING = [MAJOR, MINOR, TINY].join('.')
     end

data/spec/addressable/uri_spec.rb

@@ -164,6 +164,10 @@ describe Addressable::URI, "when created from nil components" do
     @uri = Addressable::URI.new
   end
 
+  it "should have a nil site value" do
+    @uri.site.should == nil
+  end
+
   it "should have an empty path" do
     @uri.path.should == ""
   end
@@ -172,9 +176,16 @@ describe Addressable::URI, "when created from nil components" do
     @uri.to_s.should == ""
   end
 
-  it "should still be an empty uri if the scheme is set to whitespace" do
-    @uri.scheme = "\t \n"
-    @uri.to_s.should == ""
+  it "should raise an error if the scheme is set to whitespace" do
+    (lambda do
+      @uri.scheme = "\t \n"
+    end).should raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should raise an error if the scheme is set to all digits" do
+    (lambda do
+      @uri.scheme = "123"
+    end).should raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should raise an error if set into an invalid state" do
@@ -211,6 +222,10 @@ describe Addressable::URI, "when created from string components" do
     )
   end
 
+  it "should have a site value of 'http://example.com'" do
+    @uri.site.should == "http://example.com"
+  end
+
   it "should be equal to the equivalent parsed URI" do
     @uri.should == Addressable::URI.parse("http://example.com")
   end
@@ -253,6 +268,14 @@ describe Addressable::URI, "when created with an authority and no port" do
     @uri.port.should == nil
     @uri.inferred_port.should == nil
   end
+
+  it "should have a site value of '//user@example.com'" do
+    @uri.site.should == "//user@example.com"
+  end
+
+  it "should have a 'null' origin" do
+    @uri.origin.should == 'null'
+  end
 end
 
 describe Addressable::URI, "when created with both a userinfo and a user" do
@@ -265,35 +288,65 @@ end
 
 describe Addressable::URI, "when created with a path that hasn't been " +
     "prefixed with a '/' but a host specified" do
-  it "should prefix a '/' to the path" do
-    Addressable::URI.new(
+  before do
+    @uri = Addressable::URI.new(
       :scheme => "http", :host => "example.com", :path => "path"
-    ).should == Addressable::URI.parse("http://example.com/path")
+    )
+  end
+
+  it "should prefix a '/' to the path" do
+    @uri.should == Addressable::URI.parse("http://example.com/path")
+  end
+
+  it "should have a site value of 'http://example.com'" do
+    @uri.site.should == "http://example.com"
+  end
+
+  it "should have an origin of 'http://example.com" do
+    @uri.origin.should == 'http://example.com'
   end
 end
 
 describe Addressable::URI, "when created with a path that hasn't been " +
     "prefixed with a '/' but no host specified" do
-  it "should prefix a '/' to the path" do
-    Addressable::URI.new(
+  before do
+    @uri = Addressable::URI.new(
       :scheme => "http", :path => "path"
-    ).should == Addressable::URI.parse("http:path")
+    )
+  end
+
+  it "should not prefix a '/' to the path" do
+    @uri.should == Addressable::URI.parse("http:path")
+  end
+
+  it "should have a site value of 'http:'" do
+    @uri.site.should == "http:"
+  end
+
+  it "should have a 'null' origin" do
+    @uri.origin.should == 'null'
   end
 end
 
 describe Addressable::URI, "when parsed from an Addressable::URI object" do
-  it "should return the object" do
-    uri = Addressable::URI.parse("http://example.com/")
-    (lambda do
-      Addressable::URI.parse(uri).object_id.should == uri.object_id
-    end).should_not raise_error
+  it "should not have unexpected side-effects" do
+    original_uri = Addressable::URI.parse("http://example.com/")
+    new_uri = Addressable::URI.parse(original_uri)
+    new_uri.host = 'www.example.com'
+    new_uri.host.should == 'www.example.com'
+    new_uri.to_s.should == 'http://www.example.com/'
+    original_uri.host.should == 'example.com'
+    original_uri.to_s.should == 'http://example.com/'
   end
 
-  it "should return the object" do
-    uri = Addressable::URI.parse("http://example.com/")
-    (lambda do
-      Addressable::URI.heuristic_parse(uri).object_id.should == uri.object_id
-    end).should_not raise_error
+  it "should not have unexpected side-effects" do
+    original_uri = Addressable::URI.parse("http://example.com/")
+    new_uri = Addressable::URI.heuristic_parse(original_uri)
+    new_uri.host = 'www.example.com'
+    new_uri.host.should == 'www.example.com'
+    new_uri.to_s.should == 'http://www.example.com/'
+    original_uri.host.should == 'example.com'
+    original_uri.to_s.should == 'http://example.com/'
   end
 end
 
@@ -335,6 +388,10 @@ describe Addressable::URI, "when parsed from ''" do
   it "should be considered to be in normal form" do
     @uri.normalize.should be_eql(@uri)
   end
+
+  it "should have a 'null' origin" do
+    @uri.origin.should == 'null'
+  end
 end
 
 # Section 1.1.2 of RFC 3986
@@ -367,6 +424,10 @@ describe Addressable::URI, "when parsed from " +
   it "should be considered to be in normal form" do
     @uri.normalize.should be_eql(@uri)
   end
+
+  it "should have an origin of 'ftp://ftp.is.co.za'" do
+    @uri.origin.should == 'ftp://ftp.is.co.za'
+  end
 end
 
 # Section 1.1.2 of RFC 3986
@@ -409,6 +470,10 @@ describe Addressable::URI, "when parsed from " +
     @uri.omit!(:scheme)
     @uri.to_s.should == "//www.ietf.org/rfc/rfc2396.txt"
   end
+
+  it "should have an origin of 'http://www.ietf.org'" do
+    @uri.origin.should == 'http://www.ietf.org'
+  end
 end
 
 # Section 1.1.2 of RFC 3986
@@ -467,6 +532,10 @@ describe Addressable::URI, "when parsed from " +
       @uri.omit(:authority, :path)
     end).should raise_error(Addressable::URI::InvalidURIError)
   end
+
+  it "should have an origin of 'ldap://[2001:db8::7]'" do
+    @uri.origin.should == 'ldap://[2001:db8::7]'
+  end
 end
 
 # Section 1.1.2 of RFC 3986
@@ -495,6 +564,10 @@ describe Addressable::URI, "when parsed from " +
   it "should be considered to be in normal form" do
     @uri.normalize.should be_eql(@uri)
   end
+
+  it "should have a 'null' origin" do
+    @uri.origin.should == 'null'
+  end
 end
 
 # Section 1.1.2 of RFC 3986
@@ -523,6 +596,10 @@ describe Addressable::URI, "when parsed from " +
   it "should be considered to be in normal form" do
     @uri.normalize.should be_eql(@uri)
   end
+
+  it "should have a 'null' origin" do
+    @uri.origin.should == 'null'
+  end
 end
 
 # Section 1.1.2 of RFC 3986
@@ -551,6 +628,10 @@ describe Addressable::URI, "when parsed from " +
   it "should be considered to be in normal form" do
     @uri.normalize.should be_eql(@uri)
   end
+
+  it "should have a 'null' origin" do
+    @uri.origin.should == 'null'
+  end
 end
 
 # Section 1.1.2 of RFC 3986
@@ -587,6 +668,10 @@ describe Addressable::URI, "when parsed from " +
   it "should be considered to be in normal form" do
     @uri.normalize.should be_eql(@uri)
   end
+
+  it "should have an origin of 'telnet://192.0.2.16:80'" do
+    @uri.origin.should == 'telnet://192.0.2.16:80'
+  end
 end
 
 # Section 1.1.2 of RFC 3986
@@ -617,6 +702,10 @@ describe Addressable::URI, "when parsed from " +
   it "should be considered to be in normal form" do
     @uri.normalize.should be_eql(@uri)
   end
+
+  it "should have a 'null' origin" do
+    @uri.origin.should == 'null'
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -734,6 +823,27 @@ describe Addressable::URI, "when parsed from " +
     @uri.join!(@uri).to_s.should == "http://example.com"
   end
 
+  it "should be equivalent to http://EXAMPLE.com" do
+    @uri.should == Addressable::URI.parse("http://EXAMPLE.com")
+  end
+
+  it "should be equivalent to http://EXAMPLE.com:80/" do
+    @uri.should == Addressable::URI.parse("http://EXAMPLE.com:80/")
+  end
+
+  it "should have the same hash as http://example.com" do
+    @uri.hash.should == Addressable::URI.parse("http://example.com").hash
+  end
+
+  it "should have the same hash as http://EXAMPLE.com after assignment" do
+    @uri.host = "EXAMPLE.com"
+    @uri.hash.should == Addressable::URI.parse("http://EXAMPLE.com").hash
+  end
+
+  it "should have a different hash from http://EXAMPLE.com" do
+    @uri.hash.should_not == Addressable::URI.parse("http://EXAMPLE.com").hash
+  end
+
   # Section 6.2.3 of RFC 3986
   it "should be equivalent to http://example.com/" do
     @uri.should == Addressable::URI.parse("http://example.com/")
@@ -871,6 +981,10 @@ describe Addressable::URI, "when parsed from " +
   it "should be identical to its duplicate" do
     @uri.should == @uri.dup
   end
+
+  it "should have an origin of 'http://example.com'" do
+    @uri.origin.should == 'http://example.com'
+  end
 end
 
 # Section 5.1.2 of RFC 2616
@@ -898,6 +1012,12 @@ describe Addressable::URI, "when parsed from " +
     @uri.query.should == "x=y"
   end
 
+  it "should raise an error if the site value is set to something bogus" do
+    (lambda do
+      @uri.site = 42
+    end).should raise_error(TypeError)
+  end
+
   it "should raise an error if the request URI is set to something bogus" do
     (lambda do
       @uri.request_uri = 42
@@ -916,6 +1036,10 @@ describe Addressable::URI, "when parsed from " +
       :fragment => nil
     }
   end
+
+  it "should have an origin of 'http://www.w3.org'" do
+    @uri.origin.should == 'http://www.w3.org'
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -995,6 +1119,46 @@ describe Addressable::URI, "when parsed from " +
   it "should have the same hash as an equal URI" do
     @uri.hash.should == Addressable::URI.parse("http://example.com/").hash
   end
+
+  it "should be equivalent to http://EXAMPLE.com" do
+    @uri.should == Addressable::URI.parse("http://EXAMPLE.com")
+  end
+
+  it "should be equivalent to http://EXAMPLE.com:80/" do
+    @uri.should == Addressable::URI.parse("http://EXAMPLE.com:80/")
+  end
+
+  it "should have the same hash as http://example.com/" do
+    @uri.hash.should == Addressable::URI.parse("http://example.com/").hash
+  end
+
+  it "should have the same hash as http://example.com after assignment" do
+    @uri.path = ""
+    @uri.hash.should == Addressable::URI.parse("http://example.com").hash
+  end
+
+  it "should have the same hash as http://example.com/? after assignment" do
+    @uri.query = ""
+    @uri.hash.should == Addressable::URI.parse("http://example.com/?").hash
+  end
+
+  it "should have the same hash as http://example.com/? after assignment" do
+    @uri.query_values = {}
+    @uri.hash.should == Addressable::URI.parse("http://example.com/?").hash
+  end
+
+  it "should have the same hash as http://example.com/# after assignment" do
+    @uri.fragment = ""
+    @uri.hash.should == Addressable::URI.parse("http://example.com/#").hash
+  end
+
+  it "should have a different hash from http://example.com" do
+    @uri.hash.should_not == Addressable::URI.parse("http://example.com").hash
+  end
+
+  it "should have an origin of 'http://example.com'" do
+    @uri.origin.should == 'http://example.com'
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -1023,6 +1187,10 @@ describe Addressable::URI, "when parsed from " +
   it "should be identical to its duplicate" do
     @uri.should == @uri.dup
   end
+
+  it "should have an origin of 'http://example.com'" do
+    @uri.origin.should == 'http://example.com'
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -1042,6 +1210,10 @@ describe Addressable::URI, "when parsed from " +
   it "should be identical to its duplicate" do
     @uri.should == @uri.dup
   end
+
+  it "should have an origin of 'http://example.com'" do
+    @uri.origin.should == 'http://example.com'
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -1070,6 +1242,10 @@ describe Addressable::URI, "when parsed from " +
   it "should be identical to its duplicate" do
     @uri.should == @uri.dup
   end
+
+  it "should have an origin of 'http://example.com'" do
+    @uri.origin.should == 'http://example.com'
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -1479,6 +1655,10 @@ describe Addressable::URI, "when parsed from " +
   it "should be identical to its duplicate" do
     @uri.should == @uri.dup
   end
+
+  it "should have an origin of 'http://example.com'" do
+    @uri.origin.should == 'http://example.com'
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -1576,6 +1756,10 @@ describe Addressable::URI, "when parsed from " +
   it "should be identical to its duplicate" do
     @uri.should == @uri.dup
   end
+
+  it "should have an origin of 'http://example.com:8080'" do
+    @uri.origin.should == 'http://example.com:8080'
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -1595,6 +1779,48 @@ describe Addressable::URI, "when parsed from " +
   it "should normalize to 'http://example.com/'" do
     @uri.normalize.should === "http://example.com/"
   end
+
+  it "should have an origin of 'http://example.com'" do
+    @uri.origin.should == 'http://example.com'
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/..'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/..")
+  end
+
+  it "should have the correct port" do
+    @uri.inferred_port.should == 80
+  end
+
+  it "should not be considered to be in normal form" do
+    @uri.normalize.should_not be_eql(@uri)
+  end
+
+  it "should normalize to 'http://example.com/'" do
+    @uri.normalize.should === "http://example.com/"
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/../..'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/../..")
+  end
+
+  it "should have the correct port" do
+    @uri.inferred_port.should == 80
+  end
+
+  it "should not be considered to be in normal form" do
+    @uri.normalize.should_not be_eql(@uri)
+  end
+
+  it "should normalize to 'http://example.com/'" do
+    @uri.normalize.should === "http://example.com/"
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -2026,10 +2252,10 @@ describe Addressable::URI, "when parsed from " +
 end
 
 describe Addressable::URI, "when parsed from " +
-    "'ssh+svn://developername@rubyforge.org/var/svn/project'" do
+    "'ssh+svn://developername@RUBYFORGE.ORG/var/svn/project'" do
   before do
     @uri = Addressable::URI.parse(
-      "ssh+svn://developername@rubyforge.org/var/svn/project"
+      "ssh+svn://developername@RUBYFORGE.ORG/var/svn/project"
     )
   end
 
@@ -2041,6 +2267,10 @@ describe Addressable::URI, "when parsed from " +
     @uri.normalized_scheme.should == "svn+ssh"
   end
 
+  it "should have a normalized site of 'svn+ssh'" do
+    @uri.normalized_site.should == "svn+ssh://developername@rubyforge.org"
+  end
+
   it "should not be considered to be ip-based" do
     @uri.should_not be_ip_based
   end
@@ -2116,6 +2346,10 @@ describe Addressable::URI, "when parsed from " +
   it "should be considered to be in normal form" do
     @uri.normalize.should be_eql(@uri)
   end
+
+  it "should have a 'null' origin" do
+    @uri.origin.should == 'null'
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -2157,6 +2391,10 @@ describe Addressable::URI, "when parsed from " +
   it "should be considered to be in normal form" do
     @uri.normalize.should be_eql(@uri)
   end
+
+  it "should have a 'null' origin" do
+    @uri.origin.should == 'null'
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -2268,6 +2506,22 @@ describe Addressable::URI, "when parsed from " +
       "bogus%21://user:pass@example.com/path/to/resource?query=x#fragment"
   end
 
+  it "should have the correct site segment after assignment" do
+    @uri.site = "https://newuser:newpass@example.com:443"
+    @uri.scheme.should == "https"
+    @uri.authority.should == "newuser:newpass@example.com:443"
+    @uri.user.should == "newuser"
+    @uri.password.should == "newpass"
+    @uri.userinfo.should == "newuser:newpass"
+    @uri.normalized_userinfo.should == "newuser:newpass"
+    @uri.host.should == "example.com"
+    @uri.port.should == 443
+    @uri.inferred_port.should == 443
+    @uri.to_s.should ==
+      "https://newuser:newpass@example.com:443" +
+      "/path/to/resource?query=x#fragment"
+  end
+
   it "should have the correct authority segment after assignment" do
     @uri.authority = "newuser:newpass@example.com:80"
     @uri.authority.should == "newuser:newpass@example.com:80"
@@ -2328,6 +2582,20 @@ describe Addressable::URI, "when parsed from " +
       "http://user:pass@example.com/newpath/to/resource?query=x#fragment"
   end
 
+  it "should have the correct scheme and authority after nil assignment" do
+    @uri.site = nil
+    @uri.scheme.should == nil
+    @uri.authority.should == nil
+    @uri.to_s.should == "/path/to/resource?query=x#fragment"
+  end
+
+  it "should have the correct scheme and authority after assignment" do
+    @uri.site = "file://"
+    @uri.scheme.should == "file"
+    @uri.authority.should == ""
+    @uri.to_s.should == "file:///path/to/resource?query=x#fragment"
+  end
+
   it "should have the correct path after nil assignment" do
     @uri.path = nil
     @uri.path.should == ""
@@ -2416,12 +2684,14 @@ describe Addressable::URI, "when parsed from " +
   it "should have the correct values after a merge" do
     @uri.merge(:authority => "foo:bar@baz:42").to_s.should ==
       "http://foo:bar@baz:42/path/to/resource?query=x#fragment"
+    # Ensure the operation was not destructive
     @uri.to_s.should ==
       "http://user:pass@example.com/path/to/resource?query=x#fragment"
   end
 
   it "should have the correct values after a destructive merge" do
     @uri.merge!(:authority => "foo:bar@baz:42")
+    # Ensure the operation was destructive
     @uri.to_s.should ==
       "http://foo:bar@baz:42/path/to/resource?query=x#fragment"
   end
@@ -2432,6 +2702,12 @@ describe Addressable::URI, "when parsed from " +
     end).should raise_error(Addressable::URI::InvalidURIError)
   end
 
+  it "should fail to merge with bogus values" do
+    (lambda do
+      @uri.merge(:authority => "bar@baz:bogus")
+    end).should raise_error(Addressable::URI::InvalidURIError)
+  end
+
   it "should fail to merge with bogus parameters" do
     (lambda do
       @uri.merge(42)
@@ -2459,6 +2735,70 @@ describe Addressable::URI, "when parsed from " +
   it "should be identical to its duplicate" do
     @uri.should == @uri.dup
   end
+
+  it "should have an origin of 'http://example.com'" do
+    @uri.origin.should == 'http://example.com'
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/?q&&x=b'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/?q&&x=b")
+  end
+
+  it "should have a query of 'q&&x=b'" do
+    @uri.query.should == "q&&x=b"
+  end
+
+  it "should have query_values of {'q' => true, 'x' => 'b'}" do
+    @uri.query_values.should == {'q' => true, 'x' => 'b'}
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/?q=a+b'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/?q=a+b")
+  end
+
+  it "should have a query of 'q=a+b'" do
+    @uri.query.should == "q=a+b"
+  end
+
+  it "should have query_values of {'q' => 'a b'}" do
+    @uri.query_values.should == {'q' => 'a b'}
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/?q=a%2bb'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/?q=a%2bb")
+  end
+
+  it "should have a query of 'q=a+b'" do
+    @uri.query.should == "q=a%2bb"
+  end
+
+  it "should have query_values of {'q' => 'a+b'}" do
+    @uri.query_values.should == {'q' => 'a+b'}
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/?q='" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/?q=")
+  end
+
+  it "should have a query of 'q='" do
+    @uri.query.should == "q="
+  end
+
+  it "should have query_values of {'q' => ''}" do
+    @uri.query_values.should == {'q' => ''}
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -2734,6 +3074,14 @@ describe Addressable::URI, "when parsed from " +
     @uri.host.should == nil
   end
 
+  it "should have a site of nil" do
+    @uri.site.should == nil
+  end
+
+  it "should have a normalized_site of nil" do
+    @uri.normalized_site.should == nil
+  end
+
   it "should have a path of ''" do
     @uri.path.should == ""
   end
@@ -2773,6 +3121,10 @@ describe Addressable::URI, "when parsed from " +
       @uri.route_from("http://example.com/")
     end).should raise_error(ArgumentError, /\/\/example.com\//)
   end
+
+  it "should have a 'null' origin" do
+    @uri.origin.should == 'null'
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -2804,6 +3156,10 @@ describe Addressable::URI, "when parsed from " +
     @uri.normalize.to_s.should == "http://example.com/"
     @uri.normalize!.to_s.should == "http://example.com/"
   end
+
+  it "should have a 'null' origin" do
+    @uri.origin.should == 'null'
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -2817,6 +3173,10 @@ describe Addressable::URI, "when parsed from " +
     @uri.should ==
       Addressable::URI.parse("eXAMPLE://a/./b/../b/%63/%7bfoo%7d")
   end
+
+  it "should have an origin of 'example://a'" do
+    @uri.origin.should == 'example://a'
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -2871,6 +3231,10 @@ describe Addressable::URI, "when parsed from " +
   it "should have no scheme" do
     @uri.scheme.should == nil
   end
+
+  it "should have a 'null' origin" do
+    @uri.origin.should == 'null'
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -2886,6 +3250,10 @@ describe Addressable::URI, "when parsed from " +
   it "should have a scheme of 'this'" do
     @uri.scheme.should == "this"
   end
+
+  it "should have a 'null' origin" do
+    @uri.origin.should == 'null'
+  end
 end
 
 describe Addressable::URI, "when parsed from '?'" do
@@ -2905,6 +3273,10 @@ describe Addressable::URI, "when parsed from '?'" do
   it "should have the correct flat notation query values" do
     @uri.query_values(:notation => :flat).should == {}
   end
+
+  it "should have a 'null' origin" do
+    @uri.origin.should == 'null'
+  end
 end
 
 describe Addressable::URI, "when parsed from '?one=1&two=2&three=3'" do
@@ -2921,6 +3293,32 @@ describe Addressable::URI, "when parsed from '?one=1&two=2&three=3'" do
       @uri.query_values(:notation => :bogus)
     end).should raise_error(ArgumentError)
   end
+
+  it "should have the correct flat array notation query values" do
+    @uri.query_values(:notation => :flat_array).should == [
+      ["one", "1"], ["two", "2"], ["three", "3"]
+    ]
+  end
+
+  it "should have a 'null' origin" do
+    @uri.origin.should == 'null'
+  end
+end
+
+describe Addressable::URI, "when parsed from '?one=1=uno&two=2=dos'" do
+  before do
+    @uri = Addressable::URI.parse("?one=1=uno&two=2=dos")
+  end
+
+  it "should have the correct query values" do
+    @uri.query_values.should == {"one" => "1=uno", "two" => "2=dos"}
+  end
+
+  it "should have the correct flat array notation query values" do
+    @uri.query_values(:notation => :flat_array).should == [
+      ["one", "1=uno"], ["two", "2=dos"]
+    ]
+  end
 end
 
 describe Addressable::URI, "when parsed from '?one[two][three]=four'" do
@@ -2937,6 +3335,12 @@ describe Addressable::URI, "when parsed from '?one[two][three]=four'" do
       "one[two][three]" => "four"
     }
   end
+
+  it "should have the correct flat array notation query values" do
+    @uri.query_values(:notation => :flat_array).should == [
+      ["one[two][three]", "four"]
+    ]
+  end
 end
 
 describe Addressable::URI, "when parsed from '?one.two.three=four'" do
@@ -2955,6 +3359,12 @@ describe Addressable::URI, "when parsed from '?one.two.three=four'" do
       "one.two.three" => "four"
     }
   end
+
+  it "should have the correct flat array notation query values" do
+    @uri.query_values(:notation => :flat_array).should == [
+      ["one.two.three", "four"]
+    ]
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -2975,6 +3385,12 @@ describe Addressable::URI, "when parsed from " +
       "one[two][five]" => "six"
     }
   end
+
+  it "should have the correct flat array notation query values" do
+    @uri.query_values(:notation => :flat_array).should == [
+      ["one[two][three]", "four"], ["one[two][five]", "six"]
+    ]
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -2995,6 +3411,26 @@ describe Addressable::URI, "when parsed from " +
       "one.two.five" => "six"
     }
   end
+
+  it "should have the correct flat array notation query values" do
+    @uri.query_values(:notation => :flat_array).should == [
+      ["one.two.three", "four"], ["one.two.five", "six"]
+    ]
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'?one=two&one=three'" do
+  before do
+    @uri = Addressable::URI.parse(
+      "?one=two&one=three"
+    )
+  end
+
+  it "should have correct flat_array notation query values" do
+    @uri.query_values(:notation => :flat_array).should ==
+      [['one', 'two'], ['one', 'three']]
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -3016,6 +3452,13 @@ describe Addressable::URI, "when parsed from " +
       @uri.query_values(:notation => :flat)
     end).should raise_error(ArgumentError)
   end
+
+  it "should not raise an error if a key is " +
+      "repeated in the flat array notation" do
+    (lambda do
+      @uri.query_values(:notation => :flat_array)
+    end).should_not raise_error
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -3033,6 +3476,36 @@ describe Addressable::URI, "when parsed from " +
   end
 end
 
+describe Addressable::URI, "when parsed from " +
+    "'?one[two][three][1]=four&one[two][three][0]=five'" do
+  before do
+    @uri = Addressable::URI.parse(
+      "?one[two][three][1]=four&one[two][three][0]=five"
+    )
+  end
+
+  it "should have the correct subscript notation query values" do
+    @uri.query_values(:notation => :subscript).should == {
+      "one" => {"two" => {"three" => ["five", "four"]}}
+    }
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'?one[two][three][2]=four&one[two][three][1]=five'" do
+  before do
+    @uri = Addressable::URI.parse(
+      "?one[two][three][2]=four&one[two][three][1]=five"
+    )
+  end
+
+  it "should have the correct subscript notation query values" do
+    @uri.query_values(:notation => :subscript).should == {
+      "one" => {"two" => {"three" => ["five", "four"]}}
+    }
+  end
+end
+
 describe Addressable::URI, "when parsed from " +
     "'http://www.詹姆斯.com/'" do
   before do
@@ -3048,6 +3521,10 @@ describe Addressable::URI, "when parsed from " +
     Addressable::URI.normalized_encode(@uri.to_s).should ==
       "http://www.詹姆斯.com/"
   end
+
+  it "should have an origin of 'http://www.xn--8ws00zhy3a.com'" do
+    @uri.origin.should == 'http://www.xn--8ws00zhy3a.com'
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -3067,6 +3544,10 @@ describe Addressable::URI, "when parsed from " +
     Addressable::URI.normalized_encode(@uri.to_s).should ==
       "http://www.詹姆斯.com/%20some%20spaces%20/"
   end
+
+  it "should have an origin of 'http://www.xn--8ws00zhy3a.com'" do
+    @uri.origin.should == 'http://www.xn--8ws00zhy3a.com'
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -3086,6 +3567,10 @@ describe Addressable::URI, "when parsed from " +
       display_string.encoding.to_s.should == Encoding::UTF_8.to_s
     end
   end
+
+  it "should have an origin of 'http://www.xn--8ws00zhy3a.com'" do
+    @uri.origin.should == 'http://www.xn--8ws00zhy3a.com'
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -3123,6 +3608,13 @@ describe Addressable::URI, "when parsed from a percent-encoded IRI" do
       "http://www.xn--n8jaaaaai5bhf7as8fsfk3jnknefdde3f" +
       "g11amb5gzdb4wi9bya3kc6lra.w3.mag.keio.ac.jp/"
   end
+
+  it "should have the correct origin" do
+    @uri.origin.should == (
+      "http://www.xn--n8jaaaaai5bhf7as8fsfk3jnknefdde3f" +
+      "g11amb5gzdb4wi9bya3kc6lra.w3.mag.keio.ac.jp"
+    )
+  end
 end
 
 describe Addressable::URI, "with a base uri of 'http://a/b/c/d;p?q'" do
@@ -3455,6 +3947,11 @@ describe Addressable::URI, "when given a UNIX root directory" do
     @uri = Addressable::URI.convert_path(@path)
     @uri.to_str.should == "file:///"
   end
+
+  it "should have an origin of 'file://'" do
+    @uri = Addressable::URI.convert_path(@path)
+    @uri.origin.should == 'file://'
+  end
 end
 
 describe Addressable::URI, "when given a Windows root directory" do
@@ -3466,6 +3963,11 @@ describe Addressable::URI, "when given a Windows root directory" do
     @uri = Addressable::URI.convert_path(@path)
     @uri.to_str.should == "file:///c:/"
   end
+
+  it "should have an origin of 'file://'" do
+    @uri = Addressable::URI.convert_path(@path)
+    @uri.origin.should == 'file://'
+  end
 end
 
 describe Addressable::URI, "when given the path '/home/user/'" do
@@ -3478,6 +3980,11 @@ describe Addressable::URI, "when given the path '/home/user/'" do
     @uri = Addressable::URI.convert_path(@path)
     @uri.to_str.should == "file:///home/user/"
   end
+
+  it "should have an origin of 'file://'" do
+    @uri = Addressable::URI.convert_path(@path)
+    @uri.origin.should == 'file://'
+  end
 end
 
 describe Addressable::URI, "when given the path " +
@@ -3491,6 +3998,11 @@ describe Addressable::URI, "when given the path " +
     @uri = Addressable::URI.convert_path(@path)
     @uri.to_str.should == "file:///c:/windows/My%20Documents%20100%20/foo.txt"
   end
+
+  it "should have an origin of 'file://'" do
+    @uri = Addressable::URI.convert_path(@path)
+    @uri.origin.should == 'file://'
+  end
 end
 
 describe Addressable::URI, "when given the path " +
@@ -3504,6 +4016,11 @@ describe Addressable::URI, "when given the path " +
     @uri = Addressable::URI.convert_path(@path)
     @uri.to_str.should == "file:///c:/windows/My%20Documents%20100%20/foo.txt"
   end
+
+  it "should have an origin of 'file://'" do
+    @uri = Addressable::URI.convert_path(@path)
+    @uri.origin.should == 'file://'
+  end
 end
 
 describe Addressable::URI, "when given the path " +
@@ -3517,6 +4034,11 @@ describe Addressable::URI, "when given the path " +
     @uri = Addressable::URI.convert_path(@path)
     @uri.to_str.should == "file:///c:/windows/My%20Documents%20100%20/foo.txt"
   end
+
+  it "should have an origin of 'file://'" do
+    @uri = Addressable::URI.convert_path(@path)
+    @uri.origin.should == 'file://'
+  end
 end
 
 describe Addressable::URI, "when given the path " +
@@ -3530,6 +4052,11 @@ describe Addressable::URI, "when given the path " +
     @uri = Addressable::URI.convert_path(@path)
     @uri.to_str.should == "file:///c:/windows/My%20Documents%20100%20/foo.txt"
   end
+
+  it "should have an origin of 'file://'" do
+    @uri = Addressable::URI.convert_path(@path)
+    @uri.origin.should == 'file://'
+  end
 end
 
 describe Addressable::URI, "when given the path " +
@@ -3543,6 +4070,11 @@ describe Addressable::URI, "when given the path " +
     @uri = Addressable::URI.convert_path(@path)
     @uri.to_str.should == "file:///c:/windows/My%20Documents%20100%20/foo.txt"
   end
+
+  it "should have an origin of 'file://'" do
+    @uri = Addressable::URI.convert_path(@path)
+    @uri.origin.should == 'file://'
+  end
 end
 
 describe Addressable::URI, "when given an http protocol URI" do
@@ -3588,6 +4120,95 @@ describe Addressable::URI, "when parsing a non-String object" do
   end
 end
 
+describe Addressable::URI, "when form encoding a hash" do
+  it "should result in correct percent encoded sequence" do
+    Addressable::URI.form_encode(
+      {"&one" => "/1", "=two" => "?2", ":three" => "#3"}
+    ).should == "%26one=%2F1&%3Dtwo=%3F2&%3Athree=%233"
+  end
+
+  it "should result in correct percent encoded sequence" do
+    Addressable::URI.form_encode(
+      {"q" => "one two three"}
+    ).should == "q=one+two+three"
+  end
+
+  it "should result in correct percent encoded sequence" do
+    Addressable::URI.form_encode(
+      {"key" => nil}
+    ).should == "key="
+  end
+
+  it "should result in correctly encoded newlines" do
+    Addressable::URI.form_encode(
+      {"text" => "one\ntwo\rthree\r\nfour\n\r"}
+    ).should == "text=one%0D%0Atwo%0D%0Athree%0D%0Afour%0D%0A%0D%0A"
+  end
+
+  it "should result in a sorted percent encoded sequence" do
+    Addressable::URI.form_encode(
+      [["a", "1"], ["dup", "3"], ["dup", "2"]], true
+    ).should == "a=1&dup=2&dup=3"
+  end
+end
+
+describe Addressable::URI, "when form encoding a non-Array object" do
+  it "should raise a TypeError for objects than cannot be converted" do
+    (lambda do
+      Addressable::URI.form_encode(42)
+    end).should raise_error(TypeError, "Can't convert Fixnum into Array.")
+  end
+end
+
+describe Addressable::URI, "when form unencoding a string" do
+  it "should result in correct values" do
+    Addressable::URI.form_unencode(
+      "%26one=%2F1&%3Dtwo=%3F2&%3Athree=%233"
+    ).should == [["&one", "/1"], ["=two", "?2"], [":three", "#3"]]
+  end
+
+  it "should result in correct values" do
+    Addressable::URI.form_unencode(
+      "q=one+two+three"
+    ).should == [["q", "one two three"]]
+  end
+
+  it "should result in correct values" do
+    Addressable::URI.form_unencode(
+      "text=one%0D%0Atwo%0D%0Athree%0D%0Afour%0D%0A%0D%0A"
+    ).should == [["text", "one\ntwo\nthree\nfour\n\n"]]
+  end
+
+  it "should result in correct values" do
+    Addressable::URI.form_unencode(
+      "a=1&dup=2&dup=3"
+    ).should == [["a", "1"], ["dup", "2"], ["dup", "3"]]
+  end
+
+  it "should result in correct values" do
+    Addressable::URI.form_unencode(
+      "key"
+    ).should == [["key", nil]]
+  end
+
+  it "should result in correct values" do
+    Addressable::URI.form_unencode("GivenName=Ren%C3%A9").should ==
+      [["GivenName", "René"]]
+  end
+end
+
+describe Addressable::URI, "when form unencoding a non-String object" do
+  it "should correctly parse anything with a 'to_str' method" do
+    Addressable::URI.form_unencode(SuperString.new(42))
+  end
+
+  it "should raise a TypeError for objects than cannot be converted" do
+    (lambda do
+      Addressable::URI.form_unencode(42)
+    end).should raise_error(TypeError, "Can't convert Fixnum into String.")
+  end
+end
+
 describe Addressable::URI, "when normalizing a non-String object" do
   it "should correctly parse anything with a 'to_str' method" do
     Addressable::URI.normalize_component(SuperString.new(42))
@@ -3665,6 +4286,13 @@ describe Addressable::URI, "when encoding a multibyte string" do
   end
 end
 
+describe Addressable::URI, "when form encoding a multibyte string" do
+  it "should result in correct percent encoded sequence" do
+    Addressable::URI.form_encode({"GivenName" => "René"}).should ==
+      "GivenName=Ren%C3%A9"
+  end
+end
+
 describe Addressable::URI, "when encoding a string with ASCII chars 0-15" do
   it "should result in correct percent encoded sequence" do
     Addressable::URI.encode_component("one\ntwo").should == "one%0Atwo"
@@ -3937,4 +4565,81 @@ describe Addressable::URI, "when assigning query values" do
     }
     @uri.query.should == "a=a&b[c]&b[d]=d"
   end
+
+  it "should correctly assign {}" do
+    @uri.query_values = {}
+    @uri.query.should == ''
+  end
+
+  it "should correctly assign nil" do
+    @uri.query_values = nil
+    @uri.query.should == nil
+  end
+
+  it "should correctly sort {'ab' => 'c', :ab => 'a', :a => 'x'}" do
+    @uri.query_values = {'ab' => 'c', :ab => 'a', :a => 'x'}
+    @uri.query.should == "a=x&ab=a&ab=c"
+  end
+
+  it "should correctly assign " +
+      "[['b', 'c'], ['b', 'a'], ['a', 'a']]" do
+    # Order can be guaranteed in this format, so preserve it.
+    @uri.query_values = [['b', 'c'], ['b', 'a'], ['a', 'a']]
+    @uri.query.should == "b=c&b=a&a=a"
+  end
+
+  it "should preserve query string order" do
+    query_string = (('a'..'z').to_a.shuffle.map { |e| "#{e}=#{e}" }).join("&")
+    @uri.query = query_string
+    original_uri = @uri.to_s
+    @uri.query_values = @uri.query_values(:notation => :flat_array)
+    @uri.to_s.should == original_uri
+  end
+end
+
+describe Addressable::URI, "when assigning path values" do
+  before do
+    @uri = Addressable::URI.new
+  end
+
+  it "should correctly assign paths containing colons" do
+    @uri.path = "acct:bob@sporkmonger.com"
+    Addressable::URI.parse(@uri.normalize.to_str).path.should == @uri.path
+    @uri.normalize.to_str.should == "acct%2Fbob@sporkmonger.com"
+  end
+
+  it "should correctly assign paths containing colons" do
+    @uri.path = "/acct:bob@sporkmonger.com"
+    @uri.authority = "example.com"
+    @uri.normalize.to_str.should == "//example.com/acct:bob@sporkmonger.com"
+  end
+
+  it "should correctly assign paths containing colons" do
+    @uri.path = "acct:bob@sporkmonger.com"
+    @uri.scheme = "something"
+    @uri.normalize.to_str.should == "something:acct:bob@sporkmonger.com"
+  end
+
+  it "should not allow relative paths to be assigned on absolute URIs" do
+    (lambda do
+      @uri.scheme = "http"
+      @uri.host = "example.com"
+      @uri.path = "acct:bob@sporkmonger.com"
+    end).should raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should not allow relative paths to be assigned on absolute URIs" do
+    (lambda do
+      @uri.path = "acct:bob@sporkmonger.com"
+      @uri.scheme = "http"
+      @uri.host = "example.com"
+    end).should raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should not allow relative paths to be assigned on absolute URIs" do
+    (lambda do
+      @uri.path = "uuid:0b3ecf60-3f93-11df-a9c3-001f5bfffe12"
+      @uri.scheme = "urn"
+    end).should_not raise_error(Addressable::URI::InvalidURIError)
+  end
 end