riquedafreak-github 0.1.3 → 0.1.4

data/README

@@ -17,7 +17,7 @@ Run it:
 
 
 =============
-Pulling Changes
+Pulling Upstream Changes
 =============
 
 Let's say you just forked `github-gem` on GitHub from defunkt.
@@ -44,6 +44,40 @@ master branch, use the `merge` flag:
 
   $ github pull --merge defunkt
 
+
+==========
+Fetching and Evaluation Downstream Changes
+==========
+
+If you are the maintainer of a project, you will often need to fetch commits
+from other developers, evaluate and/or test them, then merge them into the
+project.
+
+Let's say you are 'defunkt' and 'mojombo' has forked your 'github-gem' repo,
+made some changes and issues you a pull request for his 'master' branch.
+
+From the root of the project, you can do:
+
+  $ github fetch mojombo master
+  
+This will leave you in the 'mojombo/master' branch after fetching his commits.
+Your local 'mojombo/master' branch is now at the exact same place as mojombo's 
+'master' branch. You can now run tests or evaluate the code for awesomeness.
+
+If mojombo's changes are good, you'll want to merge your 'master' (or another
+branch) into those changes so you can retest post-integration:
+
+  $ git merge master
+  
+Test/analyze again and if everything is ok:
+  
+  $ git checkout master
+  $ git merge mojombo/master
+  
+The latter command will be a fast-forward merge since you already did the
+real merge previously.
+
+
 ==========
 Contributors
 ==========
@@ -52,3 +86,4 @@ Contributors
 - maddox
 - halorgium
 - kballard
+- mojombo

data/commands/commands.rb

@@ -61,6 +61,22 @@ command :track do |remote, user|
   end
 end
 
+desc "Fetch from a remote to a local branch."
+command :fetch do |user, branch|
+  die "Specify a user to pull from" if user.nil?
+  user, branch = user.split("/", 2) if branch.nil?
+  branch ||= 'master'
+  GitHub.invoke(:track, user) unless helper.tracking?(user)
+  
+  die "Unknown branch (#{branch}) specified" unless helper.remote_branch?(user, branch)
+  die "Unable to switch branches, your current branch has uncommitted changes" if helper.branch_dirty?
+
+  puts "Fetching #{user}/#{branch}"
+  git "fetch #{user} #{branch}:refs/remotes/#{user}/#{branch}"
+  git "update-ref refs/heads/#{user}/#{branch} refs/remotes/#{user}/#{branch}"
+  git_exec "checkout #{user}/#{branch}"
+end
+
 desc "Pull from a remote."
 flags :merge => "Automatically merge remote's changes into your master."
 command :pull do |user, branch|
@@ -68,28 +84,15 @@ command :pull do |user, branch|
   user, branch = user.split("/", 2) if branch.nil?
   branch ||= 'master'
   GitHub.invoke(:track, user) unless helper.tracking?(user)
-  
-  # check to see if the branch even exists on the remote user
-  die "Unknown branch (#{branch}) specified" if !helper.heads?(user, branch)
-  
-  # if the merge option was specified then don't switch to a new branch
-  if !options[:merge]
-    puts "Switching to #{user}/#{branch}"
 
-    if helper.heads?(".", "#{user}/#{branch}")
-      # if the remote branch is already locally tracked then switch to it
-      die "Unable to checkout branch (#{branch})" if git("checkout #{user}/#{branch}").error?
-    else
-      # if the remote branch is not already locally tracked, then fetch it 
-      git_exec "fetch #{user} +#{branch}:#{user}/#{branch}"
-      die "Unable to checkout branch (#{branch})" if git("checkout #{user}/#{branch}").error?
-      return
-    end
-  else
-    puts "Merging from contents of #{user}/#{branch}"
+  die "Unknown branch (#{branch}) specified" unless helper.remote_branch?(user, branch)
+  die "Unable to switch branches, your current branch has uncommitted changes" if helper.branch_dirty?
+
+  unless options[:merge]
+    puts "Switching to #{user}/#{branch}"
+    git "update-ref refs/heads/#{user}/#{branch} HEAD"
+    git "checkout #{user}/#{branch}"
   end
-  
-  # get the contents of the branch, merging it with whatever is in the local branch
   git_exec "pull #{user} #{branch}"
 end
 
@@ -120,4 +123,4 @@ command :'pull-request' do |user, branch|
 
     git_exec "request-pull #{user}/#{branch} origin"
   end
-end
+end

data/commands/helpers.rb

@@ -36,7 +36,7 @@ end
 
 helper :remotes do
   regexp = '^remote\.(.+)\.url$'
-  `git config --get-regexp '#{regexp}'`.split(/\n/).inject({}) do |memo, line|
+  `git config --get-regexp '#{regexp}'`.split("\n").inject({}) do |memo, line|
     name_string, url = line.split(/ /, 2)
     m, name = *name_string.match(/#{regexp}/)
     memo[name.to_sym] = url
@@ -44,20 +44,25 @@ helper :remotes do
   end
 end
 
-helper :heads do |user|
-  results = `git ls-remote -h #{user}  2> /dev/null`
-  results = `git rev-parse --symbolic-full-name --branches 2> /dev/null | grep refs/heads/#{user}` if $?.exitstatus != 0
-  
-  results.split(/\n/).inject({}) do |memo, line|
+helper :remote_branches_for do |user|
+  `git ls-remote -h #{user} 2> /dev/null`.split(/\n/).inject({}) do |memo, line|
     hash, head = line.split(/\t/, 2)
-    head = line.scan(/refs\/heads\/(.+)$/)[0][0]
-    memo[head] = hash
+    head = head[%r{refs/heads/(.+)$},1] unless head.nil?
+    memo[head] = hash unless head.nil?
     memo
-  end
+  end if !(user.nil? || user.strip.empty?)
+end
+
+helper :remote_branch? do |user, branch|
+  remote_branches_for(user).key?(branch)
 end
 
-helper :heads? do |user, branch|
-  heads(user).key?(branch)
+helper :branch_dirty? do
+  # see if there are any cached or tracked files that have been modified
+  # originally, we were going to use git-ls-files but that could only
+  # report modified track files...not files that have been staged
+  # for committal
+  !(system("git diff --quiet 2>/dev/null") or !system("git diff --cached --quiet 2>/dev/null"))
 end
 
 helper :tracking do

data/lib/github/command.rb

@@ -40,11 +40,11 @@ module GitHub
     def git_exec(*command)
       cmdstr = ['git', command].flatten.join(' ')
       GitHub.debug "exec: #{cmdstr}"
-      `#{cmdstr}`
+      exec cmdstr
     end
 
     def sh(*command)
-      return Shell.new(*command).run
+      Shell.new(*command).run
     end
 
     def die(message)
@@ -53,17 +53,24 @@ module GitHub
     end
 
     class Shell < String
+      attr_reader :error
+      attr_reader :out
+
       def initialize(*command)
         @command = command
       end
 
       def run
         GitHub.debug "sh: #{command}"
-        
-        out = `#{command} 2>&1`
-        replace @error = $?.exitstatus.to_s if $?.exitstatus != 0
+        _, out, err = Open3.popen3(*@command)
+
+        out = out.read.strip
+        err = err.read.strip
+
+        replace @error = err if err.any?
         replace @out = out if out.any?
-        return self
+
+        self
       end
 
       def command
@@ -73,7 +80,7 @@ module GitHub
       def error?
         !!@error
       end
-      
+
       def out?
         !!@out
       end

data/spec/command_spec.rb

@@ -24,14 +24,25 @@ describe GitHub::Command do
     unguard(Kernel, :exec)
     hi = @command.sh("echo hi")
     hi.should == "hi"
+    hi.out.should == "hi"
     hi.out?.should be(true)
+    hi.error.should be_nil
     hi.error?.should be(false)
     hi.command.should == "echo hi"
     bye = @command.sh("echo bye >&2")
     bye.should == "bye"
+    bye.out.should be_nil
     bye.out?.should be(false)
+    bye.error.should == "bye"
     bye.error?.should be(true)
     bye.command.should == "echo bye >&2"
+    hi_and_bye = @command.sh("echo hi; echo bye >&2")
+    hi_and_bye.should == "hi"
+    hi_and_bye.out.should == "hi"
+    hi_and_bye.out?.should be(true)
+    hi_and_bye.error.should == "bye"
+    hi_and_bye.error?.should be(true)
+    hi_and_bye.command.should == "echo hi; echo bye >&2"
   end
 
   it "should return the results of a git operation" do

data/spec/helper_spec.rb

@@ -149,6 +149,67 @@ remote.nex3.url git://github.com/nex3/github-gem.git
     end
   end
 
+  helper :remote_branches_for do
+    it "should return an empty list because no user was provided" do
+      @helper.remote_branches_for(nil).should == nil
+    end
+
+    it "should return a list of remote branches for defunkt" do
+      @helper.should_receive(:`).with('git ls-remote -h defunkt 2> /dev/null').and_return <<-EOF
+fe1f852f3cf719c7cd86147031732f570ad89619	refs/heads/kballard/master
+f8a6bb42b0ed43ac7336bfcda246e59a9da949d6	refs/heads/master
+624d9c2f742ff24a79353a7e02bf289235c72ff1	refs/heads/restart
+      EOF
+      @helper.remote_branches_for("defunkt").should == {
+        "master"          => "f8a6bb42b0ed43ac7336bfcda246e59a9da949d6",
+        "kballard/master" => "fe1f852f3cf719c7cd86147031732f570ad89619",
+        "restart"         => "624d9c2f742ff24a79353a7e02bf289235c72ff1"
+      }
+    end
+
+    it "should return an empty list of remote branches for nex3 and nex4" do
+      # the following use-case should never happen as the -h parameter should only return heads on remote branches
+      # however, we are testing this particular case to verify how remote_branches_for would respond if random
+      # git results
+      @helper.should_receive(:`).with('git ls-remote -h nex3 2> /dev/null').and_return <<-EOF
+fe1f852f3cf719c7cd86147031732f570ad89619	HEAD
+a1a392369e5b7842d01cce965272d4b96c2fd343	refs/tags/v0.1.3
+624d9c2f742ff24a79353a7e02bf289235c72ff1	refs/remotes/origin/master
+random
+	random_again
+      EOF
+      @helper.remote_branches_for("nex3").should be_empty
+
+      @helper.should_receive(:`).with('git ls-remote -h nex4 2> /dev/null').and_return ""
+      @helper.remote_branches_for("nex4").should be_empty
+    end
+  end
+
+  helper :remote_branch? do
+    it "should return whether the branch exists at the remote user" do
+      @helper.should_receive(:remote_branches_for).with("defunkt").any_number_of_times.and_return({
+        "master"          => "f8a6bb42b0ed43ac7336bfcda246e59a9da949d6",
+        "kballard/master" => "fe1f852f3cf719c7cd86147031732f570ad89619",
+        "restart"         => "624d9c2f742ff24a79353a7e02bf289235c72ff1"
+      })
+      @helper.remote_branch?("defunkt", "master").should == true
+      @helper.remote_branch?("defunkt", "not_master").should == false
+    end
+  end
+
+  helper :branch_dirty? do
+    it "should return false" do
+      @helper.should_receive(:system).with(/^git diff/).and_return(0, 0)
+      @helper.branch_dirty?.should == 0
+    end
+
+    it "should return true" do
+      @helper.should_receive(:system).with(/^git diff/).and_return(1, 1, 0, 1)
+      @helper.branch_dirty?.should == 1
+      @helper.branch_dirty?.should == 1
+    end
+  end
+
   helper :tracking do
     it "should return a list of remote/user_or_url pairs" do
       @helper.should_receive(:remotes).and_return({

data/spec/ui_spec.rb

@@ -157,16 +157,16 @@ EOF
     end
   end
 
-  # -- pull --
-  specify "pull should die with no args" do
-    running :pull do
-      @command.should_receive(:die).with("Specify a user to pull from").and_return { raise "Died" }
+  # -- fetch --
+  specify "fetch should die with no args" do
+    running :fetch do
+      @command.should_receive(:die).with("Specify a user to pull from").and_return { raise "Died "}
       self.should raise_error("Died")
     end
   end
 
-  specify "pull defunkt should start tracking defunkt if they're not already tracked" do
-    running :pull, "defunkt" do
+  specify "fetch defunkt should start tracking defunkt if they're not already tracked" do
+    running :fetch, "defunkt" do
       setup_remote(:origin, :user => "user", :ssh => true)
       setup_remote(:external, :url => "home:/path/to/project.git")
       GitHub.should_receive(:invoke).with(:track, "defunkt").and_return { raise "Tracked" }
@@ -174,56 +174,98 @@ EOF
     end
   end
 
-  specify "pull defunkt should create defunkt/master and pull from the defunkt remote" do
-    running :pull, "defunkt" do
+  specify "fetch defunkt should create defunkt/master and fetch from the defunkt remote" do
+    running :fetch, "defunkt" do
       setup_remote(:defunkt)
-      @command.should_receive(:git).with("checkout -b defunkt/master").ordered.and_return do
-        mock("checkout -b defunkt/master").tap { |m| m.stub!(:error?) }
-      end
-      @command.should_receive(:git_exec).with("pull defunkt master").ordered
+      @helper.should_receive(:branch_dirty?).and_return false
+      @command.should_receive(:git).with("update-ref refs/heads/defunkt/master HEAD").ordered
+      @command.should_receive(:git).with("checkout defunkt/master").ordered
+      @command.should_receive(:git_exec).with("fetch defunkt master").ordered
       stdout.should == "Switching to defunkt/master\n"
     end
   end
 
-  specify "pull defunkt should switch to pre-existing defunkt/master and pull from the defunkt remote" do
-    running :pull, "defunkt" do
+  specify "fetch defunkt should die if there is a dirty branch" do
+    running :fetch, "defunkt" do
       setup_remote(:defunkt)
-      @command.should_receive(:git).with("checkout -b defunkt/master").ordered.and_return do
-        mock("checkout -b defunkt/master").tap { |m| m.should_receive(:error?) { true } }
-      end
+      @helper.should_receive(:branch_dirty?).and_return true
+      @command.should_receive(:die).with("Unable to switch branches, your current branch has uncommitted changes").and_return { raise "Died" }
+      self.should raise_error("Died")
+    end
+  end
+
+  specify "fetch defunkt/wip should create defunkt/wip and fetch from wip branch on defunkt remote" do
+    running :fetch, "defunkt/wip" do
+      setup_remote(:defunkt, :remote_branches => ["master", "wip"])
+      @helper.should_receive(:branch_dirty?).and_return false
+      @command.should_receive(:git).with("update-ref refs/heads/defunkt/wip HEAD").ordered
+      @command.should_receive(:git).with("checkout defunkt/wip").ordered
+      @command.should_receive(:git_exec).with("fetch defunkt wip").ordered
+      stdout.should == "Switching to defunkt/wip\n"
+    end
+  end
+
+  specify "fetch --merge defunkt should fetch from defunkt remote into current branch" do
+    running :fetch, "--merge", "defunkt" do
+      setup_remote(:defunkt)
+      @helper.should_receive(:branch_dirty?).and_return false
+      @command.should_receive(:git_exec).with("fetch defunkt master")
+    end
+  end
+
+  # -- fetch --
+  specify "fetch should die with no args" do
+    running :fetch do
+      @command.should_receive(:die).with("Specify a user to fetch from").and_return { raise "Died" }
+      self.should raise_error("Died")
+    end
+  end
+
+  specify "fetch defunkt should start tracking defunkt if they're not already tracked" do
+    running :fetch, "defunkt" do
+      setup_remote(:origin, :user => "user", :ssh => true)
+      setup_remote(:external, :url => "home:/path/to/project.git")
+      GitHub.should_receive(:invoke).with(:track, "defunkt").and_return { raise "Tracked" }
+      self.should raise_error("Tracked")
+    end
+  end
+
+  specify "fetch defunkt should create defunkt/master and fetch from the defunkt remote" do
+    running :fetch, "defunkt" do
+      setup_remote(:defunkt)
+      @helper.should_receive(:branch_dirty?).and_return false
+      @command.should_receive(:git).with("update-ref refs/heads/defunkt/master HEAD").ordered
       @command.should_receive(:git).with("checkout defunkt/master").ordered
-      @command.should_receive(:git_exec).with("pull defunkt master").ordered
+      @command.should_receive(:git_exec).with("fetch defunkt master").ordered
       stdout.should == "Switching to defunkt/master\n"
     end
   end
 
-  specify "pull defunkt wip should create defunkt/wip and pull from wip branch on defunkt remote" do
-    running :pull, "defunkt", "wip" do
+  specify "fetch defunkt should die if there is a dirty branch" do
+    running :fetch, "defunkt" do
       setup_remote(:defunkt)
-      @command.should_receive(:git).with("checkout -b defunkt/wip").ordered.and_return do
-        mock("checkout -b defunkt/wip").tap { |m| m.stub!(:error?) }
-      end
-      @command.should_receive(:git_exec).with("pull defunkt wip").ordered
-      stdout.should == "Switching to defunkt/wip\n"
+      @helper.should_receive(:branch_dirty?).and_return true
+      @command.should_receive(:die).with("Unable to switch branches, your current branch has uncommitted changes").and_return { raise "Died" }
+      self.should raise_error("Died")
     end
   end
 
-  specify "pull defunkt/wip should switch to pre-existing defunkt/wip and pull from wip branch on defunkt remote" do
-    running :pull, "defunkt/wip" do
-      setup_remote(:defunkt)
-      @command.should_receive(:git).with("checkout -b defunkt/wip").ordered.and_return do
-        mock("checkout -b defunkt/wip").tap { |m| m.should_receive(:error?) { true } }
-      end
+  specify "fetch defunkt/wip should create defunkt/wip and fetch from wip branch on defunkt remote" do
+    running :fetch, "defunkt/wip" do
+      setup_remote(:defunkt, :remote_branches => ["master", "wip"])
+      @helper.should_receive(:branch_dirty?).and_return false
+      @command.should_receive(:git).with("update-ref refs/heads/defunkt/wip HEAD").ordered
       @command.should_receive(:git).with("checkout defunkt/wip").ordered
-      @command.should_receive(:git_exec).with("pull defunkt wip").ordered
+      @command.should_receive(:git_exec).with("fetch defunkt wip").ordered
       stdout.should == "Switching to defunkt/wip\n"
     end
   end
 
-  specify "pull --merge defunkt should pull from defunkt remote into current branch" do
-    running :pull, "--merge", "defunkt" do
+  specify "fetch --merge defunkt should fetch from defunkt remote into current branch" do
+    running :fetch, "--merge", "defunkt" do
       setup_remote(:defunkt)
-      @command.should_receive(:git_exec).with("pull defunkt master")
+      @helper.should_receive(:branch_dirty?).and_return false
+      @command.should_receive(:git_exec).with("fetch defunkt master")
     end
   end
 
@@ -390,12 +432,14 @@ EOF
       @stderr_mock.invoke unless @stderr_mock.nil?
     end
 
-    def setup_remote(remote, options = {:user => nil, :project => "project"})
+    def setup_remote(remote, options = {:user => nil, :project => "project", :remote_branches => nil})
       @remotes ||= {}
+      @remote_branches ||= {}
       user = options[:user] || remote
       project = options[:project]
       ssh = options[:ssh]
       url = options[:url]
+      remote_branches = options[:remote_branches] || ["master"]
       if url
         @remotes[remote.to_sym] = url
       elsif ssh
@@ -403,6 +447,11 @@ EOF
       else
         @remotes[remote.to_sym] = "git://github.com/#{user}/#{project}.git"
       end
+
+      @remote_branches[remote.to_sym] = (@remote_branches[remote.to_sym] || Array.new) | remote_branches
+      @helper.should_receive(:remote_branch?).any_number_of_times.and_return do |remote, branch|
+        @remote_branches.fetch(remote.to_sym,[]).include?(branch)
+      end
     end
 
     def mock_remotes()

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: riquedafreak-github
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors: 
 - Chris Wanstrath, Kevin Ballard