addressable 0.1.2 → 1.0.0

data/lib/addressable/version.rb

@@ -23,9 +23,9 @@
 
 module Addressable
   module ADDRESSABLE_VERSION #:nodoc:
-    MAJOR = 0
-    MINOR = 1
-    TINY  = 2
+    MAJOR = 1
+    MINOR = 0
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/rakefile

@@ -148,22 +148,13 @@ namespace :spec do
     t.spec_opts = ['--color']
   end
 
-  namespace :heckle do
-    desc "Heckle the URI class"
-    Spec::Rake::SpecTask.new(:uri) do |t|
-      t.spec_files = FileList['spec/addressable/uri_spec.rb']
-      t.spec_opts = ['--heckle', 'Addressable::URI']
-    end
+  desc "Heckle the URI class"
+  Spec::Rake::SpecTask.new(:heckle) do |t|
+    heckle_param = 'Addressable::URI'
+    heckle_param = ENV['TARGET'] if ENV['TARGET']
+    t.spec_files = FileList['spec/addressable/uri_spec.rb']
+    t.spec_opts = ['--heckle', heckle_param]
   end
-  
-  # desc "Start up autotest for RSpec"
-  # task :autospec do
-  #   require 'autotest'
-  #   require 'autotest/growl'
-  #   require 'autotest/redgreen'
-  #   require 'vendor/autospec/lib/autospec'
-  #   Autospec.run
-  # end
 
   desc "Print Specdoc for all specs"
   Spec::Rake::SpecTask.new(:doc) do |t|

data/spec/addressable/uri_spec.rb

@@ -48,14 +48,6 @@ class ExampleProcessor
   end
 end
 
-describe Addressable::URI, "when created from nil components" do
-  it "should raise an error" do
-    (lambda do
-      Addressable::URI.new(nil, nil, nil, nil, nil, nil, nil, nil)
-    end).should raise_error(Addressable::URI::InvalidURIError)
-  end
-end
-
 describe Addressable::URI, "when created with a non-numeric port number" do
   it "should raise an error" do
     (lambda do
@@ -73,6 +65,20 @@ describe Addressable::URI, "when created with a scheme but no hierarchical " +
   end
 end
 
+describe Addressable::URI, "when created from nil components" do
+  before do
+    @uri = Addressable::URI.new(nil, nil, nil, nil, nil, nil, nil, nil)
+  end
+  
+  it "should have an empty path" do
+    @uri.path.should == ""
+  end
+
+  it "should be an empty uri" do
+    @uri.to_s.should == ""
+  end
+end
+
 describe Addressable::URI, "when created from string components" do
   before do
     @uri = Addressable::URI.new(
@@ -84,6 +90,15 @@ describe Addressable::URI, "when created from string components" do
   end
 end
 
+describe Addressable::URI, "when created with a nil host but " +
+    "non-nil authority components" do
+  it "should raise an error" do
+    (lambda do
+      Addressable::URI.new(nil, "user", "pass", nil, 80, nil, nil, nil)
+    end).should raise_error(Addressable::URI::InvalidURIError)
+  end
+end
+
 # Section 1.1.2 of RFC 3986
 describe Addressable::URI, " when parsed from " +
     "'ftp://ftp.is.co.za/rfc/rfc1808.txt'" do
@@ -312,6 +327,14 @@ describe Addressable::URI, " when parsed from " +
     @uri.inspect.should include("http://example.com")
   end
 
+  it "when inspected, should have the correct class name" do
+    @uri.inspect.should include("Addressable::URI")
+  end
+
+  it "when inspected, should have the correct object id" do
+    @uri.inspect.should include("%#0x" % @uri.object_id)
+  end
+
   it "should use the 'http' scheme" do
     @uri.scheme.should == "http"
   end
@@ -503,7 +526,7 @@ describe Addressable::URI, " when parsed from " +
   end
   
   it "should correctly convert to a hash" do
-    @uri.to_h.should == {
+    @uri.to_hash.should == {
       :scheme => "http",
       :user => nil,
       :password => nil,
@@ -514,6 +537,10 @@ describe Addressable::URI, " when parsed from " +
       :fragment => nil
     }
   end
+
+  it "should be identical to its duplicate" do
+    @uri.should == @uri.dup
+  end
 end
 
 describe Addressable::URI, " when parsed from " +
@@ -562,7 +589,7 @@ describe Addressable::URI, " when parsed from " +
   end
   
   it "should correctly convert to a hash" do
-    @uri.to_h.should == {
+    @uri.to_hash.should == {
       :scheme => "http",
       :user => nil,
       :password => nil,
@@ -573,6 +600,10 @@ describe Addressable::URI, " when parsed from " +
       :fragment => nil
     }
   end
+
+  it "should be identical to its duplicate" do
+    @uri.should == @uri.dup
+  end
 end
 
 describe Addressable::URI, " when parsed from " +
@@ -586,7 +617,7 @@ describe Addressable::URI, " when parsed from " +
   end
   
   it "should correctly convert to a hash" do
-    @uri.to_h.should == {
+    @uri.to_hash.should == {
       :scheme => "http",
       :user => "",
       :password => nil,
@@ -597,6 +628,10 @@ describe Addressable::URI, " when parsed from " +
       :fragment => nil
     }
   end
+
+  it "should be identical to its duplicate" do
+    @uri.should == @uri.dup
+  end
 end
 
 describe Addressable::URI, " when parsed from " +
@@ -612,6 +647,10 @@ describe Addressable::URI, " when parsed from " +
   it "should not be considered to be in normal form" do
     @uri.normalize.should_not be_eql(@uri)
   end
+
+  it "should be identical to its duplicate" do
+    @uri.should == @uri.dup
+  end
 end
 
 describe Addressable::URI, " when parsed from " +
@@ -625,7 +664,7 @@ describe Addressable::URI, " when parsed from " +
   end
   
   it "should correctly convert to a hash" do
-    @uri.to_h.should == {
+    @uri.to_hash.should == {
       :scheme => "http",
       :user => "",
       :password => "",
@@ -636,6 +675,10 @@ describe Addressable::URI, " when parsed from " +
       :fragment => nil
     }
   end
+
+  it "should be identical to its duplicate" do
+    @uri.should == @uri.dup
+  end
 end
 
 describe Addressable::URI, " when parsed from " +
@@ -653,6 +696,10 @@ describe Addressable::URI, " when parsed from " +
   it "should be equivalent to http://example.com/%7esmith/" do
     @uri.should == Addressable::URI.parse("http://example.com/%7esmith/")
   end
+
+  it "should be identical to its duplicate" do
+    @uri.should == @uri.dup
+  end
 end
 
 describe Addressable::URI, " when parsed from " +
@@ -675,6 +722,10 @@ describe Addressable::URI, " when parsed from " +
     Addressable::URI.encode(@uri).to_s.should ==
       "http://example.com/%25C3%2587"
   end
+
+  it "should be identical to its duplicate" do
+    @uri.should == @uri.dup
+  end
 end
 
 describe Addressable::URI, " when parsed from " +
@@ -730,6 +781,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 be identical to its duplicate" do
+    @uri.should == @uri.dup
+  end
 end
 
 describe Addressable::URI, " when parsed from " +
@@ -801,9 +856,9 @@ describe Addressable::URI, " when parsed from " +
     end).should_not raise_error
   end
 
-  it "should result in itself when merged with itself" do
-    @uri.merge(@uri).to_s.should == "http://example.com:80/"
-    @uri.merge!(@uri).to_s.should == "http://example.com:80/"
+  it "should result in itself when joined with itself" do
+    @uri.join(@uri).to_s.should == "http://example.com:80/"
+    @uri.join!(@uri).to_s.should == "http://example.com:80/"
   end
 
   # Section 6.2.3 of RFC 3986
@@ -825,6 +880,223 @@ describe Addressable::URI, " when parsed from " +
   it "should be equal to http://EXAMPLE.COM/" do
     @uri.should == Addressable::URI.parse("http://EXAMPLE.COM/")
   end
+  
+  it "should correctly convert to a hash" do
+    @uri.to_hash.should == {
+      :scheme => "http",
+      :user => nil,
+      :password => nil,
+      :host => "example.com",
+      :port => 80,
+      :path => "/",
+      :query => nil,
+      :fragment => nil
+    }
+  end
+
+  it "should be identical to its duplicate" do
+    @uri.should == @uri.dup
+  end
+end
+
+describe Addressable::URI, " when parsed from " +
+    "'http://example.com:8080/'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com:8080/")
+  end
+
+  it "should use the 'http' scheme" do
+    @uri.scheme.should == "http"
+  end
+
+  it "should have an authority segment of 'example.com:8080'" do
+    @uri.authority.should == "example.com:8080"
+  end
+
+  it "should have a host of 'example.com'" do
+    @uri.host.should == "example.com"
+  end
+
+  it "should have no username" do
+    @uri.user.should == nil
+  end
+
+  it "should have no password" do
+    @uri.password.should == nil
+  end
+  
+  it "should use port 8080" do
+    @uri.port.should == 8080
+  end
+
+  it "should have a path of '/'" do
+    @uri.path.should == "/"
+  end
+
+  it "should have no query string" do
+    @uri.query.should == nil
+  end
+
+  it "should have no fragment" do
+    @uri.fragment.should == nil
+  end
+
+  it "should be considered absolute" do
+    @uri.should be_absolute
+  end
+
+  it "should not be considered relative" do
+    @uri.should_not be_relative
+  end
+
+  it "should be exactly equal to http://example.com:8080/" do
+    @uri.eql?(Addressable::URI.parse(
+      "http://example.com:8080/")).should == true
+  end
+  
+  it "should have a route of 'http://example.com:8080/' from " +
+      "'http://example.com/path/to/'" do
+    @uri.route_from("http://example.com/path/to/").should ==
+      Addressable::URI.parse("http://example.com:8080/")
+  end
+  
+  it "should have a route of 'http://example.com:8080/' from " +
+      "'http://example.com:80/path/to/'" do
+    @uri.route_from("http://example.com:80/path/to/").should ==
+      Addressable::URI.parse("http://example.com:8080/")
+  end
+  
+  it "should have a route of '/' from " +
+      "'http://example.com:8080/path/to/'" do
+    @uri.route_from("http://example.com:8080/path/to/").should ==
+      Addressable::URI.parse("/")
+  end
+  
+  it "should have a route of 'http://example.com:8080/' from " +
+      "'http://user:pass@example.com/path/to/'" do
+    @uri.route_from("http://user:pass@example.com/path/to/").should ==
+      Addressable::URI.parse("http://example.com:8080/")
+  end
+
+  it "should correctly convert to a hash" do
+    @uri.to_hash.should == {
+      :scheme => "http",
+      :user => nil,
+      :password => nil,
+      :host => "example.com",
+      :port => 8080,
+      :path => "/",
+      :query => nil,
+      :fragment => nil
+    }
+  end
+
+  it "should be identical to its duplicate" do
+    @uri.should == @uri.dup
+  end
+end
+
+describe Addressable::URI, " when parsed from " +
+    "'http://example.com/path/to/resource/'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/path/to/resource/")
+  end
+
+  it "should use the 'http' scheme" do
+    @uri.scheme.should == "http"
+  end
+
+  it "should have an authority segment of 'example.com'" do
+    @uri.authority.should == "example.com"
+  end
+
+  it "should have a host of 'example.com'" do
+    @uri.host.should == "example.com"
+  end
+
+  it "should have no username" do
+    @uri.user.should == nil
+  end
+
+  it "should have no password" do
+    @uri.password.should == nil
+  end
+  
+  it "should use port 80" do
+    @uri.port.should == 80
+  end
+
+  it "should have a path of '/path/to/resource/'" do
+    @uri.path.should == "/path/to/resource/"
+  end
+
+  it "should have no query string" do
+    @uri.query.should == nil
+  end
+
+  it "should have no fragment" do
+    @uri.fragment.should == nil
+  end
+
+  it "should be considered absolute" do
+    @uri.should be_absolute
+  end
+
+  it "should not be considered relative" do
+    @uri.should_not be_relative
+  end
+
+  it "should be exactly equal to http://example.com:8080/" do
+    @uri.eql?(Addressable::URI.parse(
+      "http://example.com/path/to/resource/")).should == true
+  end
+  
+  it "should have a route of 'resource/' from " +
+      "'http://example.com/path/to/'" do
+    @uri.route_from("http://example.com/path/to/").should ==
+      Addressable::URI.parse("resource/")
+  end
+  
+  it "should have a route of 'resource/' from " +
+      "'http://example.com:80/path/to/'" do
+    @uri.route_from("http://example.com:80/path/to/").should ==
+      Addressable::URI.parse("resource/")
+  end
+  
+  it "should have a route of 'http://example.com/path/to/' from " +
+      "'http://example.com:8080/path/to/'" do
+    @uri.route_from("http://example.com:8080/path/to/").should ==
+      Addressable::URI.parse("http://example.com/path/to/resource/")
+  end
+  
+  it "should have a route of 'http://example.com/path/to/' from " +
+      "'http://user:pass@example.com/path/to/'" do
+    @uri.route_from("http://user:pass@example.com/path/to/").should ==
+      Addressable::URI.parse("http://example.com/path/to/resource/")
+  end
+  
+  it "should have a route of '/path/to/resource/' from " +
+      "'http://example.com/to/resource/'" do
+    @uri.route_from("http://example.com/to/resource/").should ==
+      Addressable::URI.parse("/path/to/resource/")
+  end
+
+  it "should correctly convert to a hash" do
+    @uri.to_hash.should == {
+      :scheme => "http",
+      :user => nil,
+      :password => nil,
+      :host => "example.com",
+      :port => nil,
+      :path => "/path/to/resource/",
+      :query => nil,
+      :fragment => nil
+    }
+  end
+
+  it "should be identical to its duplicate" do
+    @uri.should == @uri.dup
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -884,10 +1156,10 @@ describe Addressable::URI, "when parsed from " +
   it "should raise an error if routing is attempted" do
     (lambda do
       @uri.route_to("http://example.com/")
-    end).should raise_error
+    end).should raise_error(ArgumentError, /relative\/path\/to\/resource/)
     (lambda do
       @uri.route_from("http://example.com/")
-    end).should raise_error
+    end).should raise_error(ArgumentError, /relative\/path\/to\/resource/)
   end
   
   it "when joined with 'another/relative/path' should be " +
@@ -895,6 +1167,10 @@ describe Addressable::URI, "when parsed from " +
     @uri.join('another/relative/path').should ==
       Addressable::URI.parse("relative/path/to/another/relative/path")    
   end
+
+  it "should be identical to its duplicate" do
+    @uri.should == @uri.dup
+  end
 end
 
 describe Addressable::URI, "when parsed from " +
@@ -992,6 +1268,61 @@ describe Addressable::URI, " when parsed from " +
     @uri.path.should == "/file.txt"
   end
 
+  it "should have a basename of 'file.txt'" do
+    @uri.basename.should == "file.txt"
+  end
+
+  it "should have an extname of '.txt'" do
+    @uri.extname.should == ".txt"
+  end
+
+  it "should have no query string" do
+    @uri.query.should == nil
+  end
+
+  it "should have no fragment" do
+    @uri.fragment.should == nil
+  end
+end
+
+describe Addressable::URI, " when parsed from " +
+    "'http://example.com/file.txt;parameter'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/file.txt;parameter")
+  end
+
+  it "should have a scheme of 'http'" do
+    @uri.scheme.should == "http"
+  end
+  
+  it "should have an authority segment of 'example.com'" do
+    @uri.authority.should == "example.com"
+  end
+
+  it "should have a host of 'example.com'" do
+    @uri.host.should == "example.com"
+  end
+
+  it "should have no username" do
+    @uri.user.should == nil
+  end
+
+  it "should have no password" do
+    @uri.password.should == nil
+  end
+  
+  it "should use port 80" do
+    @uri.port.should == 80
+  end
+
+  it "should have a path of '/file.txt;parameter'" do
+    @uri.path.should == "/file.txt;parameter"
+  end
+
+  it "should have a basename of 'file.txt'" do
+    @uri.basename.should == "file.txt"
+  end
+
   it "should have an extname of '.txt'" do
     @uri.extname.should == ".txt"
   end
@@ -1213,7 +1544,7 @@ describe Addressable::URI, " when parsed from " +
   it "should have a route of '/path/to/resource?query=x#fragment' " +
       "from 'http://user:pass@example.com/path/'" do
     @uri.route_from("http://user:pass@example.com/path/").should ==
-      Addressable::URI.parse("/path/to/resource?query=x#fragment")
+      Addressable::URI.parse("to/resource?query=x#fragment")
   end
   
   it "should have a route of '?query=x#fragment' " +
@@ -1242,6 +1573,14 @@ describe Addressable::URI, " when parsed from " +
       Addressable::URI.parse("http://elsewhere.com/")
   end
 
+  it "should have a route of " +
+      "'http://user:pass@example.com/path/to/resource?query=x#fragment' " +
+      "from 'http://example.com/path/to/'" do
+    @uri.route_from("http://elsewhere.com/path/to/").should ==
+      Addressable::URI.parse(
+        "http://user:pass@example.com/path/to/resource?query=x#fragment")
+  end
+
   it "should have the correct scheme after assignment" do
     @uri.scheme = "ftp"
     @uri.scheme.should == "ftp"
@@ -1307,6 +1646,13 @@ describe Addressable::URI, " when parsed from " +
       "http://user:pass@example.com/newpath/to/resource?query=x#fragment"
   end
 
+  it "should have the correct path after nil assignment" do
+    @uri.path = nil
+    @uri.path.should == ""
+    @uri.to_s.should ==
+      "http://user:pass@example.com?query=x#fragment"
+  end
+
   it "should have the correct query string after assignment" do
     @uri.query = "newquery=x"
     @uri.query.should == "newquery=x"
@@ -1320,6 +1666,10 @@ describe Addressable::URI, " when parsed from " +
     @uri.to_s.should ==
       "http://user:pass@example.com/path/to/resource?query=x#newfragment"
   end
+
+  it "should be identical to its duplicate" do
+    @uri.should == @uri.dup
+  end
 end
 
 describe Addressable::URI, " when parsed from " +
@@ -1605,6 +1955,15 @@ describe Addressable::URI, " when parsed from " +
   it "should have a path of '/'" do
     @uri.path.should == "/"
   end
+  
+  it "should raise an error if routing is attempted" do
+    (lambda do
+      @uri.route_to("http://example.com/")
+    end).should raise_error(ArgumentError, /\/\/example.com\//)
+    (lambda do
+      @uri.route_from("http://example.com/")
+    end).should raise_error(ArgumentError, /\/\/example.com\//)    
+  end
 end
 
 describe Addressable::URI, " when parsed from " +
@@ -1613,13 +1972,12 @@ describe Addressable::URI, " when parsed from " +
     @uri = Addressable::URI.parse("feed://http://example.com/")
   end
 
-  it "should have a path of 'http://example.com/'" do
-    @uri.path.should == "http://example.com/"
+  it "should have a host of 'http'" do
+    @uri.host.should == "http"
   end
 
-  it "should normalize to 'http://example.com/'" do
-    @uri.normalize.to_s.should == "http://example.com/"
-    @uri.normalize!.to_s.should == "http://example.com/"
+  it "should have a path of '//example.com/'" do
+    @uri.path.should == "//example.com/"
   end
 end
 
@@ -2520,3 +2878,125 @@ describe Addressable::URI, " when parsed from " +
       }
   end
 end
+
+describe Addressable::URI, " when given the input " +
+    "'/path/to/resource'" do
+  before do
+    @input = "/path/to/resource"
+  end
+
+  it "should heuristically parse to '/path/to/resource'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    @uri.to_s.should == "/path/to/resource"
+  end
+end
+
+describe Addressable::URI, " when given the input " +
+    "'relative/path/to/resource'" do
+  before do
+    @input = "relative/path/to/resource"
+  end
+
+  it "should heuristically parse to 'relative/path/to/resource'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    @uri.to_s.should == "relative/path/to/resource"
+  end
+end
+
+describe Addressable::URI, " when given the input " +
+    "'example.com'" do
+  before do
+    @input = "example.com"
+  end
+
+  it "should heuristically parse to 'http://example.com'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    @uri.to_s.should == "http://example.com"
+  end
+end
+
+describe Addressable::URI, " when given the input " +
+    "'example.com' and a scheme hint of 'ftp'" do
+  before do
+    @input = "example.com"
+    @hints = {:scheme => 'ftp'}
+  end
+
+  it "should heuristically parse to 'http://example.com'" do
+    @uri = Addressable::URI.heuristic_parse(@input, @hints)
+    @uri.to_s.should == "ftp://example.com"
+  end
+end
+
+describe Addressable::URI, " when given the input " +
+    "'example.com:21' and a scheme hint of 'ftp'" do
+  before do
+    @input = "example.com:21"
+    @hints = {:scheme => 'ftp'}
+  end
+
+  it "should heuristically parse to 'http://example.com:21'" do
+    @uri = Addressable::URI.heuristic_parse(@input, @hints)
+    @uri.to_s.should == "ftp://example.com:21"
+  end
+end
+
+describe Addressable::URI, " when given the input " +
+    "'example.com/path/to/resource'" do
+  before do
+    @input = "example.com/path/to/resource"
+  end
+
+  it "should heuristically parse to 'http://example.com/path/to/resource'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    @uri.to_s.should == "http://example.com/path/to/resource"
+  end
+end
+
+describe Addressable::URI, " when given the input " +
+    "'http:///example.com'" do
+  before do
+    @input = "http:///example.com"
+  end
+
+  it "should heuristically parse to 'http://example.com'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    @uri.to_s.should == "http://example.com"
+  end
+end
+
+describe Addressable::URI, " when given the input " +
+    "'feed:///example.com'" do
+  before do
+    @input = "feed:///example.com"
+  end
+
+  it "should heuristically parse to 'feed://example.com'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    @uri.to_s.should == "feed://example.com"
+  end
+end
+
+describe Addressable::URI, " when given the input " +
+    "'file://path/to/resource/'" do
+  before do
+    @input = "file://path/to/resource/"
+  end
+
+  it "should heuristically parse to 'file:///path/to/resource/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    @uri.to_s.should == "file:///path/to/resource/"
+  end
+end
+
+describe Addressable::URI, " when given the input " +
+    "'feed://http://example.com'" do
+  before do
+    @input = "feed://http://example.com"
+  end
+
+  it "should heuristically parse to 'feed:http://example.com'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    @uri.to_s.should == "feed:http://example.com"
+  end
+end