webmat-git_remote_branch 0.2.1

data/README

@@ -0,0 +1,69 @@
+Why git_remote_branch?
+
+The basic idea for git_remote_branch is to trivialize the interaction with 
+remote branches in simple situations.
+Things we mean by 'simple situations':
+- The local and remote name are the same
+
+Another goal of git_remote_branch is to help teach the real underlying git 
+commands. Each operation done on your behalf is displayed at the console.
+
+
+
+Installation
+
+(Not yet published as a gem)
+(gem install webmat-git_remote_branch --source=http://gems.github.com)
+
+
+
+Usage
+
+Notes: 
+- parts between brackets are optional
+- When 'origin_server' is not specified, the name 'origin' is assumed.
+
+$ grb [-h]    #=> Displays help
+
+Available commands (with aliases):
+
+create (alias: new)
+Create a new local branch as well as a corresponding remote branch.
+Automatically track the new remote branch (useful for pulling and merging).
+Switch to the new branch.
+
+$ grb create branch_name [origin_server]
+
+
+delete (aliases: destroy, kill)
+Delete the remote branch then delete the local branch.
+The local branch is not deleted if there are pending changes.
+
+$ grb delete branch_name [origin_server]
+
+
+track (aliases: follow grab)
+Track an existing remote branch locally.
+
+
+$ grb track branch_name [origin_server]
+
+
+
+History
+
+This script was originally created by Carl Mercier and made public on his blog 
+here:
+
+No nonsense GIT, part 1: git-remote-branch
+http://blog.carlmercier.com/2008/01/25/no-nonsense-git-part-1-git-remote-branch/
+
+For now I just want to document the changes I make to it. I'm not sure if I'll 
+keep this alive, it depends on if he wants to keep evolving it himself in a 
+public repo.
+
+
+
+Contributors
+- Mathieu Martin  webmat@gmail.com
+- Carl Mercier    (Carl: want your email here?)

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rubygems'
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/gempackagetask'
+
+HERE = File.dirname(__FILE__)
+
+require "#{HERE}/lib/git_remote_branch"
+
+
+#Stuff gleaned from merb-core's Rakefile
+NAME = 'git_remote_branch'
+windows = (RUBY_PLATFORM =~ /win32|cygwin/) rescue nil
+install_home = ENV['GEM_HOME'] ? "-i #{ENV['GEM_HOME']}" : ""
+SUDO = windows ? "" : "sudo"
+
+
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+task :default => :test
+
+gem_spec = eval(File.read("#{HERE}/git_remote_branch.gemspec"))
+
+namespace :gem do
+  #Creates clobber_package, gem,  package, repackage tasks
+  #Note on clobber_package: fortunately, this will clobber the CODE package
+  Rake::GemPackageTask.new(gem_spec) do |pkg| 
+    pkg.need_tar = true 
+  end
+
+  #Tasks gleaned from merb-core's Rakefile
+
+  desc "Run :gem and install the resulting .gem"
+  task :install => :gem do
+    cmd = "#{SUDO} gem install #{install_home} --local pkg/#{NAME}-#{GitRemoteBranch::VERSION}.gem --no-rdoc --no-ri"
+    puts cmd
+    `#{cmd}`
+  end
+
+  desc "Uninstall the .gem"
+  task :uninstall do
+    `#{SUDO} gem uninstall #{NAME}`
+  end
+end

data/TODO

@@ -0,0 +1,43 @@
+- Put in evidence the tutorial part of each grb action
+  - colorize the git commands
+  - Add 'explain' / 'show' command
+- tests :-)
+- re-architect the code a bit?
+- better exit status behavior
+- Add verification if remote delete didn't work
+- New functionality:
+  - Remotize an existing local branch (aliases: publish share make_remote makeremote)
+    git push origin branch_name:refs/heads/branch_name
+    git fetch origin
+    (find a local branch other than the branch to remotize)
+    git checkout master
+    git branch --track -f branch_name origin/branch_name
+    (yay! we don't have to delete the local one...)
+- make into a gem?
+  - that installs a grb command in the path?
+
+Fix that problem:
+  mathieu@ml code (master)$ grbd follow aaron
+  git_remote_branch version 0.2.1
+  ----------------------------------------------------------------------
+
+  Executing: git branch --track aaron origin/aaron
+  fatal: Not a valid object name: 'origin/aaron'.
+
+
+  mathieu@ml code (master)$ git fetch
+  remote: Counting objects: 87, done.
+  remote: Compressing objects: 100% (45/45), done.
+  remote: Total 51 (delta 13), reused 40 (delta 5)
+  Unpacking objects: 100% (51/51), done.
+  From git@github.com:webmat/priv_repo
+   * [new branch]      aaron      -> origin/aaron
+
+  mathieu@ml code (master)$ grbd follow aaron
+  git_remote_branch version 0.2.1
+  ----------------------------------------------------------------------
+
+  Executing: git branch --track aaron origin/aaron
+
+
+  

data/bin/grb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+# Check out the README (or try grb -h) before you screw up your repos ;-)
+
+require File.expand_path( File.join( [File.dirname(__FILE__)] + %w{ .. lib git_remote_branch } ) )
+include GitRemoteBranch
+
+print_welcome
+
+p = read_params
+
+if p[:action] == :help
+  print_usage
+  exit 0
+end
+
+if p[:current_branch].nil?
+  puts 'You must specify a branch'
+  print_usage
+  exit 1
+end
+
+case p[:action]
+  when :create
+    create_branch(p[:branch], p[:origin], p[:current_branch])
+  when :delete
+    delete_branch(p[:branch], p[:origin], p[:current_branch])
+  when :track
+    track_branch(p[:branch], p[:origin])
+  else
+    print_usage
+    exit 1
+end

data/lib/git_remote_branch.rb

@@ -0,0 +1,108 @@
+module GitRemoteBranch
+  VERSION = '0.2.1'
+
+  CMD_ALIASES = {
+    :create => %w{create new},
+    :delete => %w{delete destroy kill remove},
+    :track  => %w{track follow grab fetch},
+  }
+
+  def print_welcome
+    puts "git_remote_branch version #{VERSION}", '-' * 70, ''
+  end
+
+  def print_usage
+    puts <<-HELP
+  Usage:
+
+  git_remote_branch create branch_name [origin_server]
+  -or-
+  git_remote_branch delete branch_name [origin_server]
+  -or-
+  git_remote_branch track branch_name [origin_server]
+  
+  If origin_server is not specified, the name 'origin' is assumed
+  
+  All commands also have aliases:
+  #{ CMD_ALIASES.keys.map{|k| k.to_s}.sort.map {|k| 
+    "#{k}: #{CMD_ALIASES[k.to_sym].join(', ')}" }.join("\n  ") }
+  HELP
+  end
+
+  def execute_cmd(cmd)
+    res, out, err = steal_pipes do
+                                  `#{cmd}`
+                                end
+    return res, out, err
+  end
+
+  def execute_cmds(*cmds)
+    cmds.flatten.each do |c|
+      puts "Executing: #{c}"
+      `#{c}`
+      puts ""
+    end
+  end
+
+  def create_branch(branch_name, origin, current_branch)
+    cmd = []
+    cmd << "git push origin #{current_branch}:refs/heads/#{branch_name}"
+    cmd << "git fetch #{origin}"
+    cmd << "git branch --track #{branch_name} #{origin}/#{branch_name}"
+    cmd << "git checkout #{branch_name}"
+    execute_cmds(cmd)
+  end
+
+  def delete_branch(branch_name, origin, current_branch)
+    cmd = []
+    cmd << "git push #{origin} :refs/heads/#{branch_name}"
+    cmd << "git checkout master" if current_branch == branch_name
+    cmd << "git branch -d #{branch_name}"
+    execute_cmds(cmd)
+  end
+
+  def track_branch(branch_name, origin)
+    cmd = ["git branch --track #{branch_name} #{origin}/#{branch_name}"]
+    execute_cmds(cmd)
+  end
+
+  def get_current_branch
+    x = `git branch -l`
+    x.each_line do |l|
+      return l.sub("*","").strip if l[0] == 42
+    end
+
+    puts "Couldn't identify the current local branch."
+    return nil
+  end
+
+  def get_action
+    a = ARGV[0].downcase
+    return :create if CMD_ALIASES[:create].include?(a)
+    return :delete if CMD_ALIASES[:delete].include?(a)
+    return :track  if CMD_ALIASES[:track].include?(a)
+    return nil
+  end
+
+  def get_branch
+    ARGV[1].downcase
+  end
+
+  def get_origin
+    return ARGV[2] if ARGV.size > 2 
+    return "origin"
+  end
+
+  def read_params
+    p={}
+    begin
+      p[:action] = get_action
+      p[:branch] = get_branch
+      p[:origin] = get_origin
+      p[:current_branch] = get_current_branch
+      p
+    rescue
+      {:action=>:help}
+    end
+  end
+end

data/test/git_helper.rb

@@ -0,0 +1,57 @@
+require 'fileutils'
+require 'tmpdir'
+
+# Instantiating a GitHelper object creates a temp directory containing 3 repos.
+# 1 that's considered the remote repo and 2 peer local repos (local1 and local2).
+# All 3 are synchronized with the same data (they contain a few dummy files).
+# Once instantiated you can access the 3 full repo locations with attribute readers
+# remote, local1 and local2.
+class GitHelper
+  include FileUtils
+
+  @@WORK_DIR = 'repo_test'
+  
+  attr_reader :remote, :local1, :local2
+  
+  def initialize
+    @wd = get_temp_dir
+    
+    @remote = init_repo(@wd, 'remote')
+    @local1 = clone_repo(@remote, @wd, 'local1')
+    @local2 = clone_repo(@remote, @wd, 'local2')
+  end
+  
+  def cleanup
+    rm_rf @wd
+  end
+  
+  protected
+  def get_temp_dir
+    #Note: it's NOT a good idea to do this stuff un a subdirectory of the 
+    #git_remote_branch repo. Trust me :-)
+    wd = File.expand_path( File.join( Dir::tmpdir, @@WORK_DIR) )
+    Dir.mkdir wd unless File.exists? wd
+    
+    #Create new subdir with a random name
+    new_dir=''
+    begin
+      new_dir = File.join( wd, "#{rand(10000)}" )
+      Dir.mkdir new_dir
+    rescue
+      retry
+    end
+    
+    new_dir
+  end
+  
+  def init_repo(path, name)
+    repo_dir = File.join(path, name)
+    `mkdir #{repo_dir}; cd $_; git init; touch file.txt; git add .; git commit -a -m "dummy file"`
+    repo_dir
+  end
+  
+  def clone_repo(origin_path, clone_path, name)
+    `cd #{clone_path}; git clone #{File.join(origin_path, '.git')} #{name}`
+    return File.join(clone_path, name)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'test/unit'
+
+test_dir = File.dirname(__FILE__)
+
+begin
+  require 'try_require'
+rescue LoadError
+  require File.join( [test_dir] + %w{ .. vendor try_require try_require } )
+end
+
+try_require 'redgreen'
+try_require 'ruby-debug'
+
+require File.join(test_dir, 'git_helper')
+require File.join( [test_dir] + %w{ .. lib git_remote_branch} )
+
+class Test::Unit::TestCase
+  include GitRemoteBranch
+
+  # Passes assertion if condition is false  
+  def assert_false(condition, message = nil)
+    message = "assert_false failed" unless message
+    assert condition == false, message
+  end
+
+end

data/test/unit/git_helper_test.rb

@@ -0,0 +1,30 @@
+require File.join( File.dirname(__FILE__), '..', 'test_helper')
+
+class GitHelperTest < Test::Unit::TestCase
+  
+  def setup
+    super
+    @g = GitHelper.new
+    @directories = [@g.remote, @g.local1, @g.local2]
+  end
+  
+  def teardown
+    @g.cleanup
+  end
+  
+  def test_init
+    @directories.each do |d|
+      assert File.exists?(@g.remote), 'Directory for repo must be created'
+      assert File.exists?( File.join(@g.remote, '.git') ), 'Repo must be created'
+    end
+  end
+  
+  def test_cleanup
+    @g.cleanup
+    
+    @directories.each do |d|
+      assert_false File.exists?(@g.remote), 'Each repo directory must be destroyed after cleanup'
+    end
+  end
+  
+end

data/vendor/capture_fu/capture_fu.rb

@@ -0,0 +1,60 @@
+# This is a very early version of capture_fu. 
+# See github.com/webmat/capture_fu for more info.
+module CaptureFu
+  VERSION = '0.0.1'
+
+  def capture_output(&block)
+    real_out, real_err = $stdout, $stderr
+    result = fake_out = fake_err = nil
+    begin
+      fake_out, fake_err = Helpers::PipeStealer.new, Helpers::PipeStealer.new
+      $stdout, $stderr = fake_out, fake_err
+      result = yield
+    ensure
+      $stdout, $stderr = real_out, real_err
+    end
+    return result, fake_out.captured, fake_err.captured
+  end
+
+  # This first implementation is only intended for batch executions.
+  # You can't pipe stuff programmatically to the child process.
+  def capture_process_output(command)
+
+    #capture stderr in the same stream
+    command << ' 2>&1' unless Helpers.stderr_already_redirected(command)
+
+    out = `#{command}`
+    return $?.exitstatus, out
+  end
+
+
+  private
+
+  module Helpers
+    
+    def self.stderr_already_redirected(command)
+      #Already redirected to stdout (valid for Windows)
+      return true if command =~ /2>&1\s*\Z/
+
+      #Redirected to /dev/null (this is clearly POSIX-dependent)
+      return true if command =~ /2>\/dev\/null\s*\Z/
+
+      return false
+    end
+
+    class PipeStealer < File
+      attr_reader :captured
+      def initialize
+        @captured = ''
+      end
+      def write(s)
+        @captured << s
+      end
+      def captured
+        return nil if @captured.empty?
+        @captured.dup
+      end
+    end
+
+  end #Helper module
+end

data/vendor/try_require/try_require.rb

@@ -0,0 +1,18 @@
+# This is a very early version of try_require. 
+# See github.com/webmat/try_require for more info.
+def try_require(what, &block)
+  loaded, require_result = false, nil 
+
+  begin
+    require_result = require what
+    loaded = true 
+
+  rescue LoadError => ex
+    puts "Unable to require '#{what}'", "#{ex.class}: #{ex.message}"
+  end 
+
+  yield if loaded and block_given? 
+
+  require_result
+end
+

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: webmat-git_remote_branch
+version: !ruby/object:Gem::Version 
+  version: 0.2.1
+platform: ruby
+authors: 
+- Mathieu Martin
+- Carl Mercier
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-13 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: git_remote_branch is a learning tool to ease the interaction with remote branches in simple situations.
+email: webmat@gmail.com
+executables: 
+- grb
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- README
+- TODO
+- bin/grb
+- lib/git_remote_branch.rb
+- vendor/try_require/try_require.rb
+- vendor/capture_fu/capture_fu.rb
+- test/git_helper.rb
+- test/test_helper.rb
+- test/unit/git_helper_test.rb
+has_rdoc: false
+homepage: http://github.com/webmat/git_remote_branch
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: git_remote_branch eases the interaction with remote branches
+test_files: 
+- test/git_helper.rb
+- test/test_helper.rb
+- test/unit/git_helper_test.rb