git-wtf

#!/usr/bin/env ruby

$debug = false

require 'yaml'
CONFIG_FILENAME = ".git-wtf"

begin
  require 'rubygems'
  require 'term/ansicolor'
  HAS_COLOR=true
  include Term::ANSIColor
rescue LoadError
  HAS_COLOR=false
end

class Numeric; def pluralize s; "#{to_s} #{s}" + (self != 1 ? "s" : "") end end

class Hash
  def leaves
    children = values.select { |v| v.is_a?(Hash) }
    children.length > 0 ? children.map { |c| c.leaves }.flatten : self
  end
end

def die s
  $stderr.puts "Error: #{s}"
  exit(-1)
end

COLOR_ATTRIBUTES = {
  0 => black,
  1 => red,
  2 => green,
  3 => yellow,
  4 => blue,
  5 => magenta,
  6 => cyan,
  7 => dark,
  8 => bold,
  9 => reset
} if HAS_COLOR

def cputs(string='')
  if HAS_COLOR
    COLOR_ATTRIBUTES.each { |num, color| string.gsub!("&|#{num}", color) }
  else
    string.gsub!(/&\|\d/, '')
  end
  puts string
end

def run_command(command)
  output = IO.popen(command, 'r').read

  if $debug
    cputs "-- begin run_command --"
    cputs "executing: #{command}"
    cputs "output:"
    cputs output
    cputs "-- end run_command --"
  end

  output
end

def commits_between from, to
  commits = run_command(%{ git log --pretty=format:"%h-%ae-%s" #{from}..#{to} }).split(/[\r\n]+/).map do |raw_commit|
    raw_commit_parts = raw_commit.split('-')

    {
      :hash    => raw_commit_parts.shift,
      :author  => raw_commit_parts.shift.split('@').first,
      :message => raw_commit_parts.join('-')
    }
  end
  
  max_author_size = commits.map { |c| c[:author].length }.sort.last
  
  commits.map do |commit|
    "[&|2%s&|9] &|8&|4%#{max_author_size}s&|9 %s" % [commit[:hash], commit[:author], commit[:message]]
  end
end

begin
  $config = YAML::load_file(CONFIG_FILENAME)
  raise 'invalid configuration format' unless $config["version_branches"].length > 0
rescue
  # cputs <<-CONFIG.gsub(/^  /, '')
  # Create a .git-wtf in your git repository directory that looks like:
  # --
  # version_branches:
  #   - stable-2.0
  # CONFIG
  # exit 1
  $config = { 'version_branches' => [] }
end

current_branch = File.read(File.join('.git', 'HEAD')).chomp.split('/').last

$branches = Dir[File.join('.git', 'refs', 'heads', '*')].inject({}) do |hash, ref|
  name    = File.basename(ref)
  rev     = File.read(ref).chomp
  current = (name == current_branch)
  version = $config["version_branches"].include?(name)
  remote  = run_command("git config --get branch.#{name}.remote").chomp
  merge   = run_command("git config --get branch.#{name}.merge").chomp.split('/').last

  hash.update({ name => {
    :name    => name,
    :rev     => rev,
    :current => current,
    :version => version,
    :merge   => { :remote => remote, :branch => merge }
  }})
end

$remotes = Dir[File.join('.git', 'refs', 'remotes', '*', '*')].inject({}) do |hash, ref|
  ref_parts = ref.split('/')
  name   = ref_parts.pop
  remote = ref_parts.pop
  rev    = File.read(ref).chomp
  hash[remote] ||= {}
  hash[remote][name] = { :name => name, :remote => remote, :rev => rev }
  hash
end

$branches.each do |name, branch|
  $branches[name][:parent] = begin
    merge  = branch[:merge] 
    remote = merge[:remote] == '.' ? $branches : $remotes[merge[:remote]]
    remote ? remote[merge[:branch]] : nil
  end
end

repo = {
  :master   => ($branches.values + $remotes['origin'].values).detect { |b| b[:name] == 'master' },
  :current  => $branches.values.detect { |b| b[:current] },
  :versions => $branches.values.select { |b| b[:version] },
  :features => $branches.values.select { |b| !(b[:version] || b[:name] == 'master') },
  :remotes  => $remotes
}

def branch_sync_status(local, remote, show_outgoing=true, show_incoming=true, good="in sync", bad="out of sync")
  outgoing = show_outgoing ? commits_between(remote[:rev], local[:rev])  : []
  incoming = show_incoming ? commits_between(local[:rev],  remote[:rev]) : []

  sync = (incoming.length == 0 && outgoing.length == 0)

  verb = case
    when incoming.length > 0 &&
         outgoing.length > 0 then 'merge'
    when incoming.length > 0 then 'pull'
    when outgoing.length > 0 then 'push'
    else nil
  end

  cputs sync ? "[x] #{good}" : "[ ] #{bad}"
  incoming.each { |c| cputs "    &|8&|3<&|9 #{c}" }
  outgoing.each { |c| cputs "    &|8&|3>&|9 #{c}" }
end

def name(branch)
  if $remotes.leaves.include?(branch)
    "#{branch[:remote]}/#{branch[:name]}"
  else
    "#{branch[:name]}"
  end
end

cputs "Local Branch: #{name(repo[:current])}"
branch_sync_status(repo[:current], repo[:current][:parent], true, true, "in sync with remote", "out of sync with remote (#{repo[:current][:parent][:remote]}/#{repo[:current][:parent][:name]})") if repo[:current][:parent]
cputs

if repo[:current] == repo[:master]
  if repo[:versions].length > 0
    cputs "Version branches:"
    repo[:versions].each do |branch|
      branch_sync_status(repo[:current], branch, false, true, "#{branch[:name]} is merged in", "#{branch[:name]} needs to be merged in")
    end
    cputs
  end
elsif repo[:versions].include?(repo[:current])
  master = repo[:master]
  cputs "Master Branch: #{name(master)}"
  branch_sync_status(repo[:current], master, true, false, "in sync", "#{name(repo[:current])} needs to be merged into master")
  cputs
end

if repo[:features].length > 0
  cputs "Feature branches:"
  repo[:features].each do |branch|
    branch_sync_status(repo[:current], branch, false, true, "#{branch[:name]} is merged in", "#{branch[:name]} needs to be merged in")
  end
end