4 files changed, 353 insertions, 0 deletions
diff --git a/spec/ruby/library/uri/shared/eql.rb b/spec/ruby/library/uri/shared/eql.rb
new file mode 100644
index 0000000000..2cc960d39a
--- /dev/null
+++ b/spec/ruby/library/uri/shared/eql.rb
@@ -0,0 +1,17 @@
+describe :uri_eql, shared: true do
+  it "returns false if the normalized forms are different" do
+    URISpec::NORMALIZED_FORMS.each do |form|
+      normal_uri = URI(form[:normalized])
+      form[:different].each do |other|
+        URI(other).send(@method, normal_uri).should be_false
+      end
+    end
+  end
+end
+
+describe :uri_eql_against_other_types, shared: true do
+  it "returns false for when compared to non-uri objects" do
+    URI("http://example.com/").send(@method, "http://example.com/").should be_false
+    URI("http://example.com/").send(@method, nil).should be_false
+  end
+end
diff --git a/spec/ruby/library/uri/shared/extract.rb b/spec/ruby/library/uri/shared/extract.rb
new file mode 100644
index 0000000000..efe60ae4b9
--- /dev/null
+++ b/spec/ruby/library/uri/shared/extract.rb
@@ -0,0 +1,83 @@
+describe :uri_extract, shared: true do
+  it "behaves according to its documentation" do
+    @object.extract("text here http://foo.example.org/bla and here mailto:[email protected] and here also.").should == ["http://foo.example.org/bla", "mailto:[email protected]"]
+  end
+
+  it "treats contiguous URIs as a single URI" do
+    @object.extract('http://example.jphttp://example.jp').should == ['http://example.jphttp://example.jp']
+  end
+
+  it "treats pretty much anything with a colon as a URI" do
+    @object.extract('From: XXX [mailto:[email protected]]').should == ['From:', 'mailto:[email protected]]']
+  end
+
+  it "wraps a URI string in an array" do
+    @object.extract("http://github.com/brixen/rubyspec/tree/master").should == ["http://github.com/brixen/rubyspec/tree/master"]
+  end
+
+  it "pulls a variety of protocol URIs from a string" do
+    @object.extract("this is a string, it has http://rubini.us/ in it").should == ["http://rubini.us/"]
+    @object.extract("mailto:[email protected]").should == ["mailto:[email protected]"]
+    @object.extract("ftp://ruby-lang.org/").should == ["ftp://ruby-lang.org/"]
+    @object.extract("https://mail.google.com").should == ["https://mail.google.com"]
+    @object.extract("anything://example.com/").should == ["anything://example.com/"]
+  end
+
+  it "pulls all URIs within a string in order into an array when a block is not given" do
+    @object.extract("1.3. Example URI
+
+       The following examples illustrate URI that are in common use.
+
+       ftp://ftp.is.co.za/rfc/rfc1808.txt
+          -- ftp scheme for File Transfer Protocol services
+
+       gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles
+          -- gopher scheme for Gopher and Gopher+ Protocol services
+
+       http://www.math.uio.no/faq/compression-faq/part1.html
+          -- http scheme for Hypertext Transfer Protocol services
+
+       mailto:[email protected]
+          -- mailto scheme for electronic mail addresses
+
+       news:comp.infosystems.www.servers.unix
+          -- news scheme for USENET news groups and articles
+
+       telnet://melvyl.ucop.edu/
+          -- telnet scheme for interactive services via the TELNET Protocol
+    ").should == ["ftp://ftp.is.co.za/rfc/rfc1808.txt","gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles","http://www.math.uio.no/faq/compression-faq/part1.html","mailto:[email protected]","news:comp.infosystems.www.servers.unix","telnet://melvyl.ucop.edu/"]
+  end
+
+  it "yields each URI in the given string in order to a block, if given, and returns nil" do
+    results = ["http://foo.example.org/bla", "mailto:[email protected]"]
+    @object.extract("text here http://foo.example.org/bla and here mailto:[email protected] and here also.") {|uri|
+      uri.should == results.shift
+    }.should == nil
+    results.should == []
+  end
+
+  it "allows the user to specify a list of acceptable protocols of URIs to scan for" do
+    @object.extract("1.3. Example URI
+
+       The following examples illustrate URI that are in common use.
+
+       ftp://ftp.is.co.za/rfc/rfc1808.txt
+          -- ftp scheme for File Transfer Protocol services
+
+       gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles
+          -- gopher scheme for Gopher and Gopher+ Protocol services
+
+       http://www.math.uio.no/faq/compression-faq/part1.html
+          -- http scheme for Hypertext Transfer Protocol services
+
+       mailto:[email protected]
+          -- mailto scheme for electronic mail addresses
+
+       news:comp.infosystems.www.servers.unix
+          -- news scheme for USENET news groups and articles
+
+       telnet://melvyl.ucop.edu/
+          -- telnet scheme for interactive services via the TELNET Protocol
+    ", ["http","ftp","mailto"]).should == ["ftp://ftp.is.co.za/rfc/rfc1808.txt","http://www.math.uio.no/faq/compression-faq/part1.html","mailto:[email protected]"]
+  end
+end
diff --git a/spec/ruby/library/uri/shared/join.rb b/spec/ruby/library/uri/shared/join.rb
new file mode 100644
index 0000000000..dfe44e9be2
--- /dev/null
+++ b/spec/ruby/library/uri/shared/join.rb
@@ -0,0 +1,54 @@
+describe :uri_join, shared: true do
+  it "returns a URI object of the concatenation of a protocol and domain, and a path" do
+    @object.join("http://localhost/","main.rbx").should == URI.parse("http://localhost/main.rbx")
+  end
+
+  it "accepts URI objects" do
+    @object.join(URI("http://localhost/"),"main.rbx").should == URI.parse("http://localhost/main.rbx")
+    @object.join("http://localhost/",URI("main.rbx")).should == URI.parse("http://localhost/main.rbx")
+    @object.join(URI("http://localhost/"),URI("main.rbx")).should == URI.parse("http://localhost/main.rbx")
+  end
+
+  it "accepts string-like arguments with to_str" do
+    str = mock('string-like')
+    str.should_receive(:to_str).and_return("http://ruby-lang.org")
+    str2 = mock('string-like also')
+    str2.should_receive(:to_str).and_return("foo/bar")
+    @object.join(str, str2).should == URI.parse("http://ruby-lang.org/foo/bar")
+  end
+
+  it "raises an error if given no argument" do
+    lambda{ @object.join }.should raise_error
+  end
+
+  it "doesn't create redundant '/'s" do
+    @object.join("http://localhost/", "/main.rbx").should == URI.parse("http://localhost/main.rbx")
+  end
+
+  it "discards arguments given before an absolute uri" do
+    @object.join("http://localhost/a/b/c/d", "http://ruby-lang.com/foo", "bar").should == URI.parse("http://ruby-lang.com/bar")
+  end
+
+  it "resolves .. in paths" do
+    @object.join("http://localhost/a/b/c/d", "../../e/f", "g/h/../i").to_s.should == "http://localhost/a/e/g/i"
+  end
+end
+
+
+# assert_equal(URI.parse('http://foo/bar'), URI.join('http://foo/bar'))
+# assert_equal(URI.parse('http://foo/bar'), URI.join('http://foo', 'bar'))
+# assert_equal(URI.parse('http://foo/bar/'), URI.join('http://foo', 'bar/'))
+#
+# assert_equal(URI.parse('http://foo/baz'), URI.join('http://foo', 'bar', 'baz'))
+# assert_equal(URI.parse('http://foo/baz'), URI.join('http://foo', 'bar', '/baz'))
+# assert_equal(URI.parse('http://foo/baz/'), URI.join('http://foo', 'bar', '/baz/'))
+# assert_equal(URI.parse('http://foo/bar/baz'), URI.join('http://foo', 'bar/', 'baz'))
+# assert_equal(URI.parse('http://foo/hoge'), URI.join('http://foo', 'bar', 'baz', 'hoge'))
+#
+# assert_equal(URI.parse('http://foo/bar/baz'), URI.join('http://foo', 'bar/baz'))
+# assert_equal(URI.parse('http://foo/bar/hoge'), URI.join('http://foo', 'bar/baz', 'hoge'))
+# assert_equal(URI.parse('http://foo/bar/baz/hoge'), URI.join('http://foo', 'bar/baz/', 'hoge'))
+# assert_equal(URI.parse('http://foo/hoge'), URI.join('http://foo', 'bar/baz', '/hoge'))
+# assert_equal(URI.parse('http://foo/bar/hoge'), URI.join('http://foo', 'bar/baz', 'hoge'))
+# assert_equal(URI.parse('http://foo/bar/baz/hoge'), URI.join('http://foo', 'bar/baz/', 'hoge'))
+# assert_equal(URI.parse('http://foo/hoge'), URI.join('http://foo', 'bar/baz', '/hoge'))
diff --git a/spec/ruby/library/uri/shared/parse.rb b/spec/ruby/library/uri/shared/parse.rb
new file mode 100644
index 0000000000..5ecbffcaf2
--- /dev/null
+++ b/spec/ruby/library/uri/shared/parse.rb
@@ -0,0 +1,199 @@
+describe :uri_parse, shared: true do
+  it "returns a URI::HTTP object when parsing an HTTP URI" do
+    @object.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(@object.parse("http://user:[email protected]/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(@object.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(@object.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
+    @object.parse("http://example.com:8080/").port.should == 8080
+  end
+
+  it "returns a URI::HTTPS object when parsing an HTTPS URI" do
+    @object.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
+    @object.parse("https://example.com/").port.should == 443
+  end
+
+  it "populates the components of a parsed URI::FTP object" do
+    # generic, empty password.
+    url = @object.parse("ftp://[email protected]/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 = @object.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 = @object.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
+
+  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|
+      @object.parse(ldap_uri).should be_kind_of(URI::LDAP)
+    end
+  end
+
+  it "populates the components of a parsed URI::LDAP object" do
+    URISpec.components(@object.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
+    @object.parse("mailto:[email protected]").should be_kind_of(URI::MailTo)
+  end
+
+  it "populates the components of a parsed URI::MailTo object" do
+    URISpec.components(@object.parse("mailto:[email protected]?subject=Discounts%20On%20Imported%20methods!!!&body=Exciting%20offer")).should == {
+      scheme: "mailto",
+      to: "[email protected]",
+      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 = @object.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 = @object.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 = @object.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 = @object.parse('file:///foo/bar.txt')
+    file_l.should be_kind_of(URI::Generic)
+    file = @object.parse('file:/foo/bar.txt')
+    file.should be_kind_of(URI::Generic)
+  end
+
+  it "raises errors on malformed URIs" do
+    lambda { @object.parse('http://a_b:80/') }.should raise_error(URI::InvalidURIError)
+    lambda { @object.parse('http://a_b/') }.should raise_error(URI::InvalidURIError)
+  end
+end