git-icing

#!/usr/bin/ruby
#
# Some extra icing on top of git cherry's tasty cake ...
#
#   - Allow blacklisting of commits which should never be upstreamed,
#     via the git-notes(1) mechanism.  To blacklist a commit from being
#     upstreamed to any branch:
#
#         git notes --ref=upstreaming add -m'skip: all' $sha
#
#     or to blacklist from being upstreamed to specific branches (currently
#     only works when the upstream branch is explicitly provided):
#
#         git notes --ref=upstreaming add    -m'skip: upstream-branch' $sha
#         git notes --ref=upstreaming append -m'skip: another-branch'  $sha
#         git notes --ref=upstreaming append -m'skip: /branch-regexp/' $sha
#
#     It is strongly recommended that you also include justification for
#     why this commit should not be upstreamed.  You can place free-form
#     text in the note, as long as the 'skip: ' line is preserved, with
#     no indentation.  To edit the note:
#
#         git notes --ref=upstreaming edit $sha
#
#     To remove from the blacklist:
#
#         git notes --ref=upstreaming remove $sha
#
#     To push / pull the blacklist notes between git repositories, see:
#
#         http://stackoverflow.com/questions/12055303/merging-git-notes-when-there-are-merge-conflicts-in-them/
#
#   - Categorise and colour-code commits.  The first field of each
#     line output by `git cherry' is extended to show more than just
#     `+' and `-'.  Run `git icing --help' to show all possibilities.

require 'optparse'
require 'open3'
require 'shellwords'

# This would make the code nicer, but let's minimise dependencies instead ...
# require 'term/ansicolor'
# include Term::ANSIColor

CATEGORIES = [
  [ '+',  1,   '31', 'not yet upstream'                                     ],
  [ '!',  1,   '35', 'still needs to be upstreamed, tracked on a TODO list' ],
  [ '.?', 1, '1;30', 'upstream *and* blacklisted?!'                         ],
  [ '!?', 1, '1;30', 'upstream *and* marked as a TODO?'                     ],
  [ '.',  2, '1;30', 'blacklisted - should not be pushed to this upstream'  ],
  [ '?',  2,   '33', 'not yet upstream, with unparseable note'              ],
  [ '-',  3,   '32', 'already upstream'                                     ],
  [ '#',  3,   '36', 'already upstream with an annotation note'             ],
]

CATEGORIES_BY_PREFIX = CATEGORIES.inject({}) { |h, new| h[new[0]] = new[1, 3]; h }

$verbosity = 1
$summary = false

def output(level, colour, msg)
  return unless level <= $verbosity

  if STDOUT.tty? and colour
    msg = "\033[#{colour}m#{msg}\033[0m"
  end
  puts msg
end

def upstreaming_note(sha)
  ENV['LANG'] = 'C'
  cmd = [ 'git', 'notes', '--ref=upstreaming', 'show', sha ]
  out = nil
  Open3.popen3(*cmd) do |stdin, stdout, stderr, wait_thread|
    out = stdout.readlines().join('')
    err = stderr.readlines().join('')
    status = wait_thread.value
    return nil if err =~ /No note found for object/
    unless status.success?
      raise cmd.shelljoin + " exited with status #{status.exitstatus}: #{err}"
    end
    unless err.empty?
      raise cmd.shelljoin + " outputted to STDERR: #{err}"
    end
  end
  out
end

def blacklisted(note, upstream_branch)
  skippers = note.split("\n").grep(/^skip: (.+?)\s*$/m) { |x| $1 }
  for skipper in skippers
    return true if skipper == 'all'
    if upstream_branch
      skipper = Regexp.new($1) if skipper =~ %r{^/(.+)/$}
      return true if skipper === upstream_branch
    end
  end
  false
end

def parse_options
  parser = OptionParser.new do |opts|
    opts.banner = "usage: git icing [options] [git cherry args]\n\n"
    opts.on("-v", "--verbosity [N]", Integer, "Set verbosity level") do |verbosity|
      $verbosity = verbosity || 2
    end
    opts.on("-s", "--summary", Integer, "Show summary") do
      $summary = true
    end
  end

  def parser.help
    rows = CATEGORIES.map do |field, level, colour, description|
      field = "%-2s" % field
      if STDOUT.tty?
        "  \e[#{colour}m#{field}\e[0m  |     #{level}     | \e[#{colour}m#{description}\e[0m"
      else
        "  #{field}  |     #{level}     | #{description}"
      end
    end
    super + <<EOF + rows.join("\n")

first | verbosity | description of
field |   level   | classification
------+-----------+-----------------------------------------------------
EOF
  end

  parser.parse!
end

def classify_line(upstream_branch, line)
  case line
  when /^- ([0-9a-f]{32})/
    # An equivalent change with the same patch-id is already upstream
    sha = $1
    note = upstreaming_note(sha)
    if note
      if blacklisted(note, upstream_branch)
        # Upstream *and* blacklisted?!
        return '.?'
      elsif note =~ /\bTODO\b/
        # Upstream *and* marked as a TODO?!
        return '!?'
      else
        # Upstream and has an annotation note.
        return '#'
      end
    else
      # Already upstream.
      return '-'
    end
  when /^\+ ([0-9a-f]{32})/
    # Not upstream yet
    sha = $1
    note = upstreaming_note(sha)
    if note
      if blacklisted(note, upstream_branch)
        # We never want to upstream this
        return '.'
      elsif note =~ /\bTODO\b/
        # Not upstream but tracked on a TODO list elsewhere
        return '!'
      else
        # Note had unrecognised format
        return '?'
      end
    else
      # Not upstream and no note
      return '+'
    end
  else
    # Unrecognised output; leave alone
    return nil
  end
end  

def category_colour(category)
  matched = CATEGORIES_BY_PREFIX[category]
  abort "Couldn't understand category '#{category}'" unless matched
  return matched[1]
end

def category_level(category)
  matched = CATEGORIES_BY_PREFIX[category]
  return 1 unless matched
  return matched[0]
end

def cherry(upstream_branch)
  totals = Hash.new(0)
  totals[:all] = 0

  IO.popen(["git", "cherry", "-v"] + ARGV) do |out|
    out.each_line do |line|
      line.chomp!
      category = classify_line(upstream_branch, line)
      colour = nil
      if category
        line[0] = category
        if STDOUT.tty?
          colour = category_colour(category)
        end
      end
      level = category_level(category)
      output level, colour, line
      totals[line[0..1].strip] += 1
      totals[:all] += 1
    end
  end

  exitcode = $?.exitstatus
  exit(exitcode) unless exitcode == 0

  return totals
end

def status_description(status)
  CATEGORIES_BY_PREFIX[status][2] or raise "unrecognised status '#{status}'"
end

def needs_work?(status)
  case status
  when '-', '.'
    false
  when '+', '!', /^.\?$/
    true
  else
    raise "unrecognised status '#{status}'"
  end
end

def show_summary(totals)
  all = totals.delete(:all)
  if all == 0
    puts "No commits found."
    exit 0
  end

  remaining, done = totals.sort_by { |status, count| -count }.partition {|t| needs_work?(t[0])}
  totals[:done]      = done     .inject(0) { |acc, new| acc += new[1] }
  totals[:remaining] = remaining.inject(0) { |acc, new| acc += new[1] }
  total = totals[:done] + totals[:remaining]
  percent = totals[:done].to_f / total * 100

  puts unless $verbosity == 0

  puts <<EOF
Summary
=======

#{totals[:done]} commits processed#{done.empty? ? '' : ':'}
EOF
  done.each do |status, count|
    puts "  %4d %2s" % [count, status_description(status)]
  end

  puts <<EOF

#{totals[:remaining]} commits remaining#{remaining.empty? ? '' : ':'}
EOF
  remaining.each do |status, count|
    puts "  %4d %2s" % [count, status_description(status)]
  end
  

  puts <<EOF % [totals[:done], total, percent]

Progress: %d / %d commits (%d%%)
EOF
end

def main
  parse_options
  upstream_branch = ARGV[0]

  trap "PIPE" do
    exit 1
  end

  totals = cherry(upstream_branch)
  if $summary
    show_summary(totals)
  end
end

main