git-author-report 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 53e61550adce28323504c93920a1c75d8e45d6f85e7afb20235a31a4cc0d4016
+  data.tar.gz: 41918e48a7553b4134efde8a642e97ff035c253d1f5a4e96bdf04b742e3c63c1
+SHA512:
+  metadata.gz: d473d8b1f9adbc2b6ac34265c0e5981780fd87e3870099eef5c23323dc59f836023616e23d2a0d40c7ca6a67e3bb06c32dec9e12368cb04c32a12f8bb7df4c8b
+  data.tar.gz: c4740e7a739f9521a5afc000052b9957226d5381a11ff7e7b059384c4726f149d5fd4f7780687e637769400739450585c22a5b051101a170267eff92a140bcff

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/bin/git-report

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+# git-report runs on whatever Ruby is on PATH -- including the stock macOS
+# system Ruby -- so users don't have to install Ruby. It has no gem
+# dependencies: everything it needs comes from the Ruby standard library, so
+# there is nothing to install and no first-run vendoring step.
+
+script_dir = File.expand_path(File.dirname(__FILE__))
+
+require File.join(script_dir, '../lib/version.rb')
+
+if ['-v', '--version'].include?(ARGV[0])
+  puts "git-report #{Git::Report::VERSION}"
+  exit 0
+end
+
+require File.join(script_dir, '../lib/git_report.rb')
+
+git_report = Git::Report.new.retrieve_stats
+puts git_report.stats

data/bin/git_add_alias_report

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+
+pushd `dirname $0` > /dev/null
+BIN_DIR=`pwd`
+popd > /dev/null
+
+git config --global alias.report "!exec \"$BIN_DIR/git-report\""
+echo '#################################'
+echo '# "git report" has been added   #'
+echo '# Run: git report               #'
+echo '#################################'

data/bin/git_remove_alias_report

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+git config --global --unset alias.report
+echo '###################################'
+echo '# "git report" has been removed   #'
+echo '###################################'

data/ext/git_report/Makefile

@@ -0,0 +1,4 @@
+all:
+	true
+install:
+	true

data/ext/git_report/extconf.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+
+find_executable('bash')
+find_executable('git')
+find_executable('make')
+
+# Trick Rubygems into thinking the generated artifact was compiled
+compile = File.join(Dir.pwd, "git_report.#{RbConfig::CONFIG['DLEXT']}")
+File.write(compile, '')
+
+# Install "git report"
+puts `../../bin/git_add_alias_report`
+
+# Trick Rubygems into thinking the Makefile was executed
+$makefile_created = true

data/lib/git/author.rb

@@ -0,0 +1,77 @@
+# keys of report are the authors, the values contains the report data:
+#  * commits, +LOC, -LOC, LOC,
+require 'shellwords'
+
+module Git
+  # Author class - represents a git contributor with their statistics
+  class Author
+    # name: String - the name of the author
+    # emails: Set<String> - a list of email addresses
+    # commits: Fixnum - number of commits by this author
+    # loc_added: Fixnum  - number of lines this author added over time
+    # loc_deleted: Fixnum  - number of lines this author deleted over time
+    # loc: Fixnum - number of lines in the current codebase this author added
+    # files: Fixnum - number of files
+    attr_reader :name, :emails, :commits, :loc_added, :loc_deleted, :loc, :files
+
+    #
+    def initialize(name:, emails: '', commits: 0)
+      @name = name
+      @emails = Set.new Array(emails)
+      @commits = commits.to_i
+      @loc = 0
+      @loc_added = 0
+      @loc_deleted = 0
+      @files = 0
+    end
+
+    def merge(other)
+      return unless mergable?(other)
+      @emails.merge other.emails
+      @commits += other.commits
+      self
+    end
+
+    def mergable?(other)
+      name == other.name
+    end
+
+    def retrieve_loc_stats
+      # Run one git log per email in parallel, returning [added, deleted] per
+      # email. The instance-variable accumulation happens afterwards on this
+      # single thread, so the parallel blocks never race on @loc_added/@loc_deleted.
+      Git::Parallel.pmap(emails) do |email|
+        # Escape email to prevent command injection
+        escaped_email = Shellwords.escape(email)
+        numstat = `git log --author=#{escaped_email} \
+          --pretty=tformat: --numstat --no-merges`
+
+        # Skip if no commits found for this email
+        next if numstat.empty?
+
+        loc = numstat.split(/\n/).map do |numstat_line|
+          parts = numstat_line.scan(/\A(.*)\t(.*)\t/)[0]
+          parts ? parts.map(&:to_i) : nil
+        end.compact
+
+        # Skip if no valid data
+        next if loc.empty?
+
+        loc.transpose.map { |add_del_loc| add_del_loc.inject(&:+) }
+      end.each do |added_deleted|
+        next unless added_deleted
+        added, deleted = added_deleted
+        @loc_added += added if added
+        @loc_deleted += deleted if deleted
+      end
+    end
+
+    def loc=(loc)
+      @loc = loc.to_i
+    end
+
+    def files=(files)
+      @files = files.to_i
+    end
+  end
+end

data/lib/git/parallel.rb

@@ -0,0 +1,67 @@
+module Git
+  # Minimal parallel helpers built on the Ruby standard library, replacing the
+  # former `pmap` gem. The work these drive is I/O-bound -- every block shells
+  # out to git -- so threads give real concurrency even under MRI's GVL: a
+  # subprocess spawned by backticks runs outside the lock while other threads
+  # proceed. Keeping this in-tree is what lets git-report run on stock Ruby
+  # with no gems to install.
+  module Parallel
+    # Upper bound on worker threads, and therefore on how many git subprocesses
+    # run at once. This cap is the whole point: a repository with thousands of
+    # authors must NOT spawn a thread (and a `git log`) per author -- that would
+    # swamp the machine. 64 matches the historical default of the pmap gem this
+    # replaced, so throughput on large repositories is unchanged.
+    MAX_THREADS = 64
+
+    module_function
+
+    # Like Enumerable#map, but runs the block for each element across a bounded
+    # pool of threads and returns the results in the original order.
+    def pmap(enum, &block)
+      results = []
+      mutex = Mutex.new
+      process(enum) do |item, index|
+        value = block.call(item)
+        mutex.synchronize { results[index] = value }
+      end
+      results
+    end
+
+    # Like Enumerable#each, but runs the block for each element across a bounded
+    # pool of threads. Returns the original enumerable once all work is done.
+    def peach(enum, &block)
+      process(enum) { |item, _index| block.call(item) }
+      enum
+    end
+
+    # Drains every [item, index] pair through at most MAX_THREADS workers. All
+    # jobs are enqueued up front, so each worker simply pops until the queue is
+    # empty and then exits -- no poison pills needed. Joining via Thread#value
+    # propagates the first exception raised in any worker to the caller.
+    def process(enum)
+      items = enum.to_a
+      queue = Queue.new
+      items.each_with_index { |item, index| queue << [item, index] }
+
+      worker_count = [items.size, MAX_THREADS].min
+      workers = Array.new(worker_count) do
+        Thread.new do
+          # We re-raise from Thread#value below, so silence Ruby's automatic
+          # "terminated with exception" dump to stderr -- it would otherwise
+          # print the same error twice.
+          Thread.current.report_on_exception = false
+          loop do
+            begin
+              item, index = queue.pop(true)
+            rescue ThreadError
+              break # queue drained
+            end
+            yield item, index
+          end
+        end
+      end
+      workers.each(&:value)
+    end
+    private_class_method :process
+  end
+end

data/lib/git/report.rb

@@ -0,0 +1,169 @@
+# Git report module for analyzing repository statistics
+require 'shellwords'
+
+module Git
+  # Report class - generates statistics about git repository contributors
+  # Analyzes commits, lines of code, and file changes per author
+  class Report
+    attr_reader :authors
+
+    NAME = /\A[^(]*\((.*)\s*\d{4}-\d\d-\d\d \d\d:\d\d:\d\d [+-]\d{4}\s+\d+\)/
+    COMMITS_NAME_EMAIL = /\A\s*(\d*)\t(.*) <(.*)>/
+    HEADER = {
+      name:    'Name',
+      loc:     'LOC',
+      commits: 'Commits',
+      files:   'files',
+      loc_add: '+LOC',
+      loc_del: '-LOC'
+    }.freeze
+
+    def initialize
+      @authors = []
+    end
+
+    def retrieve_stats
+      verify_git_repository
+      parse_shortlog
+      parse_blame
+      self
+    end
+    
+
+
+    def parse_shortlog
+      # First pass: get all authors (including those with only merges).
+      # HEAD is required: without an explicit revision and with a non-tty
+      # stdin (as when run via the `git report` alias) git shortlog reads the
+      # commit list from stdin and would otherwise return nothing.
+      `git shortlog -se HEAD`.split(/\n/).map do |shortlog_line|
+        add shortlog_line, commits: 0
+      end
+
+      # Second pass: get actual commit counts (excluding merges)
+      `git shortlog -se --no-merges HEAD`.split(/\n/).map do |shortlog_line|
+        add shortlog_line
+      end
+
+      Git::Parallel.peach(authors, &:retrieve_loc_stats)
+    end
+
+    def parse_blame
+      ls_files        = `git ls-files`.split(/\n/)
+      ignore_files    = `git status --porcelain`.split(/\n/)
+      ignore_files.map! { |file| file[3..-1] }
+      ls_files -= ignore_files
+
+      file_lists      = ls_files.each_slice((ls_files.count**0.5).ceil).to_a
+      names_loc_count = Hash.new(0)
+      names_files     = {}
+
+      Git::Parallel.peach(file_lists) do |files|
+        files.each do |file|
+          escaped_file = Shellwords.escape(file)
+          blame = `git blame -w #{escaped_file} 2> /dev/null`
+          next if blame.empty?
+          blame.unpack('C*').pack('C*').split(/\n/).map do |line|
+            name = line.match(NAME)[1].strip.force_encoding('UTF-8')
+            names_loc_count[name] += 1
+            names_files[name] ||= Set.new
+            names_files[name] << file
+          end
+        end
+      end
+      # find_author can be nil for lines git attributes to someone outside the
+      # shortlog history (e.g. "Not Committed Yet" for staged-but-uncommitted
+      # changes), so skip those rather than crash.
+      names_loc_count.each { |name, loc| find_author(name)&.loc = loc }
+      names_files.each { |name, files| find_author(name)&.files = files.size }
+    end
+
+    def add(line, opts = {})
+      shortlog_line = format_shortlog_line(*line.scan(COMMITS_NAME_EMAIL)[0])
+      shortlog_line[:commits] = opts[:commits] if opts[:commits]
+      candidate = Author.new(**shortlog_line)
+      @authors << candidate unless add_author candidate
+    end
+
+    def add_author(candidate)
+      merged = false
+      @authors.each do |author|
+        if author.mergable?(candidate)
+          author.merge(candidate)
+          merged = true
+        end
+      end
+      merged
+    end
+
+    def find_author(name)
+      @authors.find { |author| author.name == name }
+    end
+
+    def stats
+      authors.sort! { |this, other| other.name  <=> this.name }
+      authors.sort! { |this, other| other.files <=> this.files }
+      authors.sort! { |this, other| other.loc   <=> this.loc }
+
+      name_length =    authors.map { |auth| auth.name.length }.max
+      loc_length =     authors.map { |auth| auth.loc.to_s.length }.max
+      commits_length = authors.map { |auth| auth.commits.to_s.length }.max
+      files_length =   authors.map { |auth| auth.files.to_s.length }.max
+      loc_add_length = authors.map { |auth| auth.loc_added.to_s.length }.max
+      loc_del_length = authors.map { |auth| auth.loc_deleted.to_s.length }.max
+
+      name_length =    [name_length, HEADER[:name].length].max
+      loc_length =     [loc_length, HEADER[:loc].length].max
+      commits_length = [commits_length, HEADER[:commits].length].max
+      files_length =   [files_length, HEADER[:files].length].max
+      loc_add_length = [loc_add_length, HEADER[:loc_add].length].max
+      loc_del_length = [loc_del_length, HEADER[:loc_del].length].max
+
+      lines = []
+      hr = '+' + ('-' * name_length) + '--'
+      hr += '+' + ('-' * loc_length) + '--'
+      hr += '+' + ('-' * commits_length) + '--'
+      hr += '+' + ('-' * files_length) + '--'
+      hr += '+' + ('-' * loc_add_length) + '--'
+      hr += '+' + ('-' * loc_del_length) + '--+'
+
+      head =  "| #{HEADER[:name].ljust(name_length)} "
+      head += "| #{HEADER[:loc].rjust(loc_length)} "
+      head += "| #{HEADER[:commits].rjust(commits_length)} "
+      head += "| #{HEADER[:files].rjust(files_length)} "
+      head += "| #{HEADER[:loc_add].rjust(loc_add_length)} "
+      head += "| #{HEADER[:loc_del].to_s.rjust(loc_del_length)} |"
+
+      lines << hr
+      lines << head
+      lines << hr
+      authors.each do |author|
+        # Skip authors with no contributions
+        next if [author.loc, author.commits, author.files, author.loc_added,
+                 author.loc_deleted].all?(&:zero?)
+                 
+        line =  "| #{author.name.unicode_normalize.ljust(name_length)} "
+        line += "| #{author.loc.to_s.rjust(loc_length)} "
+        line += "| #{author.commits.to_s.rjust(commits_length)} "
+        line += "| #{author.files.to_s.rjust(files_length)} "
+        line += "| #{author.loc_added.to_s.rjust(loc_add_length)} "
+        line += "| #{author.loc_deleted.to_s.rjust(loc_del_length)} |"
+        lines << line
+      end
+      lines << hr
+      lines
+    end
+
+    private
+
+    def verify_git_repository
+      unless system('git rev-parse --git-dir > /dev/null 2>&1')
+        raise "Not a git repository (or any of the parent directories)"
+      end
+    end
+
+    def format_shortlog_line(commits, name, email)
+      { name: name, emails: email, commits: commits.to_i }
+    end
+  end
+end

data/lib/git_report.rb

@@ -0,0 +1,8 @@
+require 'set'
+
+# Git module - contains classes for analyzing git repository statistics
+module Git
+  # Auto-load all classes in the git subdirectory (sorted for deterministic
+  # load order across platforms)
+  Dir[File.join(File.dirname(__FILE__), 'git', '**', '*.rb')].sort.each(&method(:require))
+end

data/lib/rubygems_plugin.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+Gem.pre_uninstall do |uninstaller|
+  bin_dir = uninstaller.spec.bin_dir
+  git_remove_alias_report = File.join(bin_dir, 'git_remove_alias_report')
+  puts `#{git_remove_alias_report}`
+end

data/lib/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Git
+  # Report carries the gem version, read from the VERSION file at the repo root.
+  class Report
+    VERSION_FILE = File.expand_path('../VERSION', __dir__)
+    VERSION = File.exist?(VERSION_FILE) ? File.read(VERSION_FILE).strip : 'unknown'
+  end
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: git-author-report
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Wolfgang Teuber
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: git-author-report is a command line tool, run as `git report`, that prints
+  a per-author breakdown of code contribution (surviving LOC, lifetime +/-LOC, commits,
+  files) as an ASCII table.
+email: knugie@gmx.net
+executables:
+- git-report
+extensions:
+- ext/git_report/extconf.rb
+extra_rdoc_files: []
+files:
+- VERSION
+- bin/git-report
+- bin/git_add_alias_report
+- bin/git_remove_alias_report
+- ext/git_report/Makefile
+- ext/git_report/extconf.rb
+- lib/git/author.rb
+- lib/git/parallel.rb
+- lib/git/report.rb
+- lib/git_report.rb
+- lib/rubygems_plugin.rb
+- lib/version.rb
+homepage: https://github.com/wteuber/git-author-report
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/wteuber/git-author-report
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Per-author contribution report for any git repository
+test_files: []