git_helpers 0.1.0

data/gemspec.yml

@@ -0,0 +1,18 @@
+name: git_helpers
+summary: "Git helpers utilities"
+description: "Add status line 'gitstatus.rb' and diff enhancement 'diff-fancy.rb'"
+license: MIT
+authors: Damien Robert
+email: Damien.Olivier.Robert+gems@gmail.com
+homepage: https://github.com/DamienRobert/git_helpers#readme
+
+dependencies:
+  shell_helpers: ~> 0.1
+  drain: ~> 0.1
+  simplecolor: ~> 0.2
+development_dependencies:
+  bundler: "~> 1.10"
+  minitest: "~> 5.0"
+  rake: "~> 10"
+  rubygems-tasks: "~> 0.2"
+  yard: "~> 0.8"

data/git_helpers.gemspec

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+require 'yaml'
+
+Gem::Specification.new do |gem|
+  gemspec = YAML.load_file('gemspec.yml')
+
+  gem.name    = gemspec.fetch('name')
+  gem.version = gemspec.fetch('version') do
+                  lib_dir = File.join(File.dirname(__FILE__),'lib')
+                  $LOAD_PATH << lib_dir unless $LOAD_PATH.include?(lib_dir)
+
+                  require 'git_helpers/version'
+                  GitHelpers::VERSION
+                end
+
+  gem.summary     = gemspec['summary']
+  gem.description = gemspec['description']
+  gem.licenses    = Array(gemspec['license'])
+  gem.authors     = Array(gemspec['authors'])
+  gem.email       = gemspec['email']
+  gem.homepage    = gemspec['homepage']
+
+  glob = lambda { |patterns| gem.files & Dir[*patterns] }
+
+  gem.files = `git ls-files`.split($/)
+
+  `git submodule --quiet foreach --recursive pwd`.split($/).each do |submodule|
+    submodule.sub!("#{Dir.pwd}/",'')
+
+    Dir.chdir(submodule) do
+      `git ls-files`.split($/).map do |subpath|
+        gem.files << File.join(submodule,subpath)
+      end
+    end
+  end
+  gem.files = glob[gemspec['files']] if gemspec['files']
+
+  gem.executables = gemspec.fetch('executables') do
+    glob['bin/*'].map { |path| File.basename(path) }
+  end
+  gem.default_executable = gem.executables.first if Gem::VERSION < '1.7.'
+
+  gem.extensions       = glob[gemspec['extensions'] || 'ext/**/extconf.rb']
+  gem.extra_rdoc_files = glob[gemspec['extra_doc_files'] || '*.{txt,md}']
+
+  gem.require_paths = Array(gemspec.fetch('require_paths') {
+    %w[ext lib].select { |dir| File.directory?(dir) }
+  })
+
+  gem.requirements              = Array(gemspec['requirements'])
+  gem.required_ruby_version     = gemspec['required_ruby_version']
+  gem.required_rubygems_version = gemspec['required_rubygems_version']
+  gem.post_install_message      = gemspec['post_install_message']
+
+  split = lambda { |string| string.split(/,\s*/) }
+
+  if gemspec['dependencies']
+    gemspec['dependencies'].each do |name,versions|
+      gem.add_dependency(name,split[versions])
+    end
+  end
+
+  if gemspec['development_dependencies']
+    gemspec['development_dependencies'].each do |name,versions|
+      gem.add_development_dependency(name,split[versions])
+    end
+  end
+
+  gem.metadata['yard.run']='yri'
+end

data/lib/git_helpers.rb

@@ -0,0 +1,344 @@
+require 'git_helpers/version'
+require 'git_helpers/extra_helpers'
+require 'dr/base/bool'
+require 'pathname'
+
+module GitHelpers
+	#git functions helper
+	
+	#small library wrapping git; use rugged for more interesting things
+	class GitDir
+		attr_accessor :dir
+		def initialize(dir=".")
+			@dir=Pathname.new(dir.to_s).realpath
+		end
+
+		def to_s
+			@dir.to_s
+		end
+
+
+		#we could also use 'git -C #{@dir}' for each git invocation
+		def with_dir
+			Dir.chdir(@dir) { yield }
+		end
+
+		def all_files
+			with_dir do
+				%x/git ls-files -z/.split("\0")
+			end
+		end
+
+		#are we in a git folder?
+		def git?(quiet: false)
+			launch="git rev-parse"
+			launch=launch + " 2>/dev/null" if quiet
+			with_dir do
+				system launch
+				return Bool.to_bool($?)
+			end
+		end
+
+		#are we in .git/?
+		def gitdir?
+			with_dir do
+				return Bool.to_bool(%x/git rev-parse --is-inside-git-dir/)
+			end
+		end
+		#are we in the worktree?
+		def worktree?
+			with_dir do
+				return Bool.to_bool(%x/git rev-parse --is-inside-work-tree/)
+			end
+		end
+		#are we in a bare repo?
+		def bare?
+			with_dir do
+				return Bool.to_bool(%x/git rev-parse --is-bare-repository/)
+			end
+		end
+		
+		#return the absolute path of the toplevel
+		def toplevel
+			with_dir do
+				return Pathname.new(%x/git rev-parse --show-toplevel/.chomp)
+			end
+		end
+		#relative path from toplevel to @dir
+		def prefix
+			with_dir do
+				return Pathname.new(%x/git rev-parse --show-prefix/.chomp)
+			end
+		end
+		#return the relative path from @dir to the toplevel
+		def relative_toplevel
+			with_dir do
+				return Pathname.new(%x/git rev-parse --show-cdup/.chomp)
+			end
+		end
+		#get path to .git directory (can be relative or absolute)
+		def gitdir
+			with_dir do
+				return Pathname.new(%x/git rev-parse --git-dir/.chomp)
+			end
+		end
+
+		def with_toplevel(&b)
+			with_dir do
+				dir=relative_toplevel
+				if !dir.to_s.empty?
+					Dir.chdir(dir,&b)
+				else
+					warn "No toplevel found, executing inside dir #{@dir}"
+					with_dir(&b)
+				end
+			end
+		end
+
+		#return a list of submodules
+		def submodules
+			with_dir do
+				return %x/git submodule status/.each_line.map { |l| l.split[1] }
+			end
+		end
+
+		def get_config(*args)
+			with_dir do
+				return %x/git config #{args.shelljoin}/.chomp
+			end
+		end
+
+		def current_branch(always: true)
+			with_dir do
+				branchname= %x/git symbolic-ref -q --short HEAD/.chomp!
+				branchname||= %x/git rev-parse --verify HEAD/.chomp! if always
+				return branch(branchname)
+			end
+		end
+
+		def head
+				return branch('HEAD')
+		end
+
+		#return all branches that have an upstream
+		#if branches=:all look through all branches
+		def all_upstream_branches(branches)
+			#TODO
+			upstreams=%x!git for-each-ref --format='%(upstream:short)' refs/heads/branch/!
+		end
+
+		def get_topic_branches(*branches, complete: :local)
+			if branches.length >= 2
+				return branch(branches[0]), branch(branches[1])
+			elsif branches.length == 1
+				b=branch(branches[0])
+				if complete == :local
+					return current_branch, b
+				elsif complete == :remote
+					return b, b.upstream
+				else
+					fail "complete keyword should be :local or :remote"
+				end
+			else
+				c=current_branch
+				return c, c.upstream
+			end
+		end
+
+		def branch(branch="HEAD")
+			GitBranch.new(branch, dir: @self)
+		end
+
+		def branch_infos(*branches, local: false, remote: false, tags: false)
+			query=branches.map {|b| name_branch(b, method: 'full_name')}
+			query << 'refs/heads' if local
+			query << 'refs/remotes' if remote
+			query << 'refs/tags' if tags
+			r={}
+			format=%w(refname refname:short objecttype objectsize objectname upstream upstream:short upstream:track upstream:remotename upstream:remoteref push push:short push:remotename push:remoteref HEAD symref)
+			out=SH::Run.run_simple("git for-each-ref --format '#{format.map {|f| "%(#{f})"}.join(',')}, ' #{query.shelljoin}", chomp: :lines)
+			out.each do |l|
+				infos=l.split(',')
+				full_name=infos[0]
+				r[full_name]=Hash[format.zip(infos)]
+				type=if full_name.start_with?("refs/heads/")
+							:local
+						elsif full_name.start_with?("refs/remotes/")
+							:remote
+						elsif full_name.start_with?("refs/tags/")
+							:tags
+						end
+				name = case type
+						when :local
+							full_name.delete_prefix("refs/heads/")
+						when :remote
+							full_name.delete_prefix("refs/remotes/")
+						when :tags
+							full_name.delete_prefix("refs/tags/")
+						end
+				r[full_name][:type]=type
+				r[full_name][:name]=name
+			end
+			r
+		end
+
+		def name_branch(branch,*args)
+			self.branch(branch).name(*args)
+		end
+	end
+
+	extend self
+	add_instance_methods = lambda do |klass|
+		klass.instance_methods(false).each do |m|
+			define_method(m) do |*args,&b|
+				GitDir.new.public_send(m,*args,&b)
+			end
+		end
+	end
+	add_instance_methods.call(GitDir)
+	add_instance_methods.call(GitStats)
+	add_instance_methods.call(GitExtraInfos)
+
+	class GitBranch
+		attr_accessor :gitdir
+		attr_accessor :branch
+		attr_writer :infos
+
+		def initialize(branch="HEAD", dir: ".")
+			@gitdir=dir.is_a?(GitDir) ? dir : GitDir.new(dir)
+			@branch=branch
+		end
+
+		def new_branch(name)
+			self.class.new(name, @gitdir)
+		end
+
+		def to_s
+			@branch.to_s
+		end
+
+		def nil?
+			@branch.nil?
+		end
+
+		def shellescape
+			@branch.shellescape
+		end
+		
+		def infos
+			return @infos if @infos
+			infos=branch_infos
+			type=infos[:type]
+			if type == :local
+				rebase=gitdir.get_config("branch.#{name}.rebase")
+				rebase = false if rebase.empty?
+				rebase = true if rebase == "true"
+				infos[:rebase]=rebase
+			end
+			@infos=infos
+		end
+
+		def name(method: "name", always: true)
+			@gitdir.with_dir do
+				case method
+				when "sha1"
+					describe=%x"git rev-parse --short #{@branch.shellescape}".chomp!
+				when "describe"
+					describe=%x"git describe #{@branch.shellescape}".chomp!
+				when "contains"
+					describe=%x"git describe --contains #{@branch.shellescape}".chomp!
+				when "match"
+					describe=%x"git describe --tags --exact-match #{@branch.shellescape}".chomp!
+				when "topic"
+					describe=%x"git describe --all #{@branch.shellescape}".chomp!
+				when "branch"
+					describe=%x"git describe --contains --all #{@branch.shellescape}".chomp!
+				when "topic-fb" #try --all, then --contains all
+					describe=%x"git describe --all #{@branch.shellescape}".chomp!
+					describe=%x"git describe --contains --all #{@branch.shellescape}".chomp! if describe.nil? or describe.empty?
+				when "branch-fb" #try --contains all, then --all
+					describe=%x"git describe --contains --all #{@branch.shellescape}".chomp!
+					describe=%x"git describe --all #{@branch.shellescape}".chomp! if describe.nil? or describe.empty?
+				when "magic"
+					describe1=%x"git describe --contains --all #{@branch.shellescape}".chomp!
+					describe2=%x"git describe --all #{@branch.shellescape}".chomp!
+					describe= describe1.length < describe2.length ? describe1 : describe2
+					describe=describe1 if describe2.empty?
+					describe=describe2 if describe1.empty?
+				when "name"
+					describe=%x"git rev-parse --abbrev-ref --symbolic-full-name #{@branch.shellescape}".chomp!
+				when "full_name"
+					describe=%x"git rev-parse --symbolic-full-name #{@branch.shellescape}".chomp!
+				when "symbolic"
+					describe=%x"git rev-parse --symbolic #{@branch.shellescape}".chomp!
+				else
+					describe=%x/#{method}/.chomp! unless method.nil? or method.empty?
+				end
+				if (describe.nil? or describe.empty?) and always
+					describe=%x/git rev-parse --short #{@branch.shellescape}/.chomp!
+				end
+				return describe
+			end
+		end
+
+		def rebase?
+			@gitdir.with_dir do
+				rb=%x/git config --bool branch.#{@branch.shellescape}.rebase/.chomp!
+				rb||=%x/git config --bool pull.rebase/.chomp!
+				return rb=="true"
+			end
+		end
+
+		def remote
+			@gitdir.with_dir do
+				rm=%x/git config --get branch.#{@branch.shellescape}.remote/.chomp!
+				rm||="origin"
+				return rm
+			end
+		end
+
+		def push_remote
+			@gitdir.with_dir do
+				rm= %x/git config --get branch.#{@branch.shellescape}.pushRemote/.chomp! || 
+				%x/git config --get remote.pushDefault/.chomp! ||
+				remote
+				return rm
+			end
+		end
+
+		def upstream
+			@gitdir.with_dir do
+				up=%x/git rev-parse --abbrev-ref #{@branch.shellescape}@{u}/.chomp!
+				return new_branch(up)
+			end
+		end
+
+		def push
+			@gitdir.with_dir do
+				pu=%x/git rev-parse --abbrev-ref #{@branch.shellescape}@{push}/.chomp!
+				return new_branch(pu)
+			end
+		end
+
+		def hash
+			@hash||=`git rev-parse #{@branch.shellescape}`.chomp!
+		end
+
+		def ==(other)
+			@branch == other.branch && @gitdir=other.gitdir
+		end
+
+		#return upstream + push if push !=upstream
+		def related
+			up=upstream
+			pu=push
+			pu=new_branch(nil) if up==pu
+			return up, pu
+		end
+
+		def branch_infos
+			@gitdir.branch_infos(@branch).values.first
+		end
+	end
+
+end

data/lib/git_helpers/extra_helpers.rb

@@ -0,0 +1,359 @@
+require 'shellwords'
+require 'dr/sh'
+require 'dr/base/encoding'
+# require 'git_helpers' #if we are required directly
+
+module GitHelpers
+	DefaultLogOptions=["-M", "-C", "--no-color"].shelljoin
+	
+	module GitStats
+		#Note: stats-authors give the same result, should be faster, and handle mailcap
+		#inspired by git-mainline//git-rank-contributors
+		def stats_diff(logopts=nil)
+			lines = {}
+
+			with_dir do
+				author = nil
+				state = :pre_author
+				DR::Encoding.fix_utf8(`git log #{DefaultLogOptions} -p #{logopts}`).each_line do |l|
+					case
+					when (state == :pre_author || state == :post_author) && m=l[/Author: (.*)$/,1]
+						#TODO: using directly author=l[]... seems to only affect a block scoped author variable
+						author=m
+						state = :post_author
+						lines[author] ||= {added: 0, deleted: 0, all: 0}
+					when state == :post_author && l =~ /^\+\+\+\s/
+						state = :in_diff
+					when state == :in_diff && l =~ /^[\+\-]/
+						unless l=~ /^(\+\+\+|\-\-\-)\s/
+							lines[author][:all] += 1 
+							lines[author][:added] += 1	if l[0]=="+"
+							lines[author][:deleted] += 1 if l[0]=="-"
+						end
+					when state == :in_diff && l =~ /^commit /
+						state = :pre_author
+					end
+				end
+			end
+			lines
+		end
+
+		def output_stats_diff(logopts=nil)
+			lines=stats_diff(logopts)
+			lines.sort_by { |a, c| -c[:all] }.each do |a, c|
+				puts "#{a}: #{c[:all]} lines of diff (+#{c[:added]}/-#{c[:deleted]})"
+			end
+		end
+
+		# inspired by visionmedia//git-line-summary
+		def stats_lines(file)
+			#p file
+			with_dir do
+				out,_suc=SH.run_simple("git", "blame", "--line-porcelain", file, quiet: true)
+			end
+			r={}
+			begin
+			out.each_line do |l|
+					l.match(/^author (.*)/) do |m|
+						r[m[1]]||=0
+						r[m[1]]+=1
+					end
+				end
+			rescue => e
+				warn "Warning: #{e} on #{file}"
+			end
+			r
+		end
+
+		def stats_lines_all
+			r={}
+			all_files.select {|f| SH::Pathname.new(f).text? rescue false}.each do |f|
+				stats_lines(f).each do |k,v|
+					r[k]||=0
+					r[k]+=v
+				end
+			end
+			r
+		end
+
+		def output_stats_lines
+			stats=stats_lines_all
+			total=stats.values.sum
+			stats.sort_by{|k,v| -v}.each do |k,v|
+				puts "- #{k}: #{v} (#{"%2.1f%%" % (100*v/total.to_f)})"
+			end
+			puts "Total lines: #{total}"
+		end
+
+		#Inspired by https://github.com/esc/git-stats/blob/master/git-stats.sh
+		def stats_authors(logopts=nil, more: false)
+			require 'set'
+			#Exemple: --after=..., --before=...,
+			#  -w #word diff
+			#  -C --find-copies-harder; -M
+			authors={}
+			with_dir do
+				%x/git shortlog -sn #{logopts}/.each_line do |l|
+					commits, author=l.chomp.split(' ', 2)
+					authors[author]={commits: commits.to_i}
+				end
+
+				if more
+					authors.each_key do |a|
+						tot_a=0; tot_r=0; tot_rename=0; files=Set.new
+						%x/git log #{DefaultLogOptions} #{logopts} --numstat --format="%n" --author='#{a}'/.each_line do |l|
+							added, deleted, file=l.chomp.split(' ',3)
+							#puts "#{l} => #{added}, #{deleted}, #{rest}"
+							tot_a+=added.to_i; tot_r+=deleted.to_i
+							next if file.nil?
+							if file.include?(' => ')
+								tot_rename+=1
+							else
+								files.add(file) unless file.empty?
+							end
+						end
+						#rev-list should be faster, but I would need to use 
+						# `git rev-parse --revs-only --default HEAD #{logopts.shelljoin}`
+						# to be sure we default to HEAD, and 
+						# `git rev-parse --flags #{logopts.shelljoin}` to get the log flags...
+						#tot_merges=%x/git rev-list #{logopts} --merges --author='#{a}'/.each_line.count
+						tot_merges=%x/git log --pretty=oneline #{logopts} --merges --author='#{a}'/.each_line.count
+						authors[a].merge!({added: tot_a, deleted: tot_r, files: files.size, renames: tot_rename, merges: tot_merges})
+					end
+				end
+			end
+			authors
+		end
+
+		def output_stats_authors(logopts=nil)
+			authors=stats_authors(logopts, more: true)
+			authors.each do |a,v|
+				puts "- #{a}: #{v[:commits]} commits (+#{v[:added]}/-#{v[:deleted]}), #{v[:files]} files modified, #{v[:renames]} renames, #{v[:merges]} merges"
+			end
+		end
+
+		#inspired by visionmedia//git-infos
+		def infos
+			with_dir do
+				puts "## Remote URLs:"
+				puts
+				system("git --no-pager remote -v")
+				puts
+				
+				puts "## Remote Branches:"
+				puts
+				system("git --no-pager  branch -r")
+				puts
+				
+				puts "## Local Branches:"
+				puts
+				system("git --no-pager  branch")
+				puts
+				
+				puts "## Most Recent Commit:"
+				puts
+				system("git --no-pager log --max-count=1 --pretty=short")
+				puts
+			end
+		end
+
+		#inspired by visionmedia//git-summary
+		def summary(logopts=nil)
+			with_dir do
+				project=Pathname.new(%x/git rev-parse --show-toplevel/).basename
+				authors=stats_authors(logopts)
+				commits=authors.map {|a,v| v[:commits]}.sum
+				file_count=%x/git ls-files/.each_line.count
+				active_days=%x/git log --date=short --pretty='format: %ad' #{logopts}/.each_line.uniq.count
+				#This only give the rep age of the current branch; and is not
+				#efficient since we generate the first log
+				#A better way would be to get all the roots commits via
+				#    git rev-list --max-parents=0 HEAD
+				#and then look at their ages
+				repository_age=%x/git log --reverse --pretty=oneline --format="%ar" #{logopts}/.each_line.first.sub!('ago','')
+				#total= %x/git rev-list #{logopts}/.each_line.count
+				total=%x/git rev-list --count #{logopts.empty? ? "HEAD" : logopts.shelljoin}/.to_i
+
+				puts " project  : #{project}"
+				puts " repo age : #{repository_age}"
+				puts " active   : #{active_days} days"
+				puts " commits  : #{commits}"
+				puts " files    : #{file_count}"
+				puts " authors  : #{authors.keys.join(", ")} (Total: #{total})"
+				authors.each do |a,v|
+					puts " - #{a}: #{v[:commits]} (#{"%2.1f" % (100*v[:commits]/commits.to_f)}%)"
+				end
+			end
+		end
+	end
+
+	# various helpers
+	module GitExtraInfos
+		# Inspired by http://chneukirchen.org/dotfiles/bin/git-attic
+		def removed_files(logopts=nil)
+			removed={}
+			with_dir do
+				commit=nil; date=nil
+				%x/git log #{DefaultLogOptions} --raw --date=short --format="%h %cd" #{logopts}/.each_line do |l|
+					l.chomp!
+					case l
+					when /^[0-9a-f]/
+						commit, date=l.split(' ',2)
+					when /^:/
+						_old_mode, _new_mode, _old_hash, _new_hash, state, filename=l.split(' ',6)
+						#keep earliest removal
+						removed[filename]||={date: date, commit: commit} if state=="D"
+					end
+				end
+			end
+			removed
+		end
+		def output_removed_files(logopts=nil)
+			r=removed_files(logopts)
+			r.each do |file, data|
+				puts "#{data[:date]} #{data[:commit]}^:#{file}"
+			end
+		end
+
+		#Inspired by https://gist.github.com/7590246.git
+		def commit_children(*commits)
+			r={}
+			with_dir do
+				commits.each do |commit|
+					commit_id=%x/git rev-parse "#{commit}^0"/.chomp #dereference tags
+					%x/git rev-list --all --not #{commit_id}^@ --children/.each_line do |l|
+						if l=~/^#{commit_id}/
+							_commit, *children=l.chomp.split
+							described=children.map {|c| %x/git describe --always #{c}/.chomp}
+							r[commit]||=[]
+							r[commit]+=described
+						end
+					end
+				end
+			end
+			r
+		end
+		def output_commit_children(*commits)
+			commit_children(*commits).each do |commit, children|
+				puts "#{commit}: #{children.join(", ")}"
+			end
+		end
+
+		#number of commits modifying each file (look in the logs)
+		#Inspired by the script git-churn, written by Corey Haines # Scriptified by Gary Bernhardt
+		def log_commits_by_files(logopts=nil)
+			r={}
+			with_dir do
+				files=%x/git log #{DefaultLogOptions} --name-only --format="" #{logopts}/.each_line.map {|l| l.chomp!}
+				uniq=files.uniq
+				uniq.each do |file|
+					r[file]=files.count(file)
+				end
+			end
+			r
+		end
+		def output_log_commits_by_files(logopts=nil)
+			log_commits_by_files(logopts).sort {|f1, f2| -f1[1] <=> -f2[1]}.each do |file, count|
+				puts "- #{file}: #{count}"
+			end
+		end
+
+		#Inspired by the script git-effort from visionmedia
+		def commits_by_files(*files)
+			r={}
+			files=all_files if files.empty?
+			with_dir do
+				files.each do |file|
+					dates=%x/git log #{DefaultLogOptions} --pretty='format: %ad' --date=short -- "#{file}"/.each_line.map {|l| l.chomp}
+					r[file]={commits: dates.length, active: dates.uniq.length}
+				end
+			end
+			r
+		end
+		def output_commits_by_files(*files)
+			commits_by_files(*files).each do |file, data|
+				puts "- #{file}: #{data[:commits]} (active: #{data[:active]} days)"
+			end
+		end
+
+			#git config --list
+		#inspired by visionmedia//git-alias
+		def aliases
+			with_dir do
+				%x/git config --get-regexp 'alias.*'/.each_line.map do |l|
+					puts l.sub(/^alias\./,"").sub(/ /," = ")
+				end
+			end
+		end
+
+		#inspired by git-trail from https://github.com/cypher/dotfiles
+		#merges: key=branch point hash, values=tips names
+		def trails(commit, remotes: true, tags: true)
+			merges={}
+			with_dir do
+				%x/git for-each-ref/.each_line do |l|
+					hash, type, name=l.split
+					next if type=="tags" and !tags
+					next if type=="commit" && !name.start_with?("refs/heads/") and !remotes
+					mb=`git merge-base #{commit.shellescape} #{hash}`.chomp
+					mb=:disjoint if mb.empty?
+					merges[mb]||=[]
+					merges[mb] << name
+				end
+			end
+			merges
+		end
+
+		def output_all_trails(*args, **opts)
+			args.each do |commit|
+				trails(commit, **opts).each do |mb, tips|
+					next if mb==:disjoint
+					with_dir do
+						l=%x/git -c color.ui=always log -n1 --date=short --format="%C(auto,green)%cd %C(auto)%h" #{mb}/
+						date, short_hash=l.split
+						nr=tips.map do |tip|
+							`git name-rev --name-only --refs=#{tip.shellescape} #{mb}`.chomp
+						end
+						puts "#{date}: #{short_hash} – #{nr.join(', ')}"
+					end
+				end
+			end
+		end
+
+		#only output trails present in the log options passed
+		def output_trails(*args, **opts)
+			with_dir do
+				commit=`git rev-parse --revs-only --default HEAD #{args.shelljoin}`.chomp
+				merges=trails(commit, **opts)
+				%x/git -c color.ui=always log --date=short --format="%C(auto,green)%cd %C(auto)%h%C(reset) %H" #{args.shelljoin}/.each_line do |l|
+					date, short_hash, hash=l.split
+					if merges.key?(hash)
+						nr=merges[hash].map do |tip|
+							`git name-rev --name-only --refs=#{tip.shellescape} #{hash}`.chomp
+						end
+						puts "#{date}: #{short_hash} – #{nr.join(', ')}"
+					end
+				end
+			end
+		end
+
+		#inspired by git-neck from https://github.com/cypher/dotfiles
+		def neck(*args, **opts)
+			with_dir do
+				commit=`git rev-parse --revs-only --default HEAD #{args.shelljoin}`.chomp
+				log_opts=`git rev-parse --flags --no-revs #{args.shelljoin}`.chomp
+				hash=`git rev-parse #{commit.shellescape}`.chomp
+				merges=trails(commit, **opts)
+				merges.delete(hash) #todo: only delete if we are the only tip
+				merges.delete(:disjoint)
+				system("git --no-pager -c color.ui=always log --pretty=summary #{log_opts} #{merges.keys.map {|mb| "^#{mb}"}.join(" ")} #{commit}")
+				puts
+			end
+		end
+	end
+
+	class GitDir
+		include GitStats
+		include GitExtraInfos
+	end
+end