gitable 0.2.4 → 0.3.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MzE0ZTY2Yjc1ZTI4MmU0N2VkMmZkNTQ3ODBlM2UzYWE5NjY3ZDhlOQ==
+  data.tar.gz: !binary |-
+    OGY2ZDZjZTk3OTNiMDU2MDdkNjNiZTgwNDY3MjVkY2M5MzVjNjg2ZA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    NzI3MmM5ZjkyNGRkZDA1N2YwMGE5OThjZmE1MDBlN2E3MDVkM2Q0MjJjNWI1
+    MWUzY2U5YTI4OTUyYWMzY2UzNjM2NTQxN2RmNDg0MTUzNWQ5M2NiMzc4M2I2
+    YmE4YWZhODRiNjVkOGZjNzBjZmFkNWJjOTc1ODk0MDVkMTRiODU=
+  data.tar.gz: !binary |-
+    Y2ZmNjhiZDllODY0NjZmM2E4NjM5ZGMwYWVjYWQxMmM2NmI0MmMwNDRkMjA0
+    ODBhYzljNmJiZjBhZGE3ZGNkZGMyNTA5YTNmNzU0NWJmZjFlZGEwNmM5OTQ4
+    YWU1MTJjZGJkZDIyODg2YjA1NzFlMWYxMzZmZjQ2OThmYTRmNjY=

data/Rakefile

@@ -11,3 +11,21 @@ task :coverage => [:coverage_env, :spec]
 task :coverage_env do
   ENV['COVERAGE'] = '1'
 end
+
+task :benchmark do
+  require 'benchmark'
+  require 'uri'
+  require File.expand_path('lib/gitable/uri', File.dirname(__FILE__))
+
+  n = 10000
+  scp = "git@github.com:martinemde/gitable.git"
+  uri = "git://github.com/martinemde/gitable.git"
+  dup = Gitable::URI.parse(uri)
+  Benchmark.bmbm do |x|
+    x.report('dup')         { n.times { Gitable::URI.parse(dup) } }
+    x.report(uri)           { n.times { Gitable::URI.parse(uri) } }
+    x.report(scp)           { n.times { Gitable::URI.parse(scp) } }
+    x.report("addressable") { n.times { Addressable::URI.parse(uri) } }
+    x.report("uri")         { n.times { URI.parse(uri) } }
+  end
+end

data/gitable.gemspec

@@ -1,15 +1,16 @@
 # -*- encoding: utf-8 -*-
 Gem::Specification.new do |s|
   s.name        = "gitable"
-  s.version     = "0.2.4"
+  s.version     = "0.3.0"
   s.authors     = ["Martin Emde"]
   s.email       = ["martin.emde@gmail.com"]
   s.homepage    = "http://github.org/martinemde/gitable"
   s.summary     = %q{Addressable::URI for Git. Gitable::URI.}
   s.description = %q{Addressable::URI for Git URIs with special handling for scp-style URIs that Addressable doesn't like.}
+  s.license     = 'MIT'
 
-  s.add_dependency "addressable"
-  s.add_development_dependency "rspec", "~>2.0"
+  s.add_dependency "addressable", ">= 2.2.7"
+  s.add_development_dependency "rspec", "~>2.11"
   s.add_development_dependency "rake"
   s.add_development_dependency "simplecov"
 

data/lib/gitable/scp_uri.rb

@@ -3,36 +3,19 @@ require 'gitable/uri'
 
 module Gitable
   class ScpURI < Gitable::URI
-    REGEXP = %r|^([^:/?#]+):([^:?#]*)$|
 
     ##
-    # Expected to be an scp style URI if Addressable interprets it wrong and
-    # it matches our scp regexp
-    #
-    # nil host is an Addressable misunderstanding (therefore it might be scp style)
+    # Deprecated: This serves no purpose. You might as well just parse the URI.
     def self.scp?(uri)
-      uri && uri.match(REGEXP) && Addressable::URI.parse(uri).normalized_host.nil?
+      $stderr.puts "DEPRECATED: Gitable::ScpURI.scp?. You're better off parsing the URI and checking #scp?."
+      parse(uri).scp?
     end
 
     ##
-    # Parse an Scp style git repository URI into a URI object.
-    #
-    # @param [Addressable::URI, #to_str] uri URI of a git repository.
-    #
-    # @return [Gitable::URI, nil] the URI object or nil if nil was passed in.
-    #
-    # @raise [TypeError] The uri must respond to #to_str.
-    # @raise [Gitable::URI::InvalidURIError] When the uri is *total* rubbish.
-    #
+    # Deprecated: This serves no purpose. Just use Gitable::URI.parse.
     def self.parse(uri)
-      return uri if uri.nil? || uri.kind_of?(self)
-
-      if scp?(uri)
-        authority, path = uri.scan(REGEXP).flatten
-        Gitable::ScpURI.new(:authority => authority, :path => path)
-      else
-        raise InvalidURIError, "Unable to parse scp style URI: #{uri}"
-      end
+      $stderr.puts "DEPRECATED: Gitable::ScpURI.parse just runs Gitable::URI.parse. Please use this directly."
+      Gitable::URI.parse(uri)
     end
 
 
@@ -50,7 +33,7 @@ module Gitable
       super
       if new_path[0..0] != '/' # addressable adds a / but scp-style uris are altered by this behavior
         @path = path.sub(%r|^/+|,'')
-        @normalized_path = normalized_path.sub(%r|^/+|,'')
+        @normalized_path = nil
         validate
       end
       path
@@ -99,19 +82,19 @@ module Gitable
     def validate
       return if @validation_deferred
 
-      if normalized_host.to_s.empty?
+      if host.to_s.empty?
         raise InvalidURIError, "Hostname segment missing: '#{to_s}'"
       end
 
-      unless normalized_scheme.to_s.empty?
+      unless scheme.to_s.empty?
         raise InvalidURIError, "Scp style URI must not have a scheme: '#{to_s}'"
       end
 
-      if !normalized_port.to_s.empty?
+      if !port.to_s.empty?
         raise InvalidURIError, "Scp style URI cannot have a port: '#{to_s}'"
       end
 
-      if normalized_path.to_s.empty?
+      if path.to_s.empty?
         raise InvalidURIError, "Absolute URI missing hierarchical segment: '#{to_s}'"
       end
 

data/lib/gitable/uri.rb

@@ -2,6 +2,8 @@ require 'addressable/uri'
 
 module Gitable
   class URI < Addressable::URI
+    SCP_REGEXP =  %r|^([^:/?#]+):([^:?#]*)$|
+    URIREGEX = %r|^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$|
 
     ##
     # Parse a git repository URI into a URI object.
@@ -14,15 +16,50 @@ module Gitable
     # @raise [Gitable::URI::InvalidURIError] When the uri is *total* rubbish.
     #
     def self.parse(uri)
-      return uri if uri.nil? || uri.kind_of?(self)
+      return nil if uri.nil?
+      return uri.dup if uri.kind_of?(self)
+
+      # Copied from Addressable to speed up our parsing.
+      #
+      # If a URI object of the Ruby standard library variety is passed,
+      # convert it to a string, then parse the string.
+      # We do the check this way because we don't want to accidentally
+      # cause a missing constant exception to be thrown.
+      if uri.class.name =~ /^URI\b/
+        uri = uri.to_s
+      end
 
-      # addressable::URI.parse always returns an instance of Addressable::URI.
-      add = super # >:( at inconsistency
+      # Otherwise, convert to a String
+      begin
+        uri = uri.to_str
+      rescue TypeError, NoMethodError
+        raise TypeError, "Can't convert #{uri.class} into String."
+      end if not uri.is_a? String
+
+      # This Regexp supplied as an example in RFC 3986, and it works great.
+      fragments = uri.scan(URIREGEX)[0]
+      scheme    = fragments[1]
+      authority = fragments[3]
+      path      = fragments[4]
+      query     = fragments[6]
+      fragment  = fragments[8]
+      host = nil
+      if authority
+        host = authority.gsub(/^([^\[\]]*)@/, '').gsub(/:([^:@\[\]]*?)$/, '')
+      else
+        authority = scheme
+      end
 
-      if Gitable::ScpURI.scp?(uri)
-        Gitable::ScpURI.parse(uri)
+      if host.nil? && (parts = uri.scan(SCP_REGEXP)) && parts.any?
+        Gitable::ScpURI.new(:authority => parts.first[0], :path => parts.first[1])
       else
-        new(add.omit(:password,:query,:fragment).to_hash)
+        new(
+          :scheme    => scheme,
+          :authority => authority,
+          :path      => path,
+          :query     => query,
+          :fragment  => fragment
+        )
       end
     end
 

data/spec/describe_uri.rb

@@ -16,7 +16,7 @@ module DescribeURI
     def it_sets(parts)
       parts.each do |part, value|
         it "sets #{part} to #{value.inspect}" do
-          subject.send(part).should == value
+          expect(subject.send(part)).to eq(value)
         end
       end
     end

data/spec/gitable_spec.rb

@@ -3,41 +3,41 @@ require 'spec_helper'
 describe Gitable::URI do
   describe_uri "git://github.com/martinemde/gitable" do
     it "sets the .git extname" do
-      subject.extname.should == ""
+      expect(subject.extname).to eq("")
       subject.set_git_extname
-      subject.extname.should == ".git"
-      subject.to_s.should == @uri + ".git"
+      expect(subject.extname).to eq(".git")
+      expect(subject.to_s).to eq(@uri + ".git")
     end
 
     it "does not duplicate the extname" do
       subject.extname = "git"
-      subject.to_s.should == @uri + ".git"
+      expect(subject.to_s).to eq(@uri + ".git")
       subject.set_git_extname
-      subject.to_s.should == @uri + ".git"
+      expect(subject.to_s).to eq(@uri + ".git")
     end
 
     it "sets a new basename" do
-      subject.basename.should == "gitable"
+      expect(subject.basename).to eq("gitable")
       subject.basename = "gitable.git"
-      subject.basename.should == "gitable.git"
-      subject.extname.should == ".git"
+      expect(subject.basename).to eq("gitable.git")
+      expect(subject.extname).to eq(".git")
     end
   end
 
   describe_uri "git://github.com/" do
     it "does not set a new extname" do
-      subject.extname.should == ""
+      expect(subject.extname).to eq("")
       subject.set_git_extname
-      subject.extname.should == ""
-      subject.to_s.should == @uri
+      expect(subject.extname).to eq("")
+      expect(subject.to_s).to eq(@uri)
     end
 
     it "sets a new basename" do
-      subject.basename.should == ""
+      expect(subject.basename).to eq("")
       subject.basename = "gitable.git"
-      subject.basename.should == "gitable.git"
-      subject.extname.should == ".git"
-      subject.to_s.should == @uri + "gitable.git"
+      expect(subject.basename).to eq("gitable.git")
+      expect(subject.extname).to eq(".git")
+      expect(subject.to_s).to eq(@uri + "gitable.git")
     end
   end
 
@@ -72,26 +72,26 @@ describe Gitable::URI do
     before { @uri = "ssh://git@github.com/martinemde/gitable.git" }
 
     it "returns a Gitable::URI" do
-      Gitable::URI.parse(@uri).should be_a_kind_of(Gitable::URI)
+      expect(Gitable::URI.parse(@uri)).to be_a_kind_of(Gitable::URI)
     end
 
     it "returns nil when passed a nil uri" do
-      Gitable::URI.parse(nil).should be_nil
+      expect(Gitable::URI.parse(nil)).to be_nil
     end
 
     it "returns the same uri when passed a Gitable::URI" do
       gitable = Gitable::URI.parse(@uri)
-      Gitable::URI.parse(gitable).should be_eql(gitable)
+      expect(Gitable::URI.parse(gitable)).to eq(gitable)
     end
 
     it "raises a TypeError on bad type" do
-      lambda {
+      expect {
         Gitable::URI.parse(5)
-      }.should raise_error(TypeError)
+      }.to raise_error(TypeError)
     end
 
     it "returns nil with bad type on parse_when_valid" do
-      Gitable::URI.parse_when_valid(42).should be_nil
+      expect(Gitable::URI.parse_when_valid(42)).to be_nil
     end
 
     context "(bad uris)" do
@@ -101,46 +101,42 @@ describe Gitable::URI do
         "user@:path.git", # no host
         "user@host:", # no path
       ].each do |uri|
-        it "raises an Gitable::URI::InvalidURIError with #{uri.inspect}" do
-          lambda {
-            Gitable::URI.parse(uri)
-          }.should raise_error(Gitable::URI::InvalidURIError)
-        end
-
-        it "returns nil on parse_when_valid with #{uri.inspect}" do
-          Gitable::URI.parse_when_valid(uri).should be_nil
+        context uri.inspect do
+          it "raises an Gitable::URI::InvalidURIError" do
+            expect {
+              puts Gitable::URI.parse(uri).to_hash.inspect
+            }.to raise_error(Gitable::URI::InvalidURIError)
+          end
+
+          it "returns nil on parse_when_valid" do
+            expect(Gitable::URI.parse_when_valid(uri)).to be_nil
+          end
         end
       end
 
       context "scp uris" do
         it "raises without path" do
-          lambda {
-            Gitable::ScpURI.parse("http://github.com/path.git")
-          }.should raise_error(Gitable::URI::InvalidURIError)
-        end
-
-        it "raises without path" do
-          lambda {
+          expect {
             Gitable::ScpURI.new(:user => 'git', :host => 'github.com')
-          }.should raise_error(Gitable::URI::InvalidURIError)
+          }.to raise_error(Gitable::URI::InvalidURIError)
         end
 
         it "raises without host" do
-          lambda {
+          expect {
             Gitable::ScpURI.new(:user => 'git', :path => 'path')
-          }.should raise_error(Gitable::URI::InvalidURIError)
+          }.to raise_error(Gitable::URI::InvalidURIError)
         end
 
         it "raises with any scheme" do
-          lambda {
+          expect {
             Gitable::ScpURI.new(:scheme => 'ssh', :host => 'github.com', :path => 'path')
-          }.should raise_error(Gitable::URI::InvalidURIError)
+          }.to raise_error(Gitable::URI::InvalidURIError)
         end
 
         it "raises with any port" do
-          lambda {
+          expect {
             Gitable::ScpURI.new(:port => 88, :host => 'github.com', :path => 'path')
-          }.should raise_error(Gitable::URI::InvalidURIError)
+          }.to raise_error(Gitable::URI::InvalidURIError)
         end
       end
     end
@@ -163,8 +159,8 @@ describe Gitable::URI do
     }
 
     describe_uri "rsync://host.xz/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme       => "rsync",
         :project_name => "repo"
@@ -172,24 +168,24 @@ describe Gitable::URI do
     end
 
     describe_uri "rsync://host.xz/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme   => "rsync",
       })
     end
 
     describe_uri "http://host.xz/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme   => "http",
       })
     end
 
     describe_uri "http://host.xz:8888/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme         => "http",
         :port           => 8888,
@@ -198,8 +194,8 @@ describe Gitable::URI do
     end
 
     describe_uri "http://12.34.56.78:8888/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme         => "http",
         :host           => "12.34.56.78",
@@ -209,16 +205,16 @@ describe Gitable::URI do
     end
 
     describe_uri "https://host.xz/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme   => "https",
       })
     end
 
     describe_uri "https://user@host.xz/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme                     => "https",
         :user                       => "user",
@@ -228,8 +224,8 @@ describe Gitable::URI do
     end
 
     describe_uri "https://host.xz:8888/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme         => "https",
         :port           => 8888,
@@ -238,8 +234,8 @@ describe Gitable::URI do
     end
 
     describe_uri "git+ssh://host.xz/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme         => "git+ssh",
         :ssh?           => true,
@@ -248,16 +244,16 @@ describe Gitable::URI do
     end
 
     describe_uri "git://host.xz/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme   => "git",
       })
     end
 
     describe_uri "git://host.xz:8888/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme         => "git",
         :port           => 8888,
@@ -266,8 +262,8 @@ describe Gitable::URI do
     end
 
     describe_uri "git://host.xz/~user/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme         => "git",
         :path           => "/~user/path/to/repo.git/",
@@ -276,8 +272,8 @@ describe Gitable::URI do
     end
 
     describe_uri "git://host.xz:8888/~user/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme         => "git",
         :path           => "/~user/path/to/repo.git/",
@@ -287,8 +283,8 @@ describe Gitable::URI do
     end
 
     describe_uri "ssh://host.xz/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme         => "ssh",
         :ssh?           => true,
@@ -297,8 +293,8 @@ describe Gitable::URI do
     end
 
     describe_uri "ssh://user@host.xz/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme         => "ssh",
         :user           => "user",
@@ -308,8 +304,8 @@ describe Gitable::URI do
     end
 
     describe_uri "ssh://host.xz/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme         => "ssh",
         :ssh?           => true,
@@ -318,8 +314,8 @@ describe Gitable::URI do
     end
 
     describe_uri "ssh://host.xz:8888/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme         => "ssh",
         :port           => 8888,
@@ -330,8 +326,8 @@ describe Gitable::URI do
     end
 
     describe_uri "ssh://user@host.xz/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :user           => "user",
         :scheme         => "ssh",
@@ -341,8 +337,8 @@ describe Gitable::URI do
     end
 
     describe_uri "ssh://user@host.xz:8888/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme         => "ssh",
         :user           => "user",
@@ -354,8 +350,8 @@ describe Gitable::URI do
     end
 
     describe_uri "ssh://host.xz/~user/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme         => "ssh",
         :user           => nil,
@@ -367,8 +363,8 @@ describe Gitable::URI do
     end
 
     describe_uri "ssh://user@host.xz/~user/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme         => "ssh",
         :user           => "user",
@@ -380,8 +376,8 @@ describe Gitable::URI do
     end
 
     describe_uri "ssh://host.xz/~/path/to/repo.git" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme         => "ssh",
         :path           => "/~/path/to/repo.git",
@@ -392,8 +388,8 @@ describe Gitable::URI do
     end
 
     describe_uri "ssh://user@host.xz/~/path/to/repo.git" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme         => "ssh",
         :user           => "user",
@@ -405,8 +401,8 @@ describe Gitable::URI do
     end
 
     describe_uri "host.xz:/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme            => nil,
         :inferred_scheme   => 'ssh',
@@ -418,13 +414,13 @@ describe Gitable::URI do
     end
 
     describe_uri "user@host.xz:/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
-      it { subject.should be_equivalent('ssh://user@host.xz/path/to/repo.git') }
-      it { subject.should be_equivalent('user@host.xz:/path/to/repo.git') }
-      it { subject.should_not be_equivalent('user@host.xz:path/to/repo.git') } # not absolute
-      it { subject.should_not be_equivalent('/path/to/repo.git') }
-      it { subject.should_not be_equivalent('host.xz:path/to/repo.git') }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
+      it { expect(subject).to be_equivalent('ssh://user@host.xz/path/to/repo.git') }
+      it { expect(subject).to be_equivalent('user@host.xz:/path/to/repo.git') }
+      it { expect(subject).to_not be_equivalent('user@host.xz:path/to/repo.git') } # not absolute
+      it { expect(subject).to_not be_equivalent('/path/to/repo.git') }
+      it { expect(subject).to_not be_equivalent('host.xz:path/to/repo.git') }
       it_sets expected.merge({
         :scheme            => nil,
         :inferred_scheme   => 'ssh',
@@ -436,8 +432,8 @@ describe Gitable::URI do
     end
 
     describe_uri "host.xz:~user/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme            => nil,
         :inferred_scheme   => 'ssh',
@@ -450,8 +446,8 @@ describe Gitable::URI do
     end
 
     describe_uri "user@host.xz:~user/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme            => nil,
         :inferred_scheme   => 'ssh',
@@ -464,8 +460,8 @@ describe Gitable::URI do
     end
 
     describe_uri "host.xz:path/to/repo.git" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
       it_sets expected.merge({
         :scheme            => nil,
         :inferred_scheme   => 'ssh',
@@ -477,12 +473,12 @@ describe Gitable::URI do
     end
 
     describe_uri "user@host.xz:path/to/repo.git" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
-      it { subject.should_not be_equivalent('ssh://user@host.xz/path/to/repo.git') } # not absolute
-      it { subject.should_not be_equivalent('path/to/repo.git') }
-      it { subject.should_not be_equivalent('host.xz:path/to/repo.git') }
-      it { subject.should_not be_equivalent('user@host.xz:/path/to/repo.git') }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
+      it { expect(subject).to_not be_equivalent('ssh://user@host.xz/path/to/repo.git') } # not absolute
+      it { expect(subject).to_not be_equivalent('path/to/repo.git') }
+      it { expect(subject).to_not be_equivalent('host.xz:path/to/repo.git') }
+      it { expect(subject).to_not be_equivalent('user@host.xz:/path/to/repo.git') }
       it_sets expected.merge({
         :scheme            => nil,
         :inferred_scheme   => "ssh",
@@ -494,15 +490,15 @@ describe Gitable::URI do
     end
 
     describe_uri "/path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
-      it { subject.inspect.should =~ %r|^#<Gitable::URI #{@uri}>$| }
-      it { subject.should be_equivalent(@uri) }
-      it { subject.should be_equivalent('/path/to/repo.git') }
-      it { subject.should be_equivalent('file:///path/to/repo.git') }
-      it { subject.should be_equivalent('file:///path/to/repo.git/') }
-      it { subject.should_not be_equivalent('/path/to/repo/.git') }
-      it { subject.should_not be_equivalent('file:///not/path/repo.git') }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
+      it { expect(subject.inspect).to match(%r|^#<Gitable::URI #{@uri}>$|) }
+      it { expect(subject).to be_equivalent(@uri) }
+      it { expect(subject).to be_equivalent('/path/to/repo.git') }
+      it { expect(subject).to be_equivalent('file:///path/to/repo.git') }
+      it { expect(subject).to be_equivalent('file:///path/to/repo.git/') }
+      it { expect(subject).to_not be_equivalent('/path/to/repo/.git') }
+      it { expect(subject).to_not be_equivalent('file:///not/path/repo.git') }
       it_sets expected.merge({
         :scheme          => nil,
         :inferred_scheme => "file",
@@ -514,15 +510,15 @@ describe Gitable::URI do
     end
 
     describe_uri "file:///path/to/repo.git/" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
-      it { subject.inspect.should =~ %r|^#<Gitable::URI #{@uri}>$| }
-      it { subject.should be_equivalent(@uri) }
-      it { subject.should be_equivalent('/path/to/repo.git') }
-      it { subject.should be_equivalent('file:///path/to/repo.git') }
-      it { subject.should be_equivalent('/path/to/repo.git/') }
-      it { subject.should_not be_equivalent('/path/to/repo/.git') }
-      it { subject.should_not be_equivalent('file:///not/path/repo.git') }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
+      it { expect(subject.inspect).to match(%r|^#<Gitable::URI #{@uri}>$|) }
+      it { expect(subject).to be_equivalent(@uri) }
+      it { expect(subject).to be_equivalent('/path/to/repo.git') }
+      it { expect(subject).to be_equivalent('file:///path/to/repo.git') }
+      it { expect(subject).to be_equivalent('/path/to/repo.git/') }
+      it { expect(subject).to_not be_equivalent('/path/to/repo/.git') }
+      it { expect(subject).to_not be_equivalent('file:///not/path/repo.git') }
       it_sets expected.merge({
         :scheme          => "file",
         :inferred_scheme => "file",
@@ -534,16 +530,16 @@ describe Gitable::URI do
     end
 
     describe_uri "ssh://git@github.com/martinemde/gitable.git" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
-      it { subject.inspect.should =~ %r|^#<Gitable::URI #{@uri}>$| }
-      it { subject.should be_equivalent(@uri) }
-      it { subject.should be_equivalent('git://github.com/martinemde/gitable.git') }
-      it { subject.should be_equivalent('git@github.com:martinemde/gitable.git') }
-      it { subject.should be_equivalent('git@github.com:/martinemde/gitable.git') }
-      it { subject.should be_equivalent('https://martinemde@github.com/martinemde/gitable.git') }
-      it { subject.should_not be_equivalent('git@othergit.com:martinemde/gitable.git') }
-      it { subject.should_not be_equivalent('git@github.com:martinemde/not_gitable.git') }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
+      it { expect(subject.inspect).to match(%r|^#<Gitable::URI #{@uri}>$|) }
+      it { expect(subject).to be_equivalent(@uri) }
+      it { expect(subject).to be_equivalent('git://github.com/martinemde/gitable.git') }
+      it { expect(subject).to be_equivalent('git@github.com:martinemde/gitable.git') }
+      it { expect(subject).to be_equivalent('git@github.com:/martinemde/gitable.git') }
+      it { expect(subject).to be_equivalent('https://martinemde@github.com/martinemde/gitable.git') }
+      it { expect(subject).to_not be_equivalent('git@othergit.com:martinemde/gitable.git') }
+      it { expect(subject).to_not be_equivalent('git@github.com:martinemde/not_gitable.git') }
       it_sets({
         :scheme            => "ssh",
         :user              => "git",
@@ -563,16 +559,16 @@ describe Gitable::URI do
     end
 
     describe_uri "https://github.com/martinemde/gitable.git" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
-      it { subject.inspect.should =~ %r|^#<Gitable::URI #{@uri}>$| }
-      it { subject.should be_equivalent(@uri) }
-      it { subject.should be_equivalent('ssh://git@github.com/martinemde/gitable.git') }
-      it { subject.should be_equivalent('git://github.com/martinemde/gitable.git') }
-      it { subject.should be_equivalent('git@github.com:martinemde/gitable.git') }
-      it { subject.should be_equivalent('git@github.com:/martinemde/gitable.git') }
-      it { subject.should_not be_equivalent('git@othergit.com:martinemde/gitable.git') }
-      it { subject.should_not be_equivalent('git@github.com:martinemde/not_gitable.git') }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
+      it { expect(subject.inspect).to match(%r|^#<Gitable::URI #{@uri}>$|) }
+      it { expect(subject).to be_equivalent(@uri) }
+      it { expect(subject).to be_equivalent('ssh://git@github.com/martinemde/gitable.git') }
+      it { expect(subject).to be_equivalent('git://github.com/martinemde/gitable.git') }
+      it { expect(subject).to be_equivalent('git@github.com:martinemde/gitable.git') }
+      it { expect(subject).to be_equivalent('git@github.com:/martinemde/gitable.git') }
+      it { expect(subject).to_not be_equivalent('git@othergit.com:martinemde/gitable.git') }
+      it { expect(subject).to_not be_equivalent('git@github.com:martinemde/not_gitable.git') }
       it_sets({
         :scheme            => "https",
         :user              => nil,
@@ -590,17 +586,17 @@ describe Gitable::URI do
     end
 
     describe_uri "https://martinemde@github.com/martinemde/gitable.git" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
-      it { subject.inspect.should =~ %r|^#<Gitable::URI #{@uri}>$| }
-      it { subject.should be_equivalent(@uri) }
-      it { subject.should be_equivalent('ssh://git@github.com/martinemde/gitable.git') }
-      it { subject.should be_equivalent('git://github.com/martinemde/gitable.git') }
-      it { subject.should be_equivalent('git@github.com:martinemde/gitable.git') }
-      it { subject.should be_equivalent('git@github.com:/martinemde/gitable.git') }
-      it { subject.should be_equivalent('https://github.com/martinemde/gitable.git') }
-      it { subject.should_not be_equivalent('git@othergit.com:martinemde/gitable.git') }
-      it { subject.should_not be_equivalent('git@github.com:martinemde/not_gitable.git') }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
+      it { expect(subject.inspect).to match(%r|^#<Gitable::URI #{@uri}>$|) }
+      it { expect(subject).to be_equivalent(@uri) }
+      it { expect(subject).to be_equivalent('ssh://git@github.com/martinemde/gitable.git') }
+      it { expect(subject).to be_equivalent('git://github.com/martinemde/gitable.git') }
+      it { expect(subject).to be_equivalent('git@github.com:martinemde/gitable.git') }
+      it { expect(subject).to be_equivalent('git@github.com:/martinemde/gitable.git') }
+      it { expect(subject).to be_equivalent('https://github.com/martinemde/gitable.git') }
+      it { expect(subject).to_not be_equivalent('git@othergit.com:martinemde/gitable.git') }
+      it { expect(subject).to_not be_equivalent('git@github.com:martinemde/not_gitable.git') }
       it_sets({
         :scheme            => "https",
         :user              => "martinemde",
@@ -620,16 +616,16 @@ describe Gitable::URI do
     end
 
     describe_uri "git://github.com/martinemde/gitable.git" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
-      it { subject.inspect.should =~ %r|^#<Gitable::URI #{@uri}>$| }
-      it { subject.should be_equivalent(@uri) }
-      it { subject.should be_equivalent('ssh://git@github.com/martinemde/gitable.git') }
-      it { subject.should be_equivalent('git@github.com:martinemde/gitable.git') }
-      it { subject.should be_equivalent('git@github.com:/martinemde/gitable.git') }
-      it { subject.should be_equivalent('https://martinemde@github.com/martinemde/gitable.git') }
-      it { subject.should_not be_equivalent('git@othergit.com:martinemde/gitable.git') }
-      it { subject.should_not be_equivalent('git@github.com:martinemde/not_gitable.git') }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
+      it { expect(subject.inspect).to match(%r|^#<Gitable::URI #{@uri}>$|) }
+      it { expect(subject).to be_equivalent(@uri) }
+      it { expect(subject).to be_equivalent('ssh://git@github.com/martinemde/gitable.git') }
+      it { expect(subject).to be_equivalent('git@github.com:martinemde/gitable.git') }
+      it { expect(subject).to be_equivalent('git@github.com:/martinemde/gitable.git') }
+      it { expect(subject).to be_equivalent('https://martinemde@github.com/martinemde/gitable.git') }
+      it { expect(subject).to_not be_equivalent('git@othergit.com:martinemde/gitable.git') }
+      it { expect(subject).to_not be_equivalent('git@github.com:martinemde/not_gitable.git') }
       it_sets({
         :scheme            => "git",
         :user              => nil,
@@ -649,15 +645,15 @@ describe Gitable::URI do
     end
 
     describe_uri "git@github.com:martinemde/gitable.git" do
-      it { subject.to_s.should == @uri }
-      it { "#{subject}".should == @uri }
-      it { subject.inspect.should =~ %r|^#<Gitable::ScpURI #{@uri}>$| }
-      it { subject.should be_equivalent(@uri) }
-      it { subject.should be_equivalent('ssh://git@github.com/martinemde/gitable.git') }
-      it { subject.should be_equivalent('git://github.com/martinemde/gitable.git') }
-      it { subject.should be_equivalent('https://martinemde@github.com/martinemde/gitable.git') }
-      it { subject.should_not be_equivalent('git@othergit.com:martinemde/gitable.git') }
-      it { subject.should_not be_equivalent('git@github.com:martinemde/not_gitable.git') }
+      it { expect(subject.to_s).to eq(@uri) }
+      it { expect("#{subject}").to eq(@uri) }
+      it { expect(subject.inspect).to match(%r|^#<Gitable::ScpURI #{@uri}>$|) }
+      it { expect(subject).to be_equivalent(@uri) }
+      it { expect(subject).to be_equivalent('ssh://git@github.com/martinemde/gitable.git') }
+      it { expect(subject).to be_equivalent('git://github.com/martinemde/gitable.git') }
+      it { expect(subject).to be_equivalent('https://martinemde@github.com/martinemde/gitable.git') }
+      it { expect(subject).to_not be_equivalent('git@othergit.com:martinemde/gitable.git') }
+      it { expect(subject).to_not be_equivalent('git@github.com:martinemde/not_gitable.git') }
       it_sets({
         :scheme            => nil,
         :inferred_scheme   => 'ssh',

data/spec/heuristic_parse_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Gitable::URI, ".heuristic_parse" do
   it "returns a Gitable::URI" do
     uri = "http://github.com/martinemde/gitable"
-    Gitable::URI.heuristic_parse(uri).should be_a_kind_of(Gitable::URI)
+    expect(Gitable::URI.heuristic_parse(uri)).to be_a_kind_of(Gitable::URI)
   end
 
   [
@@ -16,19 +16,19 @@ describe Gitable::URI, ".heuristic_parse" do
     "git@github.com:martinemde/gitable.git",
   ].each do |uri|
     it "doesn't break the already valid URI: #{uri.inspect}" do
-      Gitable::URI.heuristic_parse(uri).to_s.should == uri
+      expect(Gitable::URI.heuristic_parse(uri).to_s).to eq(uri)
     end
   end
 
   it "guesses https://github.com/martinemde/gitable.git if I pass in the url bar" do
     uri = "https://github.com/martinemde/gitable"
     gitable = Gitable::URI.heuristic_parse(uri)
-    gitable.to_s.should == "https://github.com/martinemde/gitable.git"
+    expect(gitable.to_s).to eq("https://github.com/martinemde/gitable.git")
   end
 
   it "isn't upset by trailing slashes" do
     uri = "https://github.com/martinemde/gitable/"
     gitable = Gitable::URI.heuristic_parse(uri)
-    gitable.to_s.should == "https://github.com/martinemde/gitable.git/"
+    expect(gitable.to_s).to eq("https://github.com/martinemde/gitable.git/")
   end
 end

data/spec/spec_helper.rb

@@ -16,4 +16,7 @@ require 'describe_uri'
 
 RSpec.configure do |config|
   config.extend DescribeURI
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
 end

metadata

@@ -1,52 +1,46 @@
 --- !ruby/object:Gem::Specification
 name: gitable
 version: !ruby/object:Gem::Version
-  version: 0.2.4
-  prerelease: 
+  version: 0.3.0
 platform: ruby
 authors:
 - Martin Emde
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-01 00:00:00.000000000 Z
+date: 2013-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.2.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.2.7
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.11'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -54,7 +48,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -62,7 +55,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -70,7 +62,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -101,28 +92,28 @@ files:
 - spec/heuristic_parse_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.org/martinemde/gitable
-licenses: []
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.0.6
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Addressable::URI for Git. Gitable::URI.
 test_files:
 - spec/describe_uri.rb