topfunky-github 0.1.3

data/lib/github/extensions.rb

@@ -0,0 +1,28 @@
+# define #try
+class Object
+  def try
+    self
+  end
+end
+
+class NilClass
+  klass = Class.new
+  klass.class_eval do
+    instance_methods.each { |meth| undef_method meth.to_sym unless meth =~ /^__(id|send)__$/ }
+    def method_missing(*args)
+      self
+    end
+  end
+  NilProxy = klass.new
+  def try
+    NilProxy
+  end
+end
+
+# define #tap
+class Object
+  def tap(&block)
+    block.call(self)
+    self
+  end
+end

data/lib/github/helper.rb

@@ -0,0 +1,4 @@
+module GitHub
+  class Helper
+  end
+end

data/spec/command_spec.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe GitHub::Command do
+  before(:each) do
+    @command = GitHub::Command.new(proc { |x| puts x })
+  end
+
+  it "should return a GitHub::Helper" do
+    @command.helper.should be_instance_of(GitHub::Helper)
+  end
+
+  it "should call successfully" do
+    @command.should_receive(:puts).with("test").once
+    @command.call("test")
+  end
+
+  it "should return options" do
+    GitHub.should_receive(:options).with().once.and_return({:ssh => true})
+    @command.options.should == {:ssh => true}
+  end
+
+  it "should successfully call out to the shell" do
+    unguard(Kernel, :fork)
+    unguard(Kernel, :exec)
+    hi = @command.sh("echo hi")
+    hi.should == "hi"
+    hi.out?.should be(true)
+    hi.error?.should be(false)
+    hi.command.should == "echo hi"
+    bye = @command.sh("echo bye >&2")
+    bye.should == "bye"
+    bye.out?.should be(false)
+    bye.error?.should be(true)
+    bye.command.should == "echo bye >&2"
+  end
+
+  it "should return the results of a git operation" do
+    GitHub::Command::Shell.should_receive(:new).with("git rev-parse master").once.and_return do |*cmds|
+      s = mock("GitHub::Commands::Shell")
+      s.should_receive(:run).once.and_return("sha1")
+      s
+    end
+    @command.git("rev-parse master").should == "sha1"
+  end
+
+  it "should print the results of a git operation" do
+    @command.should_receive(:puts).with("sha1").once
+    GitHub::Command::Shell.should_receive(:new).with("git rev-parse master").once.and_return do |*cmds|
+      s = mock("GitHub::Commands::Shell")
+      s.should_receive(:run).once.and_return("sha1")
+      s
+    end
+    @command.pgit("rev-parse master")
+  end
+
+  it "should exec a git command" do
+    @command.should_receive(:exec).with("git rev-parse master").once
+    @command.git_exec "rev-parse master"
+  end
+
+  it "should die" do
+    @command.should_receive(:puts).once.with("=> message")
+    @command.should_receive(:exit!).once
+    @command.die "message"
+  end
+end

data/spec/extensions_spec.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe "When calling #try" do
+  specify "objects should return themselves" do
+    obj = 1; obj.try.should equal(obj)
+    obj = "foo"; obj.try.should equal(obj)
+    obj = { :foo => "bar" }; obj.try.should equal(obj)
+  end
+
+  specify "objects should behave as if #try wasn't called" do
+    "foo".try.size.should == 3
+    { :foo => :bar }.try.fetch(:foo).should == :bar
+    [1, 2, 3].try.map { |x| x + 1 }.should == [2, 3, 4]
+  end
+
+  specify "nil should return the singleton NilClass::NilProxy" do
+    nil.try.should equal(NilClass::NilProxy)
+  end
+
+  specify "nil should ignore any calls made past #try" do
+    nil.try.size.should equal(NilClass::NilProxy)
+    nil.try.sdlfj.should equal(NilClass::NilProxy)
+    nil.try.one.two.three.should equal(NilClass::NilProxy)
+  end
+
+  specify "classes should respond just like objects" do
+    String.try.should equal(String)
+  end
+end
+
+describe "When calling #tap" do
+  specify "objects should behave like Ruby 1.9's #tap" do
+    obj = "foo"
+    obj.tap { |obj| obj.size.should == 3 }.should equal(obj)
+  end
+end

data/spec/github_spec.rb

@@ -0,0 +1,65 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "GitHub.parse_options" do
+  it "should parse --bare options" do
+    args = ["--bare", "--test"]
+    GitHub.parse_options(args).should == {:bare => true, :test => true}
+    args.should == []
+  end
+
+  it "should parse options intermixed with non-options" do
+    args = ["text", "--bare", "more text", "--option", "--foo"]
+    GitHub.parse_options(args).should == {:bare => true, :option => true, :foo => true}
+    args.should == ["text", "more text"]
+  end
+
+  it "should parse --foo=bar style options" do
+    args = ["--foo=bar", "--bare"]
+    GitHub.parse_options(args).should == {:bare => true, :foo => "bar"}
+    args.should == []
+  end
+
+  it "should stop parsing options at --" do
+    args = ["text", "--bare", "--", "--foo"]
+    GitHub.parse_options(args).should == {:bare => true}
+    args.should == ["text", "--foo"]
+  end
+
+  it "should handle duplicate options" do
+    args = ["text", "--foo=bar", "--bare", "--foo=baz"]
+    GitHub.parse_options(args).should == {:foo => "baz", :bare => true}
+    args.should == ["text"]
+  end
+
+  it "should handle duplicate --bare options surrounding --" do
+    args = ["text", "--bare", "--", "--bare"]
+    GitHub.parse_options(args).should == {:bare => true}
+    args.should == ["text", "--bare"]
+  end
+
+  it "should handle no options" do
+    args = ["text", "more text"]
+    GitHub.parse_options(args).should == {}
+    args.should == ["text", "more text"]
+  end
+
+  it "should handle no args" do
+    args = []
+    GitHub.parse_options(args).should == {}
+    args.should == []
+  end
+
+  it "should not set up debugging when --debug not passed" do
+    GitHub.stub!(:load)
+    GitHub.stub!(:invoke)
+    GitHub.activate(['default'])
+    GitHub.should_not be_debug
+  end
+
+  it "should set up debugging when passed --debug" do
+    GitHub.stub!(:load)
+    GitHub.stub!(:invoke)
+    GitHub.activate(['default', '--debug'])
+    GitHub.should be_debug
+  end
+end

data/spec/helper_spec.rb

@@ -0,0 +1,212 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class HelperRunner
+  def initialize(parent, name)
+    @parent = parent
+    @name = name
+  end
+
+  def run(&block)
+    self.instance_eval(&block)
+  end
+
+  def it(str, &block)
+    @parent.send :it, "#{@name} #{str}", &block
+  end
+  alias specify it
+end
+
+describe GitHub::Helper do
+  include SetupMethods
+
+  def self.helper(name, &block)
+    HelperRunner.new(self, name).run(&block)
+  end
+
+  before(:each) do
+    @helper = GitHub::Helper.new
+  end
+
+  helper :owner do
+    it "should return repo owner" do
+      setup_url_for :origin, "hacker"
+      @helper.owner.should == "hacker"
+    end
+  end
+
+  helper :private_url_for do
+    it "should return an ssh-style url" do
+      setup_url_for :origin, "user", "merb-core"
+      @helper.private_url_for("wycats").should == "git@github.com:wycats/merb-core.git"
+    end
+  end
+
+  helper :private_url_for_user_and_repo do
+    it "should return an ssh-style url" do
+      @helper.should_not_receive(:project)
+      @helper.private_url_for_user_and_repo("defunkt", "github-gem").should == "git@github.com:defunkt/github-gem.git"
+    end
+  end
+
+  helper :public_url_for do
+    it "should return a git:// URL" do
+      setup_url_for :origin, "user", "merb-core"
+      @helper.public_url_for("wycats").should == "git://github.com/wycats/merb-core.git"
+    end
+  end
+
+  helper :public_url_for_user_and_repo do
+    it "should return a git:// URL" do
+      @helper.should_not_receive(:project)
+      @helper.public_url_for_user_and_repo("defunkt", "github-gem").should == "git://github.com/defunkt/github-gem.git"
+    end
+  end
+
+  helper :project do
+    it "should return project-awesome" do
+      setup_url_for :origin, "user", "project-awesome"
+      @helper.project.should == "project-awesome"
+    end
+
+    it "should exit due to missing origin" do
+      @helper.should_receive(:url_for).twice.with(:origin).and_return("")
+      STDERR.should_receive(:puts).with("Error: missing remote 'origin'")
+      lambda { @helper.project }.should raise_error(SystemExit)
+    end
+
+    it "should exit due to non-github origin" do
+      @helper.should_receive(:url_for).twice.with(:origin).and_return("home:path/to/repo.git")
+      STDERR.should_receive(:puts).with("Error: remote 'origin' is not a github URL")
+      lambda { @helper.project }.should raise_error(SystemExit)
+    end
+  end
+
+  helper :repo_for do
+    it "should return mephisto.git" do
+      setup_url_for :mojombo, "mojombo", "mephisto"
+      @helper.repo_for(:mojombo).should == "mephisto.git"
+    end
+  end
+
+  helper :user_and_repo_from do
+    it "should parse a git:// url" do
+      @helper.user_and_repo_from("git://github.com/defunkt/github.git").should == ["defunkt", "github.git"]
+    end
+
+    it "should parse a ssh-based url" do
+      @helper.user_and_repo_from("git@github.com:mojombo/god.git").should == ["mojombo", "god.git"]
+    end
+
+    it "should parse a non-standard ssh-based url" do
+      @helper.user_and_repo_from("ssh://git@github.com:mojombo/god.git").should == ["mojombo", "god.git"]
+      @helper.user_and_repo_from("github.com:mojombo/god.git").should == ["mojombo", "god.git"]
+      @helper.user_and_repo_from("ssh://github.com:mojombo/god.git").should == ["mojombo", "god.git"]
+    end
+
+    it "should return nothing for other urls" do
+      @helper.user_and_repo_from("home:path/to/repo.git").should == nil
+    end
+
+    it "should return nothing for invalid git:// urls" do
+      @helper.user_and_repo_from("git://github.com/foo").should == nil
+    end
+
+    it "should return nothing for invalid ssh-based urls" do
+      @helper.user_and_repo_from("git@github.com:kballard").should == nil
+      @helper.user_and_repo_from("git@github.com:kballard/test/repo.git").should == nil
+      @helper.user_and_repo_from("ssh://git@github.com:kballard").should == nil
+      @helper.user_and_repo_from("github.com:kballard").should == nil
+      @helper.user_and_repo_from("ssh://github.com:kballard").should == nil
+    end
+  end
+
+  helper :user_for do
+    it "should return defunkt" do
+      setup_url_for :origin, "defunkt"
+      @helper.user_for(:origin).should == "defunkt"
+    end
+  end
+
+  helper :url_for do
+    it "should call out to the shell" do
+      @helper.should_receive(:`).with("git config --get remote.origin.url").and_return "git://github.com/user/project.git\n"
+      @helper.url_for(:origin).should == "git://github.com/user/project.git"
+    end
+  end
+
+  helper :remotes do
+    it "should return a list of remotes" do
+      @helper.should_receive(:`).with('git config --get-regexp \'^remote\.(.+)\.url$\'').and_return <<-EOF
+remote.origin.url git@github.com:kballard/github-gem.git
+remote.defunkt.url git://github.com/defunkt/github-gem.git
+remote.nex3.url git://github.com/nex3/github-gem.git
+      EOF
+      @helper.remotes.should == {
+        :origin => "git@github.com:kballard/github-gem.git",
+        :defunkt => "git://github.com/defunkt/github-gem.git",
+        :nex3 => "git://github.com/nex3/github-gem.git"
+      }
+    end
+  end
+
+  helper :tracking do
+    it "should return a list of remote/user_or_url pairs" do
+      @helper.should_receive(:remotes).and_return({
+        :origin => "git@github.com:kballard/github-gem.git",
+        :defunkt => "git://github.com/defunkt/github-gem.git",
+        :external => "server:path/to/github-gem.git"
+      })
+      @helper.tracking.should == {
+        :origin => "kballard",
+        :defunkt => "defunkt",
+        :external => "server:path/to/github-gem.git"
+      }
+    end
+  end
+
+  helper :tracking? do
+    it "should return whether the user is tracked" do
+      @helper.should_receive(:tracking).any_number_of_times.and_return({
+        :origin => "kballard",
+        :defunkt => "defunkt",
+        :external => "server:path/to/github-gem.git"
+      })
+      @helper.tracking?("kballard").should == true
+      @helper.tracking?("defunkt").should == true
+      @helper.tracking?("nex3").should == false
+    end
+  end
+
+  helper :user_and_branch do
+    it "should return owner and branch for unqualified branches" do
+      setup_url_for
+      @helper.should_receive(:`).with("git rev-parse --symbolic-full-name HEAD").and_return "refs/heads/master"
+      @helper.user_and_branch.should == ["user", "master"]
+    end
+
+    it "should return user and branch for user/branch-style branches" do
+      @helper.should_receive(:`).with("git rev-parse --symbolic-full-name HEAD").and_return "refs/heads/defunkt/wip"
+      @helper.user_and_branch.should == ["defunkt", "wip"]
+    end
+  end
+
+  helper :open do
+    it "should launch the URL when Launchy is installed" do
+      begin
+        require 'launchy'
+        @helper.should_receive(:gem).with('launchy')
+        # @helper.should_receive(:has_launchy?).and_return { |blk| blk.call }
+        Launchy::Browser.next_instance.should_receive(:visit).with("http://www.google.com")
+        @helper.open "http://www.google.com"
+      rescue LoadError
+        fail "Launchy is required for this spec"
+      end
+    end
+
+    it "should fail when Launchy is not installed" do
+      @helper.should_receive(:gem).with('launchy').and_raise(Gem::LoadError)
+      STDERR.should_receive(:puts).with("Sorry, you need to install launchy: `gem install launchy`")
+      @helper.open "http://www.google.com"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,138 @@
+require 'rubygems'
+require 'spec'
+
+require File.dirname(__FILE__) + '/../lib/github'
+
+class Module
+  def metaclass
+    class << self;self;end
+  end
+end
+
+class Spec::NextInstanceProxy
+  def initialize
+    @deferred = []
+  end
+
+  def method_missing(sym, *args)
+    proxy = Spec::NextInstanceProxy.new
+    @deferred << [sym, args, proxy]
+    proxy
+  end
+
+  def should_receive(*args)
+    method_missing(:should_receive, *args)
+  end
+  alias stub! should_receive
+
+  def invoke(obj)
+    @deferred.each do |(sym, args, proxy)|
+      result = obj.send(sym, *args)
+      proxy.invoke(result)
+    end
+  end
+end
+
+class Class
+  def next_instance
+    meth = metaclass.instance_method(:new)
+    proxy = Spec::NextInstanceProxy.new
+    metaclass.send :define_method, :new do |*args|
+      instance = meth.bind(self).call(*args)
+      proxy.invoke(instance)
+      metaclass.send :define_method, :new, meth
+      instance
+    end
+    proxy
+  end
+end
+
+module Spec::Example::ExampleGroupSubclassMethods
+  def add_guard(klass, name, is_class = false)
+    guarded = nil # define variable now for scoping
+    target = (is_class ? klass.metaclass : klass)
+    sep = (is_class ? "." : "#")
+    target.class_eval do
+      guarded = instance_method(name)
+      define_method name do |*args|
+        raise "Testing guards violated: Cannot call #{klass}#{sep}#{name}"
+      end
+    end
+    @guards ||= []
+    @guards << [klass, name, is_class, guarded]
+  end
+
+  def add_class_guard(klass, name)
+    add_guard(klass, name, true)
+  end
+
+  def unguard(klass, name, is_class = false)
+    row = @guards.find { |(k,n,i)| k == klass and n == name and i == is_class }
+    raise "#{klass}#{is_class ? "." : "#"}#{name} is not guarded" if row.nil?
+    (is_class ? klass.metaclass : klass).class_eval do
+      define_method name, row.last
+    end
+    @guards.delete row
+  end
+
+  def class_unguard(klass, name)
+    unguard(klass, name, true)
+  end
+
+  def unguard_all
+    @guards ||= []
+    @guards.each do |klass, name, is_class, guarded|
+      (is_class ? klass.metaclass : klass).class_eval do
+        define_method name, guarded
+      end
+    end
+    @guards.clear
+  end
+end
+
+# prevent the use of `` in tests
+Spec::Runner.configure do |configuration|
+  # load this here so it's covered by the `` guard
+  configuration.prepend_before(:all) do
+    module GitHub
+      load 'helpers.rb'
+      load 'commands.rb'
+    end
+  end
+
+  configuration.prepend_after(:each) do
+    GitHub.instance_variable_set :'@options', nil
+    GitHub.instance_variable_set :'@debug', nil
+  end
+
+  configuration.prepend_before(:all) do
+    self.class.send :include, Spec::Example::ExampleGroupSubclassMethods
+  end
+
+  configuration.prepend_before(:each) do
+    add_guard Kernel, :`
+    add_guard Kernel, :system
+    add_guard Kernel, :fork
+    add_guard Kernel, :exec
+    add_class_guard Process, :fork
+  end
+
+  configuration.append_after(:each) do
+    unguard_all
+  end
+end
+
+# include this in any example group that defines @helper
+module SetupMethods
+  def setup_user_and_branch(user = :user, branch = :master)
+    @helper.should_receive(:user_and_branch).any_number_of_times.and_return([user, branch])
+  end
+
+  def setup_url_for(remote = :origin, user = nil, project = :project)
+    if user.nil?
+      user = remote
+      user = "user" if remote == :origin
+    end
+    @helper.should_receive(:url_for).any_number_of_times.with(remote).and_return("git://github.com/#{user}/#{project}.git")
+  end
+end