git-related

#!/usr/bin/env ruby

require 'parseopt'

$since = '5-years-ago'
$threshold = 10
$patches = []
$rev_args = []
$show_commits = false
$roles = false
$base_rev = 'master'
$files = false

$persons = {}
$mailmaps = {}

$base_dir = %x[git rev-parse --show-toplevel].chomp

ROLE_MAP = {
  'signed-off-by' => :signer,
  'acked-by' => :acker,
  'reviewed-by' => :reviewer,
  'helped-by' => :helper,
  'mentored-by' => :mentor,
  'suggested-by' => :advisor,
  'cc' => :observer,
  'noticed-by' => :sentry,
  'tested-by' => :tester,
  'improved-by' => :enhancer,
  'thanks-to' => :helper,
  'based-on-patch-by' => :patcher,
  'based-on-a-patch-by' => :patcher,
  'contributions-by' => :contributor,
  'co-authored-by' => :coauthor,
  'requested-by' => :solicitor,
  'original-patch-by ' => :patcher,
}
ROLE_REGEX = /^([^ \t\n\[\]\(\):]+): ([^<>]+) <(\S+?)>$/

def get_mailmap(filename)
  return unless File.exists?(filename)
  n = /([^<>]+?)/
  e = /<(\S+)>/
  File.foreach(filename) do |line|
    case line.gsub(/\s*#.*$/, '')
    when /^(?:#{n})?(?:\s*#{e})?\s+#{e}$/
      $mailmaps[[nil, $3]] = [ $1, $2 ]
    when /^#{n}\s+#{e}(?:\s+#{n})?(?:\s+#{e})?$/
      $mailmaps[[$3, $4]] = [ $1, $2 ]
    end
  end
end

get_mailmap(File.join($base_dir, '.mailmap'))
mailmap_file = %x[git config mailmap.file].chomp
get_mailmap(mailmap_file)

opts = ParseOpt.new
opts.usage = 'git related [options] <files | rev-list options>'

opts.on('t', 'threshold', 'Minimum percentage threshold of participation') do |v|
  $threshold = v.to_i
end

opts.on('s', 'since', 'How far back to search for relevant commits') do |v|
  $since = v
end

opts.on('c', 'commits', 'List commits instead of persons') do |v|
  $show_commits = v
end

opts.on('r', 'roles', 'Display specific roles') do |v|
  $roles = v
end

opts.on('f', 'files', 'Gather file history (not blame)') do |v|
  $files = v
end

opts.parse

class Person

  attr_reader :roles

  def initialize(name, email)
    @name = name
    @email = email
    @commits = {}
    @roles = Hash.new(0)
  end

  def add_role(commit, role)
    @commits[commit] = true
    @roles[role] += 1
  end

  def weight
    @commits.size
  end

  def <=>(b)
    weight <=> b.weight
  end

  def to_s
    '%s <%s>' % [@name, @email]
  end

  def self.get(name, email)
    map = $mailmaps[[name, email]]
    map ||= $mailmaps[[nil, email]]
    map ||= $mailmaps[[name, nil]]
    map ||= []

    map_name, map_email = map
    name, email = [ map_name || name, map_email || email ]
    $persons[email.downcase] ||= Person.new(name, email)
  end

end

class Commit
  attr_accessor :boundary

  def initialize(id)
    @id = id
  end

  def parse(data)
    in_body = author = nil
    header, body = data.split("\n\n", 2)
    if header =~ /^author ([^<>]+) <(\S+)> /
      author = Person.get($1, $2)
      author.add_role(@id, :author)
    end
    return unless $roles
    trailer = body.split("\n\n").last
    trailer.scan(ROLE_REGEX) do
      person = Person.get($2, $3)
      role = ROLE_MAP[$1.downcase]
      next if role == :signer and person == author
      person.add_role(@id, role)
    end
  end

end

class Commits

  def initialize
    @items = {}
    @main_commits = {}
    @sources = Hash.new { |hash, key| hash[key] = [] }
  end

  def size
    @items.size
  end

  def each(&block)
    @items.each(&block)
  end

  def list
    @items.keys
  end

  def import
    return if @items.empty?
    IO.popen(%w[git cat-file --batch], 'r+', external_encoding: 'utf-8') do |pipe|
      pipe.write(@items.keys.join("\n"))
      pipe.close_write
      pipe.each do |line|
        if line =~ /^(\h{40}) commit (\d+)/
          id, len = $1, $2
          data = pipe.read($2.to_i)
          @items[id].parse(data)
        end
      end
    end
  end

  def get_blame(source, from, ranges)
    ranges = ranges.map { |range| '-L%u,+%u' % range }
    id = nil
    IO.popen(['git', 'blame', '--incremental', '-C', '-C',
              *ranges,
              '--since', $since, from + '~',
              '--', source], external_encoding: 'utf-8') do |pipe|
      pipe.each do |line|
        if line =~ /^\h{40}/
          id = $&
          @items[id] ||= Commit.new(id) if not @main_commits.include?(id)
        elsif line == "boundary\n"
          @items[id].boundary = true
        end
      end
    end
  end

  def scan(io)
    id = nil
    source = nil
    io.each do |line|
      case line
      when /^From (\h{40}) /, /^\0(\h{40})$/
        id = $1
        @main_commits[id] = true
      when /^---\s+(\S+)$/
        source = $1 != '/dev/null' ? $1[2..-1] : nil
      when /^@@ -(\d+)(?:,(\d+))?/
        next unless source and id
        start, len = [$1, $2]
        next if !len || len == '0'
        @sources[[source, id]] << [start, len]
      end
    end
  end

  def blame
    if not $files
      Dir.chdir($base_dir) do
        @sources.each do |(source, id), ranges|
          get_blame(source, id, ranges);
        end
      end
      @items.reject! { |_,commit| commit.boundary }
    else
      files = @sources.map { |(file, _), _| file }.uniq
      IO.popen(%w[git rev-list -n 30 --no-merges] + [$base_rev, '--'] + files) do |pipe|
        pipe.each(chomp: true) do |id|
          @items[id] ||= Commit.new(id) if not @main_commits.include?(id)
        end
      end
    end
  end

  def from_patches(files)
    files.each do |file|
      File.open(file) do |f|
        scan(f)
      end
    end
  end

  def from_rev_args(args)
    %x[git rev-parse --verify --quiet @{upstream}]
    default = $?.success? ? '@{upstream}' : 'master'
    revs = IO.popen(%W[git rev-parse --revs-only --default #{default} --symbolic] + args).readlines(chomp: true)

    if revs.size == 1
      r = revs[0]
      $base_rev = r
      r = '^' + r if r[0] != '-'
      args = [ '@', r ]
    else
      args = revs
      $base_rev = revs[1][1..-1]
    end

    if not $files
      IO.popen(%w[git log -C --format=%x00%H -p] + args) do |pipe|
        scan(pipe)
      end
    else
      IO.popen(%w[git log -C --format= --name-only] + args) do |pipe|
        pipe.each(chomp: true) do |file|
          @sources[[file, nil]] = true
        end
      end
    end
  end

end

ARGV.each do |e|
  if File.exists?(e)
    $patches << e
  else
    $rev_args << e
  end
end

commits = Commits.new
if $patches.empty?
  commits.from_rev_args($rev_args)
else
  commits.from_patches($patches)
end
commits.blame
commits.import

if $show_commits
  cmd = nil
  case $show_commits
  when 'raw'
    puts commits.list
  when 'full'
    cmd = %w[git log --patch --no-walk]
  when 'long'
    cmd = %w[git log --no-walk]
  else
    cmd = %w[git log --oneline --no-walk]
  end
  system(*cmd + commits.list) if cmd
  exit 0
end

$persons.values.sort.reverse.each do |person|
  percent = 100 * person.weight.to_f / commits.size
  next if percent < $threshold

  unless $roles
    summary = '%i%%' % percent.round
  else
    roles = person.roles.sort_by(&:last).reverse.map do |role, role_count|
      role_percent = (100 * role_count.to_f / commits.size).round
      next if role_percent == 0
      '%s: %i%%' % [role, role_percent]
    end
    summary = roles.compact.join(', ')
  end

  format = STDOUT.isatty ? "%s \e[1;34m(%s)\e[0m" : '%s (%s)'
  puts format % [person, summary]
end