rubysl-uri 0.0.1 → 1.0.0

data/spec/ldap/attributes_spec.rb

@@ -0,0 +1,9 @@
+require 'uri'
+
+describe "URI::LDAP#attributes" do
+  it "needs to be reviewed for spec completeness"
+end
+
+describe "URI::LDAP#attributes=" do
+  it "needs to be reviewed for spec completeness"
+end

data/spec/ldap/build_spec.rb

@@ -0,0 +1,5 @@
+require 'uri'
+
+describe "URI::LDAP.build" do
+  it "needs to be reviewed for spec completeness"
+end

data/spec/ldap/dn_spec.rb

@@ -0,0 +1,9 @@
+require 'uri'
+
+describe "URI::LDAP#dn" do
+  it "needs to be reviewed for spec completeness"
+end
+
+describe "URI::LDAP#dn=" do
+  it "needs to be reviewed for spec completeness"
+end

data/spec/ldap/extensions_spec.rb

@@ -0,0 +1,9 @@
+require 'uri'
+
+describe "URI::LDAP#extensions" do
+  it "needs to be reviewed for spec completeness"
+end
+
+describe "URI::LDAP#extensions=" do
+  it "needs to be reviewed for spec completeness"
+end

data/spec/ldap/filter_spec.rb

@@ -0,0 +1,9 @@
+require 'uri'
+
+describe "URI::LDAP#filter" do
+  it "needs to be reviewed for spec completeness"
+end
+
+describe "URI::LDAP#filter=" do
+  it "needs to be reviewed for spec completeness"
+end

data/spec/ldap/hierarchical_spec.rb

@@ -0,0 +1,5 @@
+require 'uri'
+
+describe "URI::LDAP#hierarchical?" do
+  it "needs to be reviewed for spec completeness"
+end

data/spec/ldap/scope_spec.rb

@@ -0,0 +1,9 @@
+require 'uri'
+
+describe "URI::LDAP#scope" do
+  it "needs to be reviewed for spec completeness"
+end
+
+describe "URI::LDAP#scope=" do
+  it "needs to be reviewed for spec completeness"
+end

data/spec/ldap/set_attributes_spec.rb

@@ -0,0 +1,5 @@
+require 'uri'
+
+describe "URI::LDAP#set_attributes" do
+  it "needs to be reviewed for spec completeness"
+end

data/spec/ldap/set_dn_spec.rb

@@ -0,0 +1,5 @@
+require 'uri'
+
+describe "URI::LDAP#set_dn" do
+  it "needs to be reviewed for spec completeness"
+end

data/spec/ldap/set_extensions_spec.rb

@@ -0,0 +1,5 @@
+require 'uri'
+
+describe "URI::LDAP#set_extensions" do
+  it "needs to be reviewed for spec completeness"
+end

data/spec/ldap/set_filter_spec.rb

@@ -0,0 +1,5 @@
+require 'uri'
+
+describe "URI::LDAP#set_filter" do
+  it "needs to be reviewed for spec completeness"
+end

data/spec/ldap/set_scope_spec.rb

@@ -0,0 +1,5 @@
+require 'uri'
+
+describe "URI::LDAP#set_scope" do
+  it "needs to be reviewed for spec completeness"
+end

data/spec/mailto/build_spec.rb

@@ -0,0 +1,98 @@
+require 'uri'
+
+describe "URI::Mailto.build" do
+  it "conforms to the MatzRuby tests" do
+    ok = []
+    bad = []
+
+    # RFC2368, 6. Examples
+    # mailto:chris@example.com
+    ok << ["mailto:chris@example.com"]
+    ok[-1] << ["chris@example.com", nil]
+    ok[-1] << {:to => "chris@example.com"}
+
+    # mailto:infobot@example.com?subject=current-issue
+    ok << ["mailto:infobot@example.com?subject=current-issue"]
+    ok[-1] << ["infobot@example.com", ["subject=current-issue"]]
+    ok[-1] << {:to => "infobot@example.com",
+      :headers => ["subject=current-issue"]}
+
+    # mailto:infobot@example.com?body=send%20current-issue
+    ok << ["mailto:infobot@example.com?body=send%20current-issue"]
+    ok[-1] << ["infobot@example.com", ["body=send%20current-issue"]]
+    ok[-1] << {:to => "infobot@example.com",
+      :headers => ["body=send%20current-issue"]}
+
+    # mailto:infobot@example.com?body=send%20current-issue%0D%0Asend%20index
+    ok << ["mailto:infobot@example.com?body=send%20current-issue%0D%0Asend%20index"]
+    ok[-1] << ["infobot@example.com",
+      ["body=send%20current-issue%0D%0Asend%20index"]]
+    ok[-1] << {:to => "infobot@example.com",
+      :headers => ["body=send%20current-issue%0D%0Asend%20index"]}
+
+    # mailto:foobar@example.com?In-Reply-To=%3c3469A91.D10AF4C@example.com
+    ok << ["mailto:foobar@example.com?In-Reply-To=%3c3469A91.D10AF4C@example.com"]
+    ok[-1] << ["foobar@example.com",
+      ["In-Reply-To=%3c3469A91.D10AF4C@example.com"]]
+    ok[-1] << {:to => "foobar@example.com",
+      :headers => ["In-Reply-To=%3c3469A91.D10AF4C@example.com"]}
+
+    # mailto:majordomo@example.com?body=subscribe%20bamboo-l
+    ok << ["mailto:majordomo@example.com?body=subscribe%20bamboo-l"]
+    ok[-1] << ["majordomo@example.com", ["body=subscribe%20bamboo-l"]]
+    ok[-1] << {:to => "majordomo@example.com",
+      :headers => ["body=subscribe%20bamboo-l"]}
+
+    # mailto:joe@example.com?cc=bob@example.com&body=hello
+    ok << ["mailto:joe@example.com?cc=bob@example.com&body=hello"]
+    ok[-1] << ["joe@example.com", ["cc=bob@example.com", "body=hello"]]
+    ok[-1] << {:to => "joe@example.com",
+      :headers => ["cc=bob@example.com", "body=hello"]}
+
+    # mailto:?to=joe@example.com&cc=bob@example.com&body=hello
+    ok << ["mailto:?to=joe@example.com&cc=bob@example.com&body=hello"]
+    ok[-1] << [nil,
+      ["to=joe@example.com", "cc=bob@example.com", "body=hello"]]
+    ok[-1] << {:headers => ["to=joe@example.com",
+	"cc=bob@example.com", "body=hello"]}
+
+    # mailto:gorby%25kremvax@example.com
+    ok << ["mailto:gorby%25kremvax@example.com"]
+    ok[-1] << ["gorby%25kremvax@example.com", nil]
+    ok[-1] << {:to => "gorby%25kremvax@example.com"}
+
+    # mailto:unlikely%3Faddress@example.com?blat=foop
+    ok << ["mailto:unlikely%3Faddress@example.com?blat=foop"]
+    ok[-1] << ["unlikely%3Faddress@example.com", ["blat=foop"]]
+    ok[-1] << {:to => "unlikely%3Faddress@example.com",
+      :headers => ["blat=foop"]}
+
+    ok_all = ok.flatten.join("\0")
+
+    # mailto:joe@example.com?cc=bob@example.com?body=hello   ; WRONG!
+    bad << ["joe@example.com", ["cc=bob@example.com?body=hello"]]
+
+    # mailto:javascript:alert()
+    bad << ["javascript:alert()", []]
+
+    # '=' which is in hname or hvalue is wrong.
+    bad << ["foo@example.jp?subject=1+1=2", []]
+
+    ok.each do |x|
+      URI::MailTo.build(x[1]).to_s.should == x[0]
+      URI::MailTo.build(x[2]).to_s.should == x[0]
+    end
+
+    bad.each do |x|
+      lambda { URI::MailTo.build(x) }.should raise_error(URI::InvalidComponentError)
+    end
+
+    ok.flatten.join("\0").should == ok_all
+  end
+end
+
+
+
+describe "URI::MailTo.build" do
+  it "needs to be reviewed for spec completeness"
+end

data/spec/mailto/headers_spec.rb

@@ -0,0 +1,9 @@
+require 'uri'
+
+describe "URI::MailTo#headers" do
+  it "needs to be reviewed for spec completeness"
+end
+
+describe "URI::MailTo#headers=" do
+  it "needs to be reviewed for spec completeness"
+end

data/spec/mailto/set_headers_spec.rb

@@ -0,0 +1,5 @@
+require 'uri'
+
+describe "URI::MailTo#set_headers" do
+  it "needs to be reviewed for spec completeness"
+end

data/spec/mailto/set_to_spec.rb

@@ -0,0 +1,5 @@
+require 'uri'
+
+describe "URI::MailTo#set_to" do
+  it "needs to be reviewed for spec completeness"
+end

data/spec/mailto/to_mailtext_spec.rb

@@ -0,0 +1,5 @@
+require 'uri'
+
+describe "URI::MailTo#to_mailtext" do
+  it "needs to be reviewed for spec completeness"
+end

data/spec/mailto/to_rfc822text_spec.rb

@@ -0,0 +1,5 @@
+require 'uri'
+
+describe "URI::MailTo#to_rfc822text" do
+  it "needs to be reviewed for spec completeness"
+end

data/spec/mailto/to_s_spec.rb

@@ -0,0 +1,5 @@
+require 'uri'
+
+describe "URI::MailTo#to_s" do
+  it "needs to be reviewed for spec completeness"
+end

data/spec/mailto/to_spec.rb

@@ -0,0 +1,9 @@
+require 'uri'
+
+describe "URI::MailTo#to" do
+  it "needs to be reviewed for spec completeness"
+end
+
+describe "URI::MailTo#to=" do
+  it "needs to be reviewed for spec completeness"
+end

data/spec/merge_spec.rb

@@ -0,0 +1,21 @@
+require 'uri'
+
+describe "URI#merge" do
+  it "returns the receiver and the argument, joined as per URI.join" do
+    URI("http://localhost/").merge("main.rbx").should == URI.parse("http://localhost/main.rbx")
+    URI("http://localhost/a/b/c/d").merge("http://ruby-lang.com/foo").should == URI.parse("http://ruby-lang.com/foo")
+    URI("http://localhost/a/b/c/d").merge("../../e/f").to_s.should == "http://localhost/a/e/f"
+  end
+
+  it "accepts URI objects as argument" do
+    URI("http://localhost/").merge(URI("main.rbx")).should == URI.parse("http://localhost/main.rbx")
+  end
+
+  ruby_bug "redmine:3506", "1.9.2" do
+    it "accepts a string-like argument" do
+      str = mock('string-like')
+      str.should_receive(:to_str).and_return("foo/bar")
+      URI("http://localhost/").merge(str).should == URI.parse("http://localhost/foo/bar")
+    end
+  end
+end

data/spec/normalize_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path('../fixtures/normalization', __FILE__)
+require 'uri'
+
+describe "URI#normalize" do
+  it "adds a / onto the end of the URI if the path is blank" do
+    no_path = URI("http://example.com")
+    no_path.to_s.should_not == "http://example.com/"
+    no_path.normalize.to_s.should == "http://example.com/"
+  end
+
+  it "downcases the host of the URI" do
+    uri = URI("http://exAMPLE.cOm/")
+    uri.to_s.should_not == "http://example.com/"
+    uri.normalize.to_s.should == "http://example.com/"
+  end
+
+  # The previous tests are included by the one below
+
+  quarantine! do # Quarantined until redmine:2542 is accepted
+    it "respects RFC 3986" do
+      URISpec::NORMALIZED_FORMS.each do |form|
+        normal_uri = URI(form[:normalized])
+        normalized = normal_uri.normalize.to_s
+        normal_uri.to_s.should == normalized
+        form[:equivalent].each do |same|
+          URI(same).normalize.to_s.should == normalized
+        end
+        form[:different].each do |other|
+          URI(other).normalize.to_s.should_not == normalized
+        end
+      end
+    end
+  end
+end

data/spec/parse_spec.rb

@@ -0,0 +1,248 @@
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "URI.parse" do
+
+  it "returns a URI::HTTP object when parsing an HTTP URI" do
+    URI.parse("http://www.example.com/").should be_kind_of(URI::HTTP)
+  end
+
+  it "populates the components of a parsed URI::HTTP, setting the port to 80 by default" do
+    # general case
+    URISpec.components(URI.parse("http://user:pass@example.com/path/?query=val&q2=val2#fragment")).should == {
+      :scheme => "http",
+      :userinfo => "user:pass",
+      :host => "example.com",
+      :port => 80,
+      :path => "/path/",
+      :query => "query=val&q2=val2",
+      :fragment => "fragment"
+    }
+
+    # multiple paths
+    URISpec.components(URI.parse("http://a/b/c/d;p?q")).should == {
+      :scheme => "http",
+      :userinfo => nil,
+      :host => "a",
+      :port => 80,
+      :path => "/b/c/d;p",
+      :query => "q",
+      :fragment => nil
+    }
+
+    # multi-level domain
+    URISpec.components(URI.parse('http://www.math.uio.no/faq/compression-faq/part1.html')).should == {
+      :scheme => "http",
+      :userinfo => nil,
+      :host => "www.math.uio.no",
+      :port => 80,
+      :path => "/faq/compression-faq/part1.html",
+      :query => nil,
+      :fragment => nil
+    }
+  end
+
+  it "parses out the port number of a URI, when given" do
+    URI.parse("http://example.com:8080/").port.should == 8080
+  end
+
+  it "returns a URI::HTTPS object when parsing an HTTPS URI" do
+    URI.parse("https://important-intern-net.net").should be_kind_of(URI::HTTPS)
+  end
+
+  it "sets the port of a parsed https URI to 443 by default" do
+    URI.parse("https://example.com/").port.should == 443
+  end
+
+  ruby_version_is "".."1.8.6" do
+    it "populates the components of a parsed URI::FTP object" do
+      # generic, empty password.
+      url = URI.parse("ftp://anonymous@ruby-lang.org/pub/ruby/1.8/ruby-1.8.6.tar.bz2;type=i")
+      url.should be_kind_of(URI::FTP)
+      URISpec.components(url).should == {
+        :scheme => "ftp",
+        :userinfo => "anonymous",
+        :host => "ruby-lang.org",
+        :port => 21,
+        :path => "pub/ruby/1.8/ruby-1.8.6.tar.bz2",
+        :typecode => "i"
+      }
+
+      # multidomain, no user or password
+      url = URI.parse('ftp://ftp.is.co.za/rfc/rfc1808.txt')
+      url.should be_kind_of(URI::FTP)
+      URISpec.components(url).should == {
+        :scheme => "ftp",
+        :userinfo => nil,
+        :host => "ftp.is.co.za",
+        :port => 21,
+        :path => "rfc/rfc1808.txt",
+        :typecode => nil
+      }
+
+      # empty user
+      url = URI.parse('ftp://:pass@localhost/')
+      url.should be_kind_of(URI::FTP)
+      URISpec.components(url).should == {
+        :scheme => "ftp",
+        :userinfo => ":pass",
+        :host => "localhost",
+        :port => 21,
+        :path => "/",
+        :typecode => nil
+      }
+      url.password.should == "pass"
+
+    end
+  end
+
+  ruby_version_is "1.8.7".."" do
+    it "populates the components of a parsed URI::FTP object" do
+      # generic, empty password.
+      url = URI.parse("ftp://anonymous@ruby-lang.org/pub/ruby/1.8/ruby-1.8.6.tar.bz2;type=i")
+      url.should be_kind_of(URI::FTP)
+      URISpec.components(url).should == {
+        :scheme => "ftp",
+        :userinfo => "anonymous",
+        :host => "ruby-lang.org",
+        :port => 21,
+        :path => "/pub/ruby/1.8/ruby-1.8.6.tar.bz2",
+        :typecode => "i"
+      }
+
+      # multidomain, no user or password
+      url = URI.parse('ftp://ftp.is.co.za/rfc/rfc1808.txt')
+      url.should be_kind_of(URI::FTP)
+      URISpec.components(url).should == {
+        :scheme => "ftp",
+        :userinfo => nil,
+        :host => "ftp.is.co.za",
+        :port => 21,
+        :path => "/rfc/rfc1808.txt",
+        :typecode => nil
+      }
+
+      # empty user
+      url = URI.parse('ftp://:pass@localhost/')
+      url.should be_kind_of(URI::FTP)
+      URISpec.components(url).should == {
+        :scheme => "ftp",
+        :userinfo => ":pass",
+        :host => "localhost",
+        :port => 21,
+        :path => "/",
+        :typecode => nil
+      }
+      url.password.should == "pass"
+
+    end
+  end
+
+
+  it "returns a URI::LDAP object when parsing an LDAP URI" do
+    #taken from http://www.faqs.org/rfcs/rfc2255.html 'cause I don't really know what an LDAP url looks like
+    ldap_uris = %w{ ldap:///o=University%20of%20Michigan,c=US ldap://ldap.itd.umich.edu/o=University%20of%20Michigan,c=US ldap://ldap.itd.umich.edu/o=University%20of%20Michigan,c=US?postalAddress ldap://host.com:6666/o=University%20of%20Michigan,c=US??sub?(cn=Babs%20Jensen) ldap://ldap.itd.umich.edu/c=GB?objectClass?one ldap://ldap.question.com/o=Question%3f,c=US?mail ldap://ldap.netscape.com/o=Babsco,c=US??(int=%5c00%5c00%5c00%5c04) ldap:///??sub??bindname=cn=Manager%2co=Foo ldap:///??sub??!bindname=cn=Manager%2co=Foo }
+    ldap_uris.each do |ldap_uri|
+      URI.parse(ldap_uri).should be_kind_of(URI::LDAP)
+    end
+  end
+
+  it "populates the components of a parsed URI::LDAP object" do
+    URISpec.components(URI.parse("ldap://ldap.itd.umich.edu/o=University%20of%20Michigan,c=US?postalAddress?scope?filter?extensions")).should == {
+      :scheme => "ldap",
+      :host => "ldap.itd.umich.edu",
+      :port => 389,
+      :dn => "o=University%20of%20Michigan,c=US",
+      :attributes => "postalAddress",
+      :scope => "scope",
+      :filter => "filter",
+      :extensions => "extensions"
+    }
+  end
+
+  it "returns a URI::MailTo object when passed a mailto URI" do
+    URI.parse("mailto:spam@mailinator.com").should be_kind_of(URI::MailTo)
+  end
+
+  it "populates the components of a parsed URI::MailTo object" do
+    URISpec.components(URI.parse("mailto:spam@mailinator.com?subject=Discounts%20On%20Imported%20methods!!!&body=Exciting%20offer")).should == {
+      :scheme => "mailto",
+      :to => "spam@mailinator.com",
+      :headers => [["subject","Discounts%20On%20Imported%20methods!!!"],
+                   ["body", "Exciting%20offer"]]
+    }
+  end
+
+  # TODO
+  # Test registry
+  it "does its best to extract components from URI::Generic objects" do
+    # generic
+    URISpec.components(URI("scheme://userinfo@host/path?query#fragment")).should == {
+      :scheme => "scheme",
+      :userinfo => "userinfo",
+      :host => "host",
+      :port => nil,
+      :path => "/path",
+      :query => "query",
+      :fragment => "fragment",
+      :registry => nil,
+      :opaque => nil
+    }
+
+    # gopher
+    gopher = URI.parse('gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles')
+    gopher.should be_kind_of(URI::Generic)
+
+    URISpec.components(gopher).should == {
+      :scheme => "gopher",
+      :userinfo => nil,
+      :host => "spinaltap.micro.umn.edu",
+      :port => nil,
+      :path => "/00/Weather/California/Los%20Angeles",
+      :query => nil,
+      :fragment => nil,
+      :registry => nil,
+      :opaque => nil
+    }
+
+    # news
+    news = URI.parse('news:comp.infosystems.www.servers.unix')
+    news.should be_kind_of(URI::Generic)
+    URISpec.components(news).should == {
+      :scheme => "news",
+      :userinfo => nil,
+      :host => nil,
+      :port => nil,
+      :path => nil,
+      :query => nil,
+      :fragment => nil,
+      :registry => nil,
+      :opaque => "comp.infosystems.www.servers.unix"
+    }
+
+    # telnet
+    telnet = URI.parse('telnet://melvyl.ucop.edu/')
+    telnet.should be_kind_of(URI::Generic)
+    URISpec.components(telnet).should == {
+      :scheme => "telnet",
+      :userinfo => nil,
+      :host => "melvyl.ucop.edu",
+      :port => nil,
+      :path => "/",
+      :query => nil,
+      :fragment => nil,
+      :registry => nil,
+      :opaque => nil
+    }
+
+    # files
+    file_l = URI.parse('file:///foo/bar.txt')
+    file_l.should be_kind_of(URI::Generic)
+    file = URI.parse('file:/foo/bar.txt')
+    file.should be_kind_of(URI::Generic)
+  end
+
+  it "raises errors on malformed URIs" do
+    lambda { URI.parse('http://a_b:80/') }.should raise_error(URI::InvalidURIError)
+    lambda { URI.parse('http://a_b/') }.should raise_error(URI::InvalidURIError)
+  end
+end