ehahn-github 0.1.3

data/lib/github/command.rb

@@ -0,0 +1,87 @@
+if RUBY_PLATFORM =~ /mswin|mingw/
+  begin
+    require 'win32/open3'
+  rescue LoadError
+    warn "You must 'gem install win32-open3' to use the github command on Windows"
+    exit 1
+  end
+else
+  require 'open3'
+end
+
+module GitHub
+  class Command
+    def initialize(block)
+      (class << self;self end).send :define_method, :command, &block
+    end
+
+    def call(*args)
+      arity = method(:command).arity
+      args << nil while args.size < arity
+      send :command, *args
+    end
+    
+    def helper
+      @helper ||= Helper.new
+    end
+
+    def options
+      GitHub.options
+    end
+
+    def pgit(*command)
+      puts git(*command)
+    end
+
+    def git(*command)
+      sh ['git', command].flatten.join(' ')
+    end
+
+    def git_exec(*command)
+      cmdstr = ['git', command].flatten.join(' ')
+      GitHub.debug "exec: #{cmdstr}"
+      exec cmdstr
+    end
+
+    def sh(*command)
+      Shell.new(*command).run
+    end
+
+    def die(message)
+      puts "=> #{message}"
+      exit!
+    end
+
+    class Shell < String
+      def initialize(*command)
+        @command = command
+      end
+
+      def run
+        GitHub.debug "sh: #{command}"
+        _, out, err = Open3.popen3(*@command)
+
+        out = out.read.strip
+        err = err.read.strip
+
+        if out.any?
+          replace @out = out
+        elsif err.any?
+          replace @error = err
+        end
+      end
+
+      def command
+        @command.join(' ')
+      end
+
+      def error?
+        !!@error
+      end
+
+      def out?
+        !!@out
+      end
+    end
+  end
+end

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