git_bpf 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+test
+.DS_Store
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in git_bpf.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2013, Affinity Bridge
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met: 
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer. 
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The views and conclusions contained in the software and documentation are those
+of the authors and should not be interpreted as representing official policies, 
+either expressed or implied, of the FreeBSD Project.

data/README.md

@@ -0,0 +1,67 @@
+Affinity Bridge's Branch-per-Feature Scripts
+============================================
+
+Configure a repository and add some useful [Branch-per-Feature] workflow commands.
+
+Performs the following actions in the target repository:
+
+ - enables ```git-rerere```
+ - configures ```git-rerere``` to automatically stage successful resolutions
+ - a .git/rr-cache directory will be set up to synchronize with a 'rr-cache' branch in the repository's remote.
+ - installs a ```post-merge``` git hook for automatic rr-cache syncing
+ - installs the bundled branch-per-feature helper commands
+
+## Commands
+
+### git-recreate-branch
+
+Usage: ```git recreate-branch <source-branch> [OPTIONS]...```
+
+Recreates <source-branch> in-place or as a new branch by re-merging all of the merge commits which it is comprised of.
+
+    OPTIONS
+        -a, --base NAME                  A reference to the commit from which the source branch is based, defaults to master.
+        -b, --branch NAME                Instead of deleting the source branch and replacng it with a new branch of the same name, leave the source branch and create a new branch called NAME.
+        -x, --exclude NAME               Specify a list of branches to be excluded.
+        -l, --list                       Process source branch for merge commits and list them. Will not make any changes to any branches.
+
+
+### git-share-rerere
+
+A collection of commands to help share your rr-cache.
+
+    OPTIONS
+        -c, --cache_dir DIR              The location of your rr-cache dir, defaults to .git/rr-cache.
+        -g, --git-dir DIR                The location of your rr-cache .git dir, defaults to .git/rr-cache/.git.
+        -b, --branch NAME                The name of the branch your rr-cache is stored in, defaults to rr-cache.
+        -r, --remote NAME                The name of the remote to use when getting the latest rr-cache, defaults to origin.
+
+**Sub-commands - Usage:**
+
+```git share-rerere push```
+
+Push any new resolutions to the designated <branch> on the remote.
+
+```git share-rerere pull```
+
+Pull any new resolutions to the designated <branch> on the remote.
+
+## Install
+
+_Requires git >= 1.7.10.x_
+
+### Install git-bpf-init script
+
+git_bpf is packaged as a Ruby Gem and hosted on [RubyGems]
+    gem install git_bpf
+
+### Usage
+
+    git-bpf-init <target-repository>
+
+ - If <target-repository> is not provided, <target-repository> defaults to your current directory (will fail if current directory is not a git repository).
+ - The script requires the <target-repository> to have a remote named 'origin'.
+
+
+[Branch-per-Feature]: https://github.com/affinitybridge/git-bpf/wiki/Branch-per-feature-process
+[RubyGems]: http://rubygems.org/

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/_git-bpf

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require 'git_bpf'

data/bin/git-bpf-init

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'git_bpf'
+GitFlow.should_run = false
+
+at_exit { GitFlow.run(*(['init'] + ARGV)) }

data/git_bpf.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'git_bpf/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "git_bpf"
+  spec.version       = GitBpf::VERSION
+  spec.authors       = ["tnightingale"]
+  spec.email         = ["tom@affinitybridge.com"]
+  spec.description   = %q{A collection of commands to help with implementing the branch-per-feature git development workflow.}
+  spec.summary       = %q{Git branch-per-feature helper commands.}
+  spec.homepage      = "https://github.com/affinitybridge/git-bpf"
+  spec.license       = "BSD"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/git-bpf.rb

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+base_path = File.dirname(__FILE__)
+$LOAD_PATH.unshift(base_path) unless $LOAD_PATH.include?(base_path)
+

data/lib/git_bpf.rb

@@ -0,0 +1,8 @@
+require "git_bpf/version"
+
+require "git_bpf/commands/recreate-branch"
+require "git_bpf/commands/share-rerere-cache"
+require "git_bpf/commands/init"
+
+module GitBpf
+end

data/lib/git_bpf/commands/init.rb

@@ -0,0 +1,146 @@
+require 'git_bpf/lib/gitflow'
+require 'git_bpf/lib/git-helpers'
+require 'git_bpf/lib/repository'
+
+#
+# init: 
+#
+class Init < GitFlow/'init'
+
+  include GitHelpersMixin
+
+  @documentation = ""
+
+  def options(opts)
+    opts.script_dir_name = 'git-bpf'
+    opts.remote_name = 'origin'
+    opts.rerere_branch = 'rr-cache'
+
+    [
+      ['-d', '--directory-name NAME',
+        "",
+        lambda { |n| opts.script_dir_name = n }],
+      ['-r', '--remote-name NAME',
+        "",
+        lambda { |n| opts.remote_name = n }],
+      ['-b', '--rerere-branch NAME',
+        "",
+        lambda { |n| opts.rerere_branch = n }],
+    ]
+  end
+
+  def execute(opts, argv)
+    if argv.length > 1
+      run 'init', '--help'
+      terminate
+    end
+
+    # TODO: There's likely a better way to do this.
+    source_path = File.join File.dirname(__FILE__), '..'
+    target = Repository.new(argv.length == 1 ? argv.pop : Dir.getwd)
+
+
+    #
+    # 1. Link source scripts directory.
+    #
+    ohai "1. Linking scripts directory to '#{source_path}'."
+
+    scripts = File.join(target.path, '.git', opts.script_dir_name)
+
+    if not File.exists? scripts
+      File.symlink source_path, scripts
+    elsif File.symlink? scripts
+      opoo "Symbolic link already exists."
+    else
+      terminate "Cannot create symbolic link (#{scripts})."
+    end
+
+
+    #
+    # 2. Create aliases for commands.
+    #
+    commands = [
+      'recreate-branch',
+      'share-rerere',
+    ]
+
+    ohai "2. Creating aliases for commands:", commands.shell_list
+
+    commands.each do |name|
+      command = "!_git-bpf #{name}"
+      target.cmd("config", "--local", "alias.#{name}", command)
+    end
+
+
+    #
+    # 3. Set up rerere sharing.
+    #
+    ohai "3. Setting up rerere sharing."
+
+    target.config(true, "rerere.enabled", "true")
+    target.config(true, "rerere.autoupdate", "true")
+
+    rerere_path = File.join(target.git_dir, 'rr-cache')
+    target_remote_url = target.remoteUrl(opts.remote_name)
+
+    if not File.directory? rerere_path
+      rerere = Repository::clone target_remote_url, rerere_path
+    elsif not File.directory? File.join(rerere_path, '.git')
+      opoo "Rerere cache directory already exists; Initializing repository in existing rr-cache directory."
+      rerere = Repository.init rerere_path
+      rerere.cmd("remote", "add", opts.remote_name, target_remote_url)
+    else
+      opoo "Rerere cache directory already exists and is a repository."
+      rerere = Repository.new rerere_path
+    end
+
+    rerere.fetch opts.remote_name
+
+    if rerere.branch?('rr-cache', opts.remote_name)
+      # Remote has branch 'rr-cache', make sure we are currently on it.
+      if not rerere.head.include? "rr-cache"
+        rerere.cmd("checkout", "rr-cache")
+      end
+    else
+      # Create orphan branch 'rr-cache' and push to remote.
+      rerere.cmd("checkout", "--orphan", "rr-cache")
+      rerere.cmd("rm", "-rf", "--ignore-unmatch", "#{rerere_path}/")
+      rerere.cmd("commit", "-a", "--allow-empty", "-m", "Automatically creating branch to track conflict resolutions.")
+      rerere.cmd("push", opts.remote_name, "rr-cache")
+    end
+
+
+    #
+    # 4. Symlink git-hooks.
+    #
+    hooks_dir = File.join(target.git_dir, "hooks")
+    hooks = [
+      'post-merge',
+      'post-checkout'
+    ]
+
+    ohai "4. Creating symbolic links to git-hooks:", hooks.shell_list
+
+    hooks.each do |name|
+      target_hook_path = File.join(hooks_dir, name)
+      source_hook_path = File.join(scripts, "hooks", "#{name}.rb")
+      files = Dir.glob("#{target_hook_path}*")
+      write = files.empty?
+
+      if not write and promptYN "Existing hook '#{name}' detected, overwrite?"
+        write = File.delete(files.shell_s) > 0
+      end
+
+      if write
+        File.symlink source_hook_path, target_hook_path
+      else
+        opoo "Couldn't link '#{name}' hook as it already exists."
+      end
+    end
+
+    #
+    # Success!
+    #
+    ohai "Success!"
+  end
+end

data/lib/git_bpf/commands/recreate-branch.rb

@@ -0,0 +1,179 @@
+require 'git_bpf/lib/gitflow'
+require 'git_bpf/lib/git-helpers'
+
+#
+# recreate_branch: Recreate a branch based on the merge commits it's comprised of.
+#
+class RecreateBranch < GitFlow/'recreate-branch'
+
+  include GitHelpersMixin
+
+  @@prefix = "BRANCH-PER-FEATURE-PREFIX"
+
+  @documentation = "Recreates the source branch in place or as a new branch by re-merging all of the merge commits."
+
+
+  def options(opts)
+    opts.base = 'master'
+    opts.exclude = []
+
+    [
+      ['-a', '--base NAME',
+        "A reference to the commit from which the source branch is based, defaults to #{opts.base}.",
+        lambda { |n| opts.base = n }],
+      ['-b', '--branch NAME',
+        "Instead of deleting the source branch and replacng it with a new branch of the same name, leave the source branch and create a new branch called NAME.",
+        lambda { |n| opts.branch = n }],
+      ['-x', '--exclude NAME',
+        "Specify a list of branches to be excluded.",
+        lambda { |n| opts.exclude.push(n) }],
+      ['-l', '--list',
+        "Process source branch for merge commits and list them. Will not make any changes to any branches.",
+        lambda { |n| opts.list = true }],
+    ]
+  end
+
+  def execute(opts, argv)
+    if argv.length != 1
+      run('recreate-branch', '--help')
+      terminate
+    end
+
+    source = argv.pop
+
+    # If no new branch name provided, replace the source branch.
+    opts.branch = source if opts.branch == nil
+
+    # Perform some validation.
+    if not branchExists? source
+      terminate "Cannot recreate branch #{source} as it doesn't exist."
+    end
+
+    if opts.branch != source and branchExists? opts.branch
+      terminate "Cannot create branch #{opts.branch} as it already exists."
+    end
+
+    if not refExists? opts.base
+      terminate "Cannot find reference '#{opts.base}' to use as a base for new branch: #{opts.branch}."
+    end
+
+    #
+    # 1. Compile a list of merged branches from source branch.
+    #
+    ohai "1. Processing branch '#{source}' for merge-commits..."
+
+    branches = getMergedBranches(opts.base, source)
+
+    if branches.empty?
+      terminate "No feature branches detected, '#{source}' matches '#{opts.base}'."
+    end
+
+    if opts.list
+      terminate "Branches to be merged:\n#{branches.shell_list}"
+    end
+
+    # Remove from the list any branches that have been explicity excluded using
+    # the -x option
+    branches.reject! do |item|
+      stripped = item.gsub /^remotes\/\w+\/([\w\-\/]+)$/, '\1'
+      opts.exclude.include? stripped
+    end
+
+    # Prompt to continue.
+    opoo "The following branches will be merged when the new #{opts.branch} branch is created:\n#{branches.shell_list}"
+    puts
+    puts "If you see something unexpected check:"
+    puts "a) that your '#{source}' branch is up to date"
+    puts "b) if '#{opts.base}' is a branch, make sure it is also up to date."
+    opoo "If there are any non-merge commits in '#{source}', they will not be included in '#{opts.branch}'. You have been warned."
+    if not promptYN "Proceed with #{source} branch recreation?"
+      terminate "Aborting."
+    end
+
+    #
+    # 2. Backup existing local source branch.
+    #
+    tmp_source = "#{@@prefix}-#{source}"
+    ohai "2. Creating backup of '#{source}', '#{tmp_source}'..."
+
+    if branchExists? tmp_source
+      terminate "Cannot create branch #{tmp_source} as one already exists. To continue, #{tmp_source} must be removed."
+    end
+
+    git('branch', '-m', source, tmp_source)
+
+    #
+    # 3. Create new branch based on 'base'.
+    #
+    ohai "3. Creating new '#{opts.branch}' branch based on '#{opts.base}'..."
+
+    git('checkout', '-b', opts.branch, opts.base, '--quiet')
+
+    #
+    # 4. Begin merging in feature branches.
+    #
+    ohai "4. Merging in feature branches..."
+
+    branches.each do |branch|
+      begin
+        puts " - '#{branch}'"
+        # Attempt to merge in the branch. If there is no conflict at all, we
+        # just move on to the next one.
+        git('merge', '--quiet', '--no-ff', '--no-edit', branch)
+      rescue
+        # There was a conflict. If there's no available rerere for it then it is
+        # unresolved and we need to abort as there's nothing that can be done
+        # automatically.
+        conflicts = git('rerere', 'status').chomp.split("\n")
+
+        if conflicts.length != 0
+          puts "\n"
+          puts "There is a merge conflict with branch #{branch} that has no rerere."
+          puts "Record a resoloution by resolving the conflict."
+          puts "Then run the following command to return your repository to its original state."
+          puts "\n"
+          puts "git checkout #{tmp_source} && git branch -D #{opts.branch} && git branch -m #{opts.branch}"
+          puts "\n"
+          puts "If you do not want to resolve the conflict, it is safe to just run the above command to restore your repository to the state it was in before executing this command."
+          terminate
+        else
+          # Otherwise, we have a rerere and the changes have been staged, so we
+          # just need to commit.
+          git('commit', '-a', '--no-edit')
+        end
+      end
+    end
+
+    #
+    # 5. Clean up.
+    #
+    ohai "5. Cleaning up temporary branches ('#{tmp_source}')."
+
+    if source != opts.branch
+      git('branch', '-m', tmp_source, source)
+    else
+      git('branch', '-D', tmp_source)
+    end
+  end
+
+  def getMergedBranches(base, source)
+    branches = []
+    merges = git('rev-list', '--parents', '--merges', '--reverse', "#{base}...#{source}").strip
+
+    merges.split("\n").each do |commits|
+      parents = commits.split("\s")
+      commit = parents.shift
+
+      parents.each do |parent|
+        name = git('name-rev', parent, '--name-only').strip
+        alt_base = git('name-rev', base, '--name-only').strip
+        remote_heads = /remote\/\w+\/HEAD/
+        unless name.include? source or name.include? alt_base or name.match remote_heads
+          branches.push name
+        end
+      end
+    end
+
+    return branches
+  end
+end

data/lib/git_bpf/commands/share-rerere-cache.rb

@@ -0,0 +1,82 @@
+require 'git_bpf/lib/gitflow'
+require 'git_bpf/lib/git-helpers'
+require 'git_bpf/lib/repository'
+
+module ShareReReReMixin
+  def options(opts)
+    opts.work_tree = ".git/rr-cache"
+    opts.branch = "rr-cache"
+    opts.remote = "origin"
+
+    [
+      ['-c', '--cache_dir DIR',
+        "The location of your rr-cache dir, defaults to #{opts.work_tree}.",
+        lambda { |n| opts.rr_cache_dir = n }],
+      ['-b', '--branch NAME',
+        "The name of the branch your rr-cache is stored in, defaults to #{opts.branch}.",
+        lambda { |n| opts.branch = n }],
+      ['-r', '--remote NAME',
+        "The name of the remote to use when getting the latest rr-cache, defaults to #{opts.remote}.",
+        lambda { |r| opts.remote = r }],
+    ]
+  end
+end
+
+#
+# share-rerere: Recreate a branch based on the merge commits it's comprised of.
+#
+class ShareReReRe < GitFlow/'share-rerere'
+
+  @documentation = <<-HELP.undent
+    A collection of commands to help share your rr-cache.
+
+    Available commands:
+     - push
+     - pull
+  HELP
+
+  def execute(opts, argv)
+    run('share-rerere', '--help')
+  end
+
+  class PullReReRe < ShareReReRe/'pull'
+
+    @help = "Pull the latest conflict resolutions."
+
+    include GitHelpersMixin
+    include ShareReReReMixin
+
+    def execute(opts, argv)
+      rerere = Repository.new opts.work_tree
+      rerere.cmd("pull", '--quiet', opts.remote, opts.branch)
+    end
+  end
+
+  class PushReReRe < ShareReReRe/'push'
+
+    @help = "Push your latest conflict resolutions."
+
+    include GitHelpersMixin
+    include ShareReReReMixin
+
+    def execute(opts, argv)
+      rerere = Repository.new opts.work_tree
+      lines = rerere.cmd("status", "--porcelain").split("\n").map { |a| a.chomp }
+      if lines.empty?
+        terminate "No resolutions to share."
+      end
+
+      lines.each do |line|
+        if line =~ /^\?\?\s(\w+)\//
+          folder = line.split("\s").last
+          message = "Sharing resolution: #{folder}."
+          rerere.cmd("add", folder)
+          rerere.cmd("commit", "-m", message)
+          rerere.cmd("push", "--quiet", opts.remote, opts.branch)
+          puts message
+        end
+      end
+    end
+  end
+
+end

data/lib/git_bpf/hooks/post-checkout.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+puts "POST-CHECKOUT.rb"
+# Pull latest conflict resolutions.
+`git share-rerere pull`

data/lib/git_bpf/hooks/post-merge.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+parents = `git rev-list -n 1 --parents HEAD`.split("\s")
+
+# Shift off the last commit.
+last = parents.shift
+
+if parents.length >= 2
+  `git share-rerere pull`
+  `git share-rerere push`
+end

data/lib/git_bpf/lib/git-helpers.rb

@@ -0,0 +1,118 @@
+#
+# From homebrew (https://raw.github.com/mxcl/homebrew/go).
+#
+class Tty
+  class <<self
+    def blue; bold 34; end
+    def white; bold 39; end
+    def red; underline 31; end
+    def yellow; underline 33 ; end
+    def reset; escape 0; end
+    def em; underline 39; end
+    def green; color 92 end
+    def gray; bold 30 end
+
+    def width
+      `/usr/bin/tput cols`.strip.to_i
+    end
+
+  private
+    def color n
+      escape "0;#{n}"
+    end
+    def bold n
+      escape "1;#{n}"
+    end
+    def underline n
+      escape "4;#{n}"
+    end
+    def escape n
+      "\033[#{n}m" if $stdout.tty?
+    end
+  end
+end
+
+def ohai title, *sput
+  title = title.to_s[0, Tty.width - 4] if $stdout.tty?
+  puts "#{Tty.blue}==>#{Tty.white} #{title}#{Tty.reset}"
+  puts sput unless sput.empty?
+end
+
+def oh1 title
+  title = title.to_s[0, Tty.width - 4] if $stdout.tty?
+  puts "#{Tty.green}==>#{Tty.white} #{title}#{Tty.reset}"
+end
+
+def opoo warning
+  puts "#{Tty.red}Warning#{Tty.reset}: #{warning}"
+end
+
+def onoe error
+  lines = error.to_s.split'\n'
+  puts "#{Tty.red}Error#{Tty.reset}: #{lines.shift}"
+  puts lines unless lines.empty?
+end
+
+class Array
+  def shell_s
+    cp = dup
+    first = cp.shift
+    cp.map{ |arg| arg.gsub " ", "\\ " }.unshift(first) * " "
+  end
+
+  def shell_list
+    cp = dup
+    dup.map{ |val| " - #{val}" }.join("\n")
+  end
+end
+
+class String
+  def undent
+    gsub(/^.{#{slice(/^ +/).length}}/, '')
+  end
+end
+
+module GitHelpersMixin
+  def context(work_tree, git_dir, *args)
+    # Git pull requires absolute paths when executed from outside of the
+    # repository's work tree.
+    params = [
+      "--git-dir=#{File.expand_path(git_dir)}",
+      "--work-tree=#{File.expand_path(work_tree)}"
+    ]
+    return params + args
+  end
+
+  def branchExists?(branch)
+    ref = (branch.include? "refs/heads/") ? branch : "refs/heads/#{branch}"
+    begin
+      git('show-ref', '--verify', '--quiet', ref)
+    rescue
+      return false
+    end
+    return true
+  end
+
+  def refExists?(ref)
+    begin
+      git('show-ref', '--tags', '--heads', ref)
+    rescue
+      return false
+    end
+    return true
+  end
+
+  def terminate(message = nil)
+    puts message if message != nil
+    throw :exit
+  end
+
+  def promptYN(message)
+    puts
+    puts "#{message} [y/N]"
+    unless STDIN.gets.chomp == 'y'
+      return false
+    end
+    return true
+  end
+end

data/lib/git_bpf/lib/gitflow.rb

@@ -0,0 +1,296 @@
+#!/usr/bin/env ruby
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+require 'optparse'
+require 'ostruct'
+require 'fileutils'
+
+module GitFlow
+  extend self
+
+  attr_accessor :should_run, :trace, :program
+
+  self.program = 'gitflow'
+  self.should_run = true # should we run at exit?
+
+  HELP = <<-HELP
+
+GitFlow is a tool to create custom git commands implemented in ruby.
+It is generic enougth to be used on any git based project besides Apache Buildr.
+
+OVERVIEW:
+
+gitflow is intended to help developers with their daily git workflow,
+performing repetitive git commands for them. It is implemented in
+ruby so you can do anything, from invoking rake tasks to telling
+people on twitter you are having trouble with their code :P.
+
+To get help for a specific command use:
+    gitflow.rb help command
+    gitflow.rb command --help
+
+For convenience you can create an alias to be execute using git.
+The following example registers buildr-git.rb, which provides apache
+svn and git synchronization commands:
+
+    git config alias.apache '!'"ruby $PWD/doc/scripts/buildr-git.rb"
+
+After that you can use
+    git apache command --help
+
+EXTENDING YOUR WORKFLOW:
+
+You can create your own gitflow commands, to adapt your development
+workflow.
+
+Simply create a ruby script somewhere say ~/.buildr/gitflow.rb
+And alias it in your local repo:
+
+    git config alias.flow '!'"ruby ~/.buildr/gitflow.rb"
+    git config alias.work '!'"ruby ~/.buildr/gitflow.rb my-flow sub-work"
+
+A sample command would look like this.. (you may want to look at buildr-git.rb)
+
+    #!/usr/bin/env ruby
+    require /path/to/gitflow.rb
+
+    class MyCommand < GitFlow/'my-flow'
+
+      @help = "Summary to be displayed when listing commands"
+      @documentation = "Very long help that will be paged if necessary. (for --help)"
+
+      # takes an openstruct to place default values and option values.
+      # returns an array of arguments given to optparse.on
+      def options(opts)
+        opts.something = 'default'
+        [
+         ['--name NAME', lambda { |n| opts.name = n }],
+         ['--yes', lambda { |n| opts.yes = true }]
+        ]
+      end
+
+      # takes the opts openstruct after options have been parsed and
+      # an argv array with non-option arguments.
+      def execute(opts, argv)
+        # you can run another command using
+        run('other-command', '--using-this', 'arg')
+        some = git('config', '--get', 'some.property').chomp rescue nil
+        page { puts "This will be paged on terminal if needed" }
+      end
+
+      class SubCommand < MyCommand/'sub-work'
+        ... # implement a subcommand
+      end
+
+    end
+
+You would then get help for your command with
+
+    git flow my-flow --help
+    git work --help
+
+Using gitflow you can customize per-project git interface.
+
+HELP
+
+  # Pager from http://nex-3.com/posts/73-git-style-automatic-paging-in-ruby
+  def pager
+    return if RUBY_PLATFORM =~ /win32/
+    return unless STDOUT.tty?
+
+    read, write = IO.pipe
+
+    unless Kernel.fork # Child process
+      STDOUT.reopen(write)
+      STDERR.reopen(write) if STDERR.tty?
+      read.close
+      write.close
+      return
+    end
+
+    # Parent process, become pager
+    STDIN.reopen(read)
+    read.close
+    write.close
+
+    ENV['LESS'] = 'FSRX' # Don't page if the input is short enough
+
+    Kernel.select [STDIN] # Wait until we have input before we start the pager
+    pager = ENV['PAGER'] || 'less'
+    exec pager rescue exec '/bin/sh', '-c', pager
+  end
+
+  # Return a class to be extended in order to register a GitFlow command
+  # if command name is nil, it will be registered as the top level command.
+  # Classes implementing commands also provide this method, allowing for
+  # sub-command creation.
+  def /(command_name)
+    command_name = command_name.to_s unless command_name.nil?
+    cls = Class.new { include GitFlow::Mixin }
+    (class << cls; self; end).module_eval do
+      attr_accessor :help, :documentation, :command
+      define_method(:/) do |subcommand|
+        raise "Subcommand cannot be nil" unless subcommand
+        GitFlow/([command_name, subcommand].compact.join(' '))
+      end
+      define_method(:inherited) do |subclass|
+        subclass.command = command_name
+        GitFlow.commands[command_name] = subclass
+      end
+    end
+    cls
+  end
+
+  def commands
+    @commands ||= Hash.new
+  end
+
+  def optparse
+    optparse = opt = OptionParser.new
+    opt.separator ' '
+    opt.separator 'OPTIONS'
+    opt.separator ' '
+    opt.on('-h', '--help', 'Display this help') do
+      GitFlow.pager; puts opt; throw :exit
+    end
+    opt.on('--trace', 'Display traces') { GitFlow.trace = true }
+    optparse
+  end
+
+  def command(argv)
+    cmds = []
+    argv.each_with_index do |arg, i|
+      arg = argv[0..i].join(' ')
+      cmds << commands[arg] if commands.key?(arg)
+    end
+    cmds.last || commands[nil]
+  end
+
+  def run(*argv)
+    catch :exit do
+      command = self.command(argv).new
+      argv = argv[command.class.command.split.length..-1] if command.class.command
+      parser = optparse
+      parser.banner = "Usage: #{GitFlow.program} #{command.class.command} [options]"
+      options = OpenStruct.new
+      if command.respond_to?(:options)
+        command.options(options).each { |args| parser.on(*args) }
+      end
+      if command.class.documentation && command.class.documentation != ''
+        parser.separator ' '
+        parser.separator command.class.documentation.split(/\n/)
+      end
+      parser.parse!(argv)
+      command.execute(options, argv)
+    end
+  end
+
+  module Mixin
+    include FileUtils
+
+    # Override this method in your command class if it
+    # needs to parse command line options.
+    #
+    # This method takes an openstruct object as argument
+    # allowing you to store default values on it, and
+    # set option values.
+    #
+    # The return value must be an array of arguments
+    # given to optparse.on
+    def options(opt)
+      []
+    end
+
+    # Override this method in your command class to implement
+    # the command.
+    # First argument is the openstruct object after
+    # it has been populated by the option parser.
+    # Second argument is the array of non-option arguments.
+    def execute(opt, argv)
+      fail "#{self.class.command} not implemented"
+    end
+
+    # Run the command line given on argv
+    def run(*argv, &block)
+      GitFlow.run(*argv, &block)
+    end
+
+    # Yield paging the blocks output if necessary.
+    def page
+      GitFlow.pager
+      yield
+    end
+
+    def trace(*str)
+      STDERR.puts(*str) if GitFlow.trace
+    end
+
+    def git(*args)
+      cmd = 'git ' + args.map { |arg| arg[' '] ? %Q{"#{arg}"} : arg }.join(' ')
+      trace cmd
+      `#{cmd}`.tap {
+        fail "GIT command `#{cmd}` failed with status #{$?.exitstatus}" unless $?.exitstatus == 0
+      }
+    end
+
+    def sh(*args)
+      `#{args.join(' ')}`.tap {
+        fail "Shell command `#{args.join(' ')}` failed with status #{$?.exitstatus}" unless $?.exitstatus == 0
+      }
+    end
+
+    def expand_path(path, dir=Dir.pwd)
+      File.expand_path(path, dir)
+    end
+  end
+
+  class NoSuchCommand < GitFlow/nil
+    @documentation = HELP
+
+    def execute(opts, argv)
+      page do
+        puts "Command not found: #{argv.join(' ').inspect}"
+        puts "Try `#{GitFlow.program} help` to obtain a list of commands."
+      end
+    end
+  end
+
+  class HelpCommand < GitFlow/:help
+    @help = "Display help for a command or show command list"
+    @documentation = "Displays help for the command given as argument"
+
+    def execute(opts, argv)
+      if argv.empty?
+        opt = GitFlow.optparse
+        opt.banner = "Usage: #{GitFlow.program} command [options]"
+        opt.separator ' '
+        opt.separator 'COMMANDS'
+        opt.separator ' '
+        commands = GitFlow.commands.map { |name, cls| [nil, name, cls.help] }.
+          sort_by { |a| a[1] || '' }
+        commands.each { |a| opt.separator("%-2s%-25s%s" % a) if a[1] }
+        opt.separator ' '
+        opt.separator 'You can also obtain help for any command giving it --help.'
+        page { puts opt }
+      else
+        run(*(argv + ['--help']))
+      end
+    end
+  end
+
+end
+
+at_exit { GitFlow.run(*ARGV) if GitFlow.should_run }

data/lib/git_bpf/lib/repository.rb

@@ -0,0 +1,104 @@
+require 'git_bpf/lib/gitflow'
+require 'git_bpf/lib/git-helpers'
+
+#
+#
+#
+class Repository
+  extend GitFlow::Mixin
+
+  include GitHelpersMixin
+
+  attr_accessor :ctx, :remote_name, :path, :git_dir
+
+  def initialize(path)
+    path = File.expand_path(path)
+    git_dir = File.join(path, '.git')
+
+    if not File.directory? git_dir
+      terminate "#{path} is not a git repository."
+    end
+
+    self.git_dir = git_dir
+    self.path = path
+    self.ctx = [
+      "--git-dir=#{File.expand_path(git_dir)}",
+      "--work-tree=#{File.expand_path(path)}"
+    ]
+
+  end
+
+  def fetch(remote)
+    self.cmd("fetch", "--quiet", remote)
+  end
+
+  def remoteUrl(name)
+    begin
+      config(false, "--get", "remote.#{name}.url").chomp
+    rescue
+      terminate "No remote named '#{name}' in repository: #{self.path}."
+    end
+  end
+
+  def cmd(*args)
+    self.class.git(*(self.ctx + args))
+  end
+
+  def config(local, *args)
+    return nil if args.empty?
+
+    command = ["config"]
+    command.push "--local" if local
+    command += args
+
+    cmd(*(self.ctx + command))
+  end
+
+  def head
+    begin
+      cmd("rev-parse", "--quiet", "--abbrev-ref", "--verify", "HEAD")
+    rescue
+      return ''
+    end
+  end
+
+  def ref?(ref)
+    begin
+      cmd('show-ref', '--tags', '--heads', ref)
+    rescue
+      return false
+    end
+    return true
+  end
+
+  def branch?(branch, remote = nil)
+    if remote != nil
+      ref = "refs/remotes/#{remote}/#{branch}"
+    else
+      ref = (branch.include? "refs/heads/") ? branch : "refs/heads/#{branch}"
+    end
+
+    begin
+      cmd('show-ref', '--verify', '--quiet', ref)
+    rescue
+      return false
+    end
+    return true
+  end
+
+  def self.clone(url, dest)
+    git('clone', url, dest)
+    Repository.new dest
+  end
+
+  def self.init(dir, *args)
+    ctx = [
+      "--git-dir=#{File.join(dir, '.git')}",
+      "--work-tree=#{dir}",
+    ]
+    command = ['init'] + args
+    git(*(ctx + command))
+    Repository.new dir
+  end
+end
+

data/lib/git_bpf/version.rb

@@ -0,0 +1,3 @@
+module GitBpf
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification 
+name: git_bpf
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- tnightingale
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-03-25 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        version: "1.3"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: A collection of commands to help with implementing the branch-per-feature git development workflow.
+email: 
+- tom@affinitybridge.com
+executables: 
+- _git-bpf
+- git-bpf-init
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/_git-bpf
+- bin/git-bpf-init
+- git_bpf.gemspec
+- lib/git-bpf.rb
+- lib/git_bpf.rb
+- lib/git_bpf/commands/init.rb
+- lib/git_bpf/commands/recreate-branch.rb
+- lib/git_bpf/commands/share-rerere-cache.rb
+- lib/git_bpf/hooks/post-checkout.rb
+- lib/git_bpf/hooks/post-merge.rb
+- lib/git_bpf/lib/git-helpers.rb
+- lib/git_bpf/lib/gitflow.rb
+- lib/git_bpf/lib/repository.rb
+- lib/git_bpf/version.rb
+has_rdoc: true
+homepage: https://github.com/affinitybridge/git-bpf
+licenses: 
+- BSD
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Git branch-per-feature helper commands.
+test_files: []
+