Move URI to rely less on shared examples

Author: Earlopain

library/uri/parser/extract_spec.rb

@@ -1,7 +1,90 @@
 require_relative '../../../spec_helper'
-require_relative '../shared/extract'
 require 'uri'
 
 describe "URI::Parser#extract" do
-  it_behaves_like :uri_extract, :extract, URI::Parser.new
+  before :all do
+    @parser = URI::Parser.new
+  end
+
+  it "behaves according to its documentation" do
+    @parser.extract("text here http://foo.example.org/bla and here mailto:test@example.com and here also.").should == ["http://foo.example.org/bla", "mailto:test@example.com"]
+  end
+
+  it "treats contiguous URIs as a single URI" do
+    @parser.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
+    @parser.extract('From: XXX [mailto:xxx@xxx.xxx.xxx]').should == ['From:', 'mailto:xxx@xxx.xxx.xxx]']
+  end
+
+  it "wraps a URI string in an array" do
+    @parser.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
+    @parser.extract("this is a string, it has http://rubini.us/ in it").should == ["http://rubini.us/"]
+    @parser.extract("mailto:spambait@example.com").should == ["mailto:spambait@example.com"]
+    @parser.extract("ftp://ruby-lang.org/").should == ["ftp://ruby-lang.org/"]
+    @parser.extract("https://mail.google.com").should == ["https://mail.google.com"]
+    @parser.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
+    @parser.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:mduerst@ifi.unizh.ch
+          -- 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:mduerst@ifi.unizh.ch","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:test@example.com"]
+    @parser.extract("text here http://foo.example.org/bla and here mailto:test@example.com 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
+    @parser.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:mduerst@ifi.unizh.ch
+          -- 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:mduerst@ifi.unizh.ch"]
+  end
 end

library/uri/parser/join_spec.rb

@@ -1,7 +1,62 @@
 require_relative '../../../spec_helper'
-require_relative '../shared/join'
 require 'uri'
 
 describe "URI::Parser#join" do
-  it_behaves_like :uri_join, :join, URI::Parser.new
+  before :all do
+    @parser = URI::Parser.new
+  end
+
+  it "returns a URI object of the concatenation of a protocol and domain, and a path" do
+    @parser.join("http://localhost/","main.rbx").should == URI.parse("http://localhost/main.rbx")
+  end
+
+  it "accepts URI objects" do
+    @parser.join(URI("http://localhost/"),"main.rbx").should == URI.parse("http://localhost/main.rbx")
+    @parser.join("http://localhost/",URI("main.rbx")).should == URI.parse("http://localhost/main.rbx")
+    @parser.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")
+    @parser.join(str, str2).should == URI.parse("http://ruby-lang.org/foo/bar")
+  end
+
+  it "raises an error if given no argument" do
+    -> {
+      @parser.join
+    }.should.raise(ArgumentError)
+  end
+
+  it "doesn't create redundant '/'s" do
+    @parser.join("http://localhost/", "/main.rbx").should == URI.parse("http://localhost/main.rbx")
+  end
+
+  it "discards arguments given before an absolute uri" do
+    @parser.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
+    @parser.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'))

library/uri/parser/parse_spec.rb

@@ -1,7 +1,213 @@
 require_relative '../../../spec_helper'
 require_relative '../fixtures/classes'
-require_relative '../shared/parse'
 
 describe "URI::Parser#parse" do
-  it_behaves_like :uri_parse, :parse, URI::Parser.new
+  before :all do
+    @parser = URI::Parser.new
+  end
+
+  it "returns a URI::HTTP object when parsing an HTTP URI" do
+    @parser.parse("http://www.example.com/").should.is_a?(URI::HTTP)
+  end
+
+  it "populates the components of a parsed URI::HTTP, setting the port to 80 by default" do
+    # general case
+    URISpec.components(@parser.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(@parser.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(@parser.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
+    @parser.parse("http://example.com:8080/").port.should == 8080
+  end
+
+  it "returns a URI::HTTPS object when parsing an HTTPS URI" do
+    @parser.parse("https://important-intern-net.net").should.is_a?(URI::HTTPS)
+  end
+
+  it "sets the port of a parsed https URI to 443 by default" do
+    @parser.parse("https://example.com/").port.should == 443
+  end
+
+  it "populates the components of a parsed URI::FTP object" do
+    # generic, empty password.
+    url = @parser.parse("ftp://anonymous@ruby-lang.org/pub/ruby/1.8/ruby-1.8.6.tar.bz2;type=i")
+    url.should.is_a?(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 = @parser.parse('ftp://ftp.is.co.za/rfc/rfc1808.txt')
+    url.should.is_a?(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 = @parser.parse('ftp://:pass@localhost/')
+    url.should.is_a?(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|
+      @parser.parse(ldap_uri).should.is_a?(URI::LDAP)
+    end
+  end
+
+  it "populates the components of a parsed URI::LDAP object" do
+    URISpec.components(@parser.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
+    @parser.parse("mailto:spam@mailinator.com").should.is_a?(URI::MailTo)
+  end
+
+  it "populates the components of a parsed URI::MailTo object" do
+    URISpec.components(@parser.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 = @parser.parse('gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles')
+    gopher.should.is_a?(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 = @parser.parse('news:comp.infosystems.www.servers.unix')
+    news.should.is_a?(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 = @parser.parse('telnet://melvyl.ucop.edu/')
+    telnet.should.is_a?(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 = @parser.parse('file:///foo/bar.txt')
+    file_l.should.is_a?(URI::Generic)
+    file = @parser.parse('file:/foo/bar.txt')
+    file.should.is_a?(URI::Generic)
+  end
+
+  if URI::DEFAULT_PARSER == URI::RFC2396_Parser
+    it "raises errors on malformed URIs" do
+      -> { @parser.parse('http://a_b:80/') }.should.raise(URI::InvalidURIError)
+      -> { @parser.parse('http://a_b/') }.should.raise(URI::InvalidURIError)
+    end
+  elsif URI::DEFAULT_PARSER == URI::RFC3986_Parser
+    it "does not raise errors on URIs contained underscore" do
+      -> { @parser.parse('http://a_b:80/') }.should_not.raise(URI::InvalidURIError)
+      -> { @parser.parse('http://a_b/') }.should_not.raise(URI::InvalidURIError)
+    end
+  end
 end