gitable 0.1.3 → 0.2.0

data/Rakefile

@@ -1,17 +1,16 @@
 require 'bundler'
 Bundler::GemHelper.install_tasks
 
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new(:spec) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/**/*_spec.rb']
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = %w[--color]
+  t.pattern = 'spec/**/*_spec.rb'
 end
-
 task :default => :spec
 
-Spec::Rake::SpecTask.new(:rcov) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
-  spec.rcov_opts << '--exclude' << 'spec,vendor,Library,.bundle'
+RSpec::Core::RakeTask.new(:rcov) do |t|
+  t.rspec_opts = %w[--color]
+  t.pattern = 'spec/**/*_spec.rb'
+  t.rcov = true
+  t.rcov_opts = %w[--exclude spec/,gems/,Library/,.bundle]
 end

data/gitable.gemspec

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 Gem::Specification.new do |s|
   s.name        = "gitable"
-  s.version     = "0.1.3"
+  s.version     = "0.2.0"
   s.authors     = ["Martin Emde"]
   s.email       = ["martin.emde@gmail.com"]
   s.homepage    = "http://github.org/martinemde/gitable"
@@ -9,8 +9,9 @@ Gem::Specification.new do |s|
   s.description = %q{Addressable::URI for Git URIs with special handling for scp-style URIs that Addressable doesn't like.}
 
   s.add_dependency "addressable"
-  s.add_development_dependency "rspec"
+  s.add_development_dependency "rspec", "~>2.0"
   s.add_development_dependency "rake"
+  s.add_development_dependency "rcov"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/gitable/scp_uri.rb

@@ -2,6 +2,38 @@ 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)
+    def self.scp?(uri)
+      uri && uri.match(REGEXP) && Addressable::URI.parse(uri).normalized_host.nil?
+    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.
+    #
+    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
+    end
+
 
     # Keep URIs like this as they were input:
     #
@@ -15,8 +47,12 @@ module Gitable
     # @return [String] The same path passed in.
     def path=(new_path)
       super
-      @path = path.sub(%r|^/|,'') if new_path[0] != ?/ # addressable likes to add a /
-      @path
+      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|^/+|,'')
+        validate
+      end
+      path
     end
 
     # Get the URI as a string in the same form it was input.
@@ -27,7 +63,7 @@ module Gitable
     def to_s
       @uri_string ||=
         begin
-          uri_string = "#{authority}:#{path}"
+          uri_string = "#{normalized_authority}:#{normalized_path}"
           if uri_string.respond_to?(:force_encoding)
             uri_string.force_encoding(Encoding::UTF_8)
           end
@@ -38,28 +74,39 @@ module Gitable
     # Return the actual scheme even though we don't show it
     #
     # @return [String] always 'ssh' for scp style URIs
-    def normalized_scheme
+    def inferred_scheme
       'ssh'
     end
 
+    # Scp style URIs are always ssh
+    #
+    # @return [true] always ssh
+    def ssh?
+      true
+    end
+
     protected
 
     def validate
       return if @validation_deferred
 
-      if !scheme.to_s.empty? && host.to_s.empty? && path.to_s.empty?
-        raise InvalidURIError, "Absolute URI missing hierarchical segment: '#{to_s}'"
+      if normalized_host.to_s.empty?
+        raise InvalidURIError, "Hostname segment missing: '#{to_s}'"
       end
 
-      if host.nil? && !path_only?
-        raise InvalidURIError, "Hostname not supplied: '#{to_s}'"
+      unless normalized_scheme.to_s.empty?
+        raise InvalidURIError, "Scp style URI must not have a scheme: '#{to_s}'"
       end
 
-      nil
-    end
+      if !normalized_port.to_s.empty?
+        raise InvalidURIError, "Scp style URI cannot have a port: '#{to_s}'"
+      end
+
+      if normalized_path.to_s.empty?
+        raise InvalidURIError, "Absolute URI missing hierarchical segment: '#{to_s}'"
+      end
 
-    def path_only?
-      host.nil? && port.nil? && user.nil? && password.nil?
+      nil
     end
   end
 end

data/lib/gitable/uri.rb

@@ -2,7 +2,6 @@ require 'addressable/uri'
 
 module Gitable
   class URI < Addressable::URI
-    SCP_URI_REGEXP = %r|^([^:/?#]+):([^:?#]*)$|
 
     ##
     # Parse a git repository URI into a URI object.
@@ -20,13 +19,9 @@ module Gitable
       # addressable::URI.parse always returns an instance of Addressable::URI.
       add = super # >:( at inconsistency
 
-      authority = uri.scan(SCP_URI_REGEXP).flatten.first
-
-      if add.host.nil? && authority
-        Gitable::ScpURI.new(
-          :authority  => authority,
-          :path       => add.path
-        )
+      if Gitable::ScpURI.scp?(uri)
+        # nil host is an Addressable misunderstanding (therefore it might be scp style)
+        Gitable::ScpURI.parse(uri)
       else
         new(add.omit(:password,:query,:fragment).to_hash)
       end
@@ -50,13 +45,30 @@ module Gitable
       return uri if uri.nil? || uri.kind_of?(self)
 
       # Addressable::URI.heuristic_parse _does_ return the correct type :)
-      add = super # boo inconsistency
+      gitable = super # boo inconsistency
 
-      if add.extname != ".git"
-        add.extname = "git"
-        add.scheme = "git" if add.scheme == "http"
+      if gitable.github?
+        gitable.extname = "git"
       end
-      add
+      gitable
+    end
+
+    # Is this uri a github uri?
+    #
+    # @return [Boolean] github.com is the host?
+    def github?
+      !!normalized_host.to_s.match(/\.?github.com$/)
+    end
+
+    # Create a web uri for repositories that follow the github pattern.
+    # This probably won't work for all git hosts, so it's a good idea to use
+    # this in conjunction with #github? to help ensure correct links.
+    #
+    # @param [String] Scheme of the web uri (smart defaults)
+    # @return [Addressable::URI] https://#{host}/#{path_without_git_extension}
+    def to_web_uri(uri_scheme='https')
+      return nil if normalized_host.to_s.empty?
+      Addressable::URI.new(:scheme => uri_scheme, :host => normalized_host, :port => normalized_port, :path => normalized_path.sub(%r#\.git/?#, ''))
     end
 
     # Tries to guess the project name of the repository.
@@ -70,18 +82,32 @@ module Gitable
     #
     # @return [Boolean] Is the URI local
     def local?
-      scheme == 'file' || host.nil?
+      inferred_scheme == 'file'
+    end
+
+    # Scheme inferred by the URI (URIs without hosts or schemes are assumed to be 'file')
+    #
+    # @return [Boolean] Is the URI local
+    def inferred_scheme
+      if normalized_scheme == 'file' || (normalized_scheme.to_s.empty? && normalized_host.to_s.empty?)
+        'file'
+      else
+        normalized_scheme
+      end
     end
 
     # Detect URIs that connect over ssh
     #
     # @return [Boolean] true if the URI uses ssh?
     def ssh?
-      !!(normalized_scheme =~ /ssh/)
+      !!normalized_scheme.to_s.match(/ssh/)
     end
 
+    # Detect URIs that will require some sort of authentication
+    #
+    # @return [Boolean] true if the URI uses ssh or has a user but no password
     def authenticated?
-      ssh? || (!user.nil? && password.nil?)
+      ssh? || (!normalized_user.nil? && normalized_password.nil?)
     end
 
     # Set an extension name, replacing one if it exists.
@@ -89,20 +115,30 @@ module Gitable
     # If there is no basename (i.e. no words in the path) this method call will
     # be ignored because it is likely to break the uri.
     #
+    # Use the public method #set_git_extname unless you actually need some other ext
+    #
     # @param [String] New extension name
     # @return [String] extname result
-    def extname=(ext)
-      base = basename
-      return nil if base.nil? || base == ""
-      self.basename = "#{base}.#{ext.sub(/^\.+/,'')}"
+    def extname=(new_ext)
+      return nil if basename.to_s.empty?
+      self.basename = "#{basename.sub(%r#\.git/?$#, '')}.#{new_ext.sub(/^\.+/,'')}"
       extname
     end
 
+    # Set the '.git' extension name, replacing one if it exists.
+    #
+    # If there is no basename (i.e. no words in the path) this method call will
+    # be ignored because it is likely to break the uri.
+    #
+    # @return [String] extname result
+    def set_git_extname
+      self.extname = "git"
+    end
+
     # Addressable does basename wrong when there's no basename.
     # It returns "/" for something like "http://host.com/"
     def basename
-      base = super
-      base == "/" ? "" : base
+      super == "/" ? "" : super
     end
 
     # Set the basename, replacing it if it exists.
@@ -111,10 +147,10 @@ module Gitable
     # @return [String] basename result
     def basename=(new_basename)
       base = basename
-      if base.nil? || base == ""
+      if base.to_s.empty?
         self.path += new_basename
       else
-        rpath = path.reverse
+        rpath = normalized_path.reverse
         # replace the last occurrence of the basename with basename.ext
         self.path = rpath.sub(%r|#{Regexp.escape(base.reverse)}|, new_basename.reverse).reverse
       end
@@ -127,8 +163,8 @@ module Gitable
       return if @validation_deferred
       super
 
-      if user && scheme != 'ssh'
-        raise InvalidURIError, "Git does not support URIs with 'user@' other than ssh:// and scp-style"
+      if normalized_user && normalized_scheme != 'ssh'
+        raise InvalidURIError, "URIs with 'user@' other than ssh:// and scp-style are not supported."
       end
     end
   end

data/spec/gitable_spec.rb

@@ -1,18 +1,21 @@
 require 'spec_helper'
 
 describe Gitable::URI do
-  before do
-    @uri = "ssh://git@github.com/martinemde/gitable.git"
-  end
-
   describe_uri "git://github.com/martinemde/gitable" do
-    it "sets a new extname" do
+    it "sets the .git extname" do
       subject.extname.should == ""
-      subject.extname = "git"
+      subject.set_git_extname
       subject.extname.should == ".git"
       subject.to_s.should == @uri + ".git"
     end
 
+    it "does not duplicate the extname" do
+      subject.extname = "git"
+      subject.to_s.should == @uri + ".git"
+      subject.set_git_extname
+      subject.to_s.should == @uri + ".git"
+    end
+
     it "sets a new basename" do
       subject.basename.should == "gitable"
       subject.basename = "gitable.git"
@@ -24,7 +27,7 @@ describe Gitable::URI do
   describe_uri "git://github.com/" do
     it "does not set a new extname" do
       subject.extname.should == ""
-      subject.extname = "git"
+      subject.set_git_extname
       subject.extname.should == ""
       subject.to_s.should == @uri
     end
@@ -66,6 +69,8 @@ describe Gitable::URI do
   #
 
   describe ".parse" 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)
     end
@@ -87,8 +92,11 @@ describe Gitable::URI do
 
     context "(bad uris)" do
       [
-        "http://",
-        "blah:",
+        "http://", # nothing but scheme
+        "blah:", # pretty much nothing
+        "http://user@example.com/path.git", # unsupported http with user part
+        "user@:path.git", # no host
+        "user@host:", # no path
       ].each do |uri|
         it "raises an Gitable::URI::InvalidURIError with #{uri.inspect}" do
           lambda {
@@ -96,6 +104,38 @@ describe Gitable::URI do
           }.should raise_error(Gitable::URI::InvalidURIError)
         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 {
+            Gitable::ScpURI.new(:user => 'git', :host => 'github.com')
+          }.should raise_error(Gitable::URI::InvalidURIError)
+        end
+
+        it "raises without host" do
+          lambda {
+            Gitable::ScpURI.new(:user => 'git', :path => 'path')
+          }.should raise_error(Gitable::URI::InvalidURIError)
+        end
+
+        it "raises with any scheme" do
+          lambda {
+            Gitable::ScpURI.new(:scheme => 'ssh', :host => 'github.com', :path => 'path')
+          }.should raise_error(Gitable::URI::InvalidURIError)
+        end
+
+        it "raises with any port" do
+          lambda {
+            Gitable::ScpURI.new(:port => 88, :host => 'github.com', :path => 'path')
+          }.should raise_error(Gitable::URI::InvalidURIError)
+        end
+      end
     end
 
     expected = {
@@ -111,6 +151,7 @@ describe Gitable::URI do
       :local?         => false,
       :ssh?           => false,
       :authenticated? => false,
+      :to_web_uri     => Addressable::URI.parse("https://host.xz/path/to/repo"),
     }
 
     describe_uri "rsync://host.xz/path/to/repo.git/" do
@@ -138,17 +179,19 @@ describe Gitable::URI do
     describe_uri "http://host.xz:8888/path/to/repo.git/" do
       it { subject.to_s.should == @uri }
       it_sets expected.merge({
-        :scheme   => "http",
-        :port     => 8888,
+        :scheme         => "http",
+        :port           => 8888,
+        :to_web_uri     => Addressable::URI.parse("https://host.xz:8888/path/to/repo")
       })
     end
 
     describe_uri "http://12.34.56.78:8888/path/to/repo.git/" do
       it { subject.to_s.should == @uri }
       it_sets expected.merge({
-        :scheme   => "http",
-        :host     => "12.34.56.78",
-        :port     => 8888,
+        :scheme         => "http",
+        :host           => "12.34.56.78",
+        :port           => 8888,
+        :to_web_uri     => Addressable::URI.parse("https://12.34.56.78:8888/path/to/repo")
       })
     end
 
@@ -162,8 +205,9 @@ describe Gitable::URI do
     describe_uri "https://host.xz:8888/path/to/repo.git/" do
       it { subject.to_s.should == @uri }
       it_sets expected.merge({
-        :scheme   => "https",
-        :port     => 8888,
+        :scheme         => "https",
+        :port           => 8888,
+        :to_web_uri     => Addressable::URI.parse("https://host.xz:8888/path/to/repo")
       })
     end
 
@@ -186,25 +230,28 @@ describe Gitable::URI do
     describe_uri "git://host.xz:8888/path/to/repo.git/" do
       it { subject.to_s.should == @uri }
       it_sets expected.merge({
-        :scheme   => "git",
-        :port     => 8888,
+        :scheme         => "git",
+        :port           => 8888,
+        :to_web_uri     => Addressable::URI.parse("https://host.xz:8888/path/to/repo")
       })
     end
 
     describe_uri "git://host.xz/~user/path/to/repo.git/" do
       it { subject.to_s.should == @uri }
       it_sets expected.merge({
-        :scheme   => "git",
-        :path     => "/~user/path/to/repo.git/",
+        :scheme         => "git",
+        :path           => "/~user/path/to/repo.git/",
+        :to_web_uri     => Addressable::URI.parse("https://host.xz/~user/path/to/repo")
       })
     end
 
     describe_uri "git://host.xz:8888/~user/path/to/repo.git/" do
       it { subject.to_s.should == @uri }
       it_sets expected.merge({
-        :scheme   => "git",
-        :path     => "/~user/path/to/repo.git/",
-        :port     => 8888,
+        :scheme         => "git",
+        :path           => "/~user/path/to/repo.git/",
+        :port           => 8888,
+        :to_web_uri     => Addressable::URI.parse("https://host.xz:8888/~user/path/to/repo")
       })
     end
 
@@ -243,6 +290,7 @@ describe Gitable::URI do
         :port           => 8888,
         :ssh?           => true,
         :authenticated? => true,
+        :to_web_uri     => Addressable::URI.parse("https://host.xz:8888/path/to/repo")
       })
     end
 
@@ -264,6 +312,7 @@ describe Gitable::URI do
         :port           => 8888,
         :ssh?           => true,
         :authenticated? => true,
+        :to_web_uri     => Addressable::URI.parse("https://host.xz:8888/path/to/repo")
       })
     end
 
@@ -275,6 +324,7 @@ describe Gitable::URI do
         :path           => "/~user/path/to/repo.git/",
         :ssh?           => true,
         :authenticated? => true,
+        :to_web_uri     => Addressable::URI.parse("https://host.xz/~user/path/to/repo")
       })
     end
 
@@ -286,6 +336,7 @@ describe Gitable::URI do
         :path           => "/~user/path/to/repo.git/",
         :ssh?           => true,
         :authenticated? => true,
+        :to_web_uri     => Addressable::URI.parse("https://host.xz/~user/path/to/repo")
       })
     end
 
@@ -296,6 +347,7 @@ describe Gitable::URI do
         :path           => "/~/path/to/repo.git",
         :ssh?           => true,
         :authenticated? => true,
+        :to_web_uri     => Addressable::URI.parse("https://host.xz/~/path/to/repo")
       })
     end
 
@@ -307,6 +359,7 @@ describe Gitable::URI do
         :path           => "/~/path/to/repo.git",
         :ssh?           => true,
         :authenticated? => true,
+        :to_web_uri     => Addressable::URI.parse("https://host.xz/~/path/to/repo")
       })
     end
 
@@ -314,7 +367,7 @@ describe Gitable::URI do
       it { subject.to_s.should == @uri }
       it_sets expected.merge({
         :scheme            => nil,
-        :normalized_scheme => 'ssh',
+        :inferred_scheme   => 'ssh',
         :user              => nil,
         :path              => "/path/to/repo.git/",
         :ssh?              => true,
@@ -326,7 +379,7 @@ describe Gitable::URI do
       it { subject.to_s.should == @uri }
       it_sets expected.merge({
         :scheme            => nil,
-        :normalized_scheme => 'ssh',
+        :inferred_scheme   => 'ssh',
         :user              => "user",
         :path              => "/path/to/repo.git/",
         :ssh?              => true,
@@ -338,11 +391,12 @@ describe Gitable::URI do
       it { subject.to_s.should == @uri }
       it_sets expected.merge({
         :scheme            => nil,
-        :normalized_scheme => 'ssh',
+        :inferred_scheme   => 'ssh',
         :user              => nil,
         :path              => "~user/path/to/repo.git/",
         :ssh?              => true,
         :authenticated?    => true,
+        :to_web_uri        => Addressable::URI.parse("https://host.xz/~user/path/to/repo")
       })
     end
 
@@ -350,11 +404,12 @@ describe Gitable::URI do
       it { subject.to_s.should == @uri }
       it_sets expected.merge({
         :scheme            => nil,
-        :normalized_scheme => 'ssh',
+        :inferred_scheme   => 'ssh',
         :user              => "user",
         :path              => "~user/path/to/repo.git/",
         :ssh?              => true,
         :authenticated?    => true,
+        :to_web_uri        => Addressable::URI.parse("https://host.xz/~user/path/to/repo")
       })
     end
 
@@ -362,7 +417,7 @@ describe Gitable::URI do
       it { subject.to_s.should == @uri }
       it_sets expected.merge({
         :scheme            => nil,
-        :normalized_scheme => 'ssh',
+        :inferred_scheme   => 'ssh',
         :user              => nil,
         :path              => "path/to/repo.git",
         :ssh?              => true,
@@ -374,7 +429,7 @@ describe Gitable::URI do
       it { subject.to_s.should == @uri }
       it_sets expected.merge({
         :scheme            => nil,
-        :normalized_scheme => 'ssh',
+        :inferred_scheme   => "ssh",
         :user              => "user",
         :path              => "path/to/repo.git",
         :ssh?              => true,
@@ -385,64 +440,74 @@ describe Gitable::URI do
     describe_uri "/path/to/repo.git/" do
       it { subject.to_s.should == @uri }
       it_sets expected.merge({
-        :scheme   => nil,
-        :host     => nil,
-        :path     => "/path/to/repo.git/",
-        :local?   => true,
+        :scheme          => nil,
+        :inferred_scheme => "file",
+        :host            => nil,
+        :path            => "/path/to/repo.git/",
+        :local?          => true,
+        :to_web_uri      => nil,
       })
     end
 
     describe_uri "file:///path/to/repo.git/" do
       it { subject.to_s.should == @uri }
       it_sets expected.merge({
-        :scheme   => "file",
-        :host     => "", # I don't really like this but it doesn't hurt anything.
-        :path     => "/path/to/repo.git/",
-        :local?   => true,
+        :scheme          => "file",
+        :inferred_scheme => "file",
+        :host            => "",
+        :path            => "/path/to/repo.git/",
+        :local?          => true,
+        :to_web_uri      => nil,
       })
     end
 
     describe_uri "ssh://git@github.com/martinemde/gitable.git" do
       it { subject.to_s.should == @uri }
       it_sets({
-        :scheme         => "ssh",
-        :user           => "git",
-        :password       => nil,
-        :host           => "github.com",
-        :port           => nil,
-        :path           => "/martinemde/gitable.git",
-        :fragment       => nil,
-        :basename       => "gitable.git",
-        :ssh?           => true,
-        :authenticated? => true,
+        :scheme            => "ssh",
+        :user              => "git",
+        :password          => nil,
+        :host              => "github.com",
+        :port              => nil,
+        :path              => "/martinemde/gitable.git",
+        :fragment          => nil,
+        :basename          => "gitable.git",
+        :ssh?              => true,
+        :authenticated?    => true,
+        :github?           => true,
+        :to_web_uri        => Addressable::URI.parse("https://github.com/martinemde/gitable"),
       })
     end
 
-    describe_uri "http://github.com/martinemde/gitable.git" do
+    describe_uri "https://github.com/martinemde/gitable.git" do
       it { subject.to_s.should == @uri }
       it_sets({
-        :scheme   => "http",
-        :user     => nil,
-        :password => nil,
-        :host     => "github.com",
-        :port     => nil,
-        :path     => "/martinemde/gitable.git",
-        :fragment => nil,
-        :basename => "gitable.git",
+        :scheme            => "https",
+        :user              => nil,
+        :password          => nil,
+        :host              => "github.com",
+        :port              => nil,
+        :path              => "/martinemde/gitable.git",
+        :fragment          => nil,
+        :basename          => "gitable.git",
+        :github?           => true,
+        :to_web_uri        => Addressable::URI.parse("https://github.com/martinemde/gitable"),
       })
     end
 
     describe_uri "git://github.com/martinemde/gitable.git" do
       it { subject.to_s.should == @uri }
       it_sets({
-        :scheme   => "git",
-        :user     => nil,
-        :password => nil,
-        :host     => "github.com",
-        :port     => nil,
-        :path     => "/martinemde/gitable.git",
-        :fragment => nil,
-        :basename => "gitable.git",
+        :scheme            => "git",
+        :user              => nil,
+        :password          => nil,
+        :host              => "github.com",
+        :port              => nil,
+        :path              => "/martinemde/gitable.git",
+        :fragment          => nil,
+        :basename          => "gitable.git",
+        :github?           => true,
+        :to_web_uri        => Addressable::URI.parse("https://github.com/martinemde/gitable"),
       })
     end
 
@@ -450,7 +515,7 @@ describe Gitable::URI do
       it { subject.to_s.should == @uri }
       it_sets({
         :scheme            => nil,
-        :normalized_scheme => 'ssh',
+        :inferred_scheme   => 'ssh',
         :user              => "git",
         :password          => nil,
         :host              => "github.com",
@@ -461,6 +526,8 @@ describe Gitable::URI do
         :project_name      => "gitable",
         :ssh?              => true,
         :authenticated?    => true,
+        :github?           => true,
+        :to_web_uri        => Addressable::URI.parse("https://github.com/martinemde/gitable"),
       })
     end
   end

data/spec/heuristic_parse_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'spec_helper'
 
 describe Gitable::URI, ".heuristic_parse" do
   it "returns a Gitable::URI" do
@@ -20,21 +20,15 @@ describe Gitable::URI, ".heuristic_parse" do
     end
   end
 
-  it "guesses git://github.com/martinemde/gitable.git if I pass in the url bar" do
-    uri = "http://github.com/martinemde/gitable"
+  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 == "git://github.com/martinemde/gitable.git"
+    gitable.to_s.should == "https://github.com/martinemde/gitable.git"
   end
 
   it "isn't upset by trailing slashes" do
-    uri = "http://github.com/martinemde/gitable/"
-    gitable = Gitable::URI.heuristic_parse(uri)
-    gitable.to_s.should == "git://github.com/martinemde/gitable.git/"
-  end
-
-  it "handles URIs with the name of the project in the path twice" do
-    uri = "http://gitorious.org/project/project"
+    uri = "https://github.com/martinemde/gitable/"
     gitable = Gitable::URI.heuristic_parse(uri)
-    gitable.to_s.should == "git://gitorious.org/project/project.git"
+    gitable.to_s.should == "https://github.com/martinemde/gitable.git/"
   end
 end

data/spec/spec_helper.rb

@@ -1,16 +1,14 @@
 unless defined? Bundler
   require 'rubygems'
   require 'bundler'
-  Bundler.setup
 end
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'gitable'
-require 'spec'
-require 'spec/autorun'
+require 'rspec'
 require 'describe_uri'
 
-Spec::Runner.configure do |config|
+RSpec.configure do |config|
   config.extend DescribeURI
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: gitable
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 23
   prerelease: 
   segments: 
   - 0
-  - 1
-  - 3
-  version: 0.1.3
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Martin Emde
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-16 00:00:00 -08:00
+date: 2011-02-18 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -38,12 +38,13 @@ dependencies:
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
         hash: 3
         segments: 
+        - 2
         - 0
-        version: "0"
+        version: "2.0"
   type: :development
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -60,6 +61,20 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
 description: Addressable::URI for Git URIs with special handling for scp-style URIs that Addressable doesn't like.
 email: 
 - martin.emde@gmail.com
@@ -84,7 +99,6 @@ files:
 - spec/describe_uri.rb
 - spec/gitable_spec.rb
 - spec/heuristic_parse_spec.rb
-- spec/spec.opts
 - spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.org/martinemde/gitable
@@ -124,5 +138,4 @@ test_files:
 - spec/describe_uri.rb
 - spec/gitable_spec.rb
 - spec/heuristic_parse_spec.rb
-- spec/spec.opts
 - spec/spec_helper.rb

data/spec/spec.opts

@@ -1 +0,0 @@
---color