This is an archive of the discontinued Mercurial Phabricator instance.

contrib: add git-sl emulation of hg smartlog
ClosedPublic

Authored by simonfar on Jul 24 2017, 9:02 AM.

Download Raw Diff

Details

Reviewers

durham
ryanmce
quark

Group Reviewers

Restricted Project

Commits

rFBHGXba70497b5340: contrib: add git-sl emulation of hg smartlog

Summary

git-sl is a script to emulate some of hg smartlog, but for git. It's generally
useful, and demonstrates some of our thinking around source control, so let's
release it to the world.

Test Plan

Just for documentation

Ran tests - only test-check-commit-hg.t fails, but that does not run on public
commits, so this is safe to land (unlike the previous attempt).

Diff Detail

Repository

rFBHGX Facebook Mercurial Extensions

Lint

Automatic diff as part of commit; lint not applicable.

Unit

Automatic diff as part of commit; unit tests not applicable.

Event Timeline

simonfar created this revision.Jul 24 2017, 9:02 AM

Herald added a reviewer: Restricted Project. · View Herald TranscriptJul 24 2017, 9:02 AM

How does test-check-commit.t fail with this?

It complains about the code style not matching Mercurial code style. As this is never going to be part of Mercurial, I'm not keen on spending time fixing coding style.

As the test won't complain about public commits, I left it alone - other tests that check code pass.

Since it's for git, I think it's fine to not use the hg code style.

You might want to add # no-check-code if test-check-code-hg.t complains.

This revision is now accepted and ready to land.Jul 26 2017, 6:43 PM

I fixed the complaints from test-check-code - they looked like good complaints to fix (readability issues). It's just test-check-commit that fails, for not being hg coding style.

Closed by commit rFBHGXba70497b5340: contrib: add git-sl emulation of hg smartlog (authored by simonfar). · Explain WhyJul 28 2017, 9:29 AM

This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

			Path	Packages
A	M		contrib/git-sl (353 lines)

Diff 438

contrib/git-sl

This file was added.

Property	Old Value	New Value
File Mode	null	100755

				#!/usr/bin/env python
				#
				# Copyright 2004-present Facebook. All rights reserved.
				#
				# Emulate the output of smartlog.py atop git, instead of Mercurial.
				#

				from __future__ import absolute_import
				from __future__ import division
				from __future__ import print_function
				from __future__ import unicode_literals
				import re
				from subprocess import Popen
				import subprocess
				from time import time
				import argparse


				seconds_in_a_day = 60.0 * 60.0 * 24.0

				class ColorOutput(object):
				colors = {
				'black': 90,
				'red': 91,
				'green': 92,
				'yellow': 93,
				'blue': 94,
				'pink': 95,
				'cyan': 96,
				'under': 4,
				'none': 0
				}
				str_pattern_color = '\33[%dm'

				@classmethod
				def str(cls, color, text):
				return (cls.str_pattern_color % cls.colors[color]) + str(text) + \
				(cls.str_pattern_color % cls.colors['none'])

				class GitRevision(object):
				revisionmap = {}
				root = None
				current_branch = None
				show_all = False
				origin_timestamp_threshold = 0
				ignored_message = None

				# ref can be a hash or a branch_name
				def __init__(self, ref, hash=None):
				self.hash = hash if hash is not None else git_rev_parse(ref)
				self.ref = [ref]
				self.ancestors = []
				self.predecessors = []
				self.father = self
				self.other_fathers = set()
				self.children = []
				self.author = "AwesomeAuthor"
				self.longref = "Awesome Description"
				self.commit_timestamp = 0
				self.between_me_and_father = []
				self.evaluated = set()
				self.real_father = False
				self.me_head = False
				self.small_hash = ""
				self.get_my_info()
				global origin_timestamp_threshold
				self.use_me = (GitRevision.show_all or
				self.commit_timestamp > GitRevision.origin_timestamp_threshold)

				@classmethod
				def make_unique(cls, ref, hash=None):
				hash = hash if hash is not None else git_rev_parse(ref)
				if hash in cls.revisionmap:
				cls.revisionmap[hash].ref += [ref]
				else:
				cls.revisionmap[hash] = cls(ref, hash=hash)
				return cls.revisionmap[hash]

				@classmethod
				def build_revmap(cls, reflist):
				hashes = git_rev_parse_many(reflist)
				for (hash, ref) in zip(hashes, reflist):
				cls.make_unique(ref, hash=hash)
				cls.remove_old_revs()

				@staticmethod
				def set_hashes(revs):
				return set([x.hash for x in revs])

				@classmethod
				def print_ignored_if_any(cls):
				if cls.ignored_message is not None:
				print(cls.ignored_message)

				@classmethod
				def remove_old_revs(cls):
				new_revisionmap = {}
				ignored = []
				for hash, rev in cls.revisionmap.iteritems():
				if rev.use_me:
				new_revisionmap[hash] = rev
				else:
				ignored.append(
				"ignored: %s %s (%s) [%.1f days old] %s" % (
				rev.small_hash,
				rev.author,
				", ".join(rev.ref),
				(time() - rev.commit_timestamp) / seconds_in_a_day,
				rev.longref)
				)
				cls.revisionmap = new_revisionmap
				cls.ignored_message = "\n".join(ignored)

				@classmethod
				def get_rev(cls, rev_hash):
				if rev_hash not in cls.revisionmap:
				cls.make_unique(rev_hash)
				return cls.revisionmap[rev_hash]

				@classmethod
				def prepare(cls, to_be_prepared=None):
				refs = cls.revisionmap.keys()
				all_rev = cls.revisionmap.values()
				will_prepare = to_be_prepared or all_rev
				for rev in will_prepare:
				for rev_s in all_rev:
				rev.eval_rev(rev_s)
				newrefs = set(cls.revisionmap.keys()) - set(refs)
				if len(newrefs) > 0:
				cls.prepare(to_be_prepared=[cls.get_rev(x) for x in newrefs])
				if to_be_prepared is None:
				cls.find_parents_and_children()
				head_hash = git_rev_parse("HEAD")
				cls.get_rev(head_hash).me_head = True

				@classmethod
				def find_parents_and_children(cls):
				for rev in cls.revisionmap.values():
				rev.normalize()
				for rev in cls.revisionmap.values():
				rev.find_my_children()
				for rev in cls.revisionmap.values():
				if rev.father == rev:
				cls.root = rev
				for rev in cls.revisionmap.values():
				key=lambda x: time() if "master" in x.ref else x.newest_timestamp()
				rev.children = sorted(
				rev.children,
				key = key
				)

				def newest_timestamp(self):
				ts = self.commit_timestamp
				for ch in self.children:
				ts = max(ts, ch.commit_timestamp)
				return ts

				def normalize(self):
				self.ancestors = list(
				dict([(x.hash, x) for x in self.ancestors]).values()
				)
				self.predecessors = list(
				dict([(x.hash, x) for x in self.predecessors]).values()
				)

				def find_my_children(self):
				my_ancestors_hashes = GitRevision.set_hashes(self.ancestors)
				my_predecessors_hashes = GitRevision.set_hashes(self.predecessors)
				for child in self.predecessors:

				# / OTHER_A
				# AN \ / - PARALLEL_A ----------\
				# AN - ME OTHER
				# AN / \ - PARALLEL_B - CHILD --/
				# BR_A ------- BR_B -----/ \ OTHER_B
				#
				# if PARALLEL_B == {} => CHILD is child
				#
				#
				#
				# CHILD.predecessors = OTHER \| OTHER_B
				# CHILD.ancestors = AN \| ME \| PARALLEL_B \| BR_A \| BR_B
				# ME.ancestors = AN \| BR_A
				# nodes := CHILD.ancestors - ME.ancestors - ME = PARALLEL_B \| BR_B
				# nodes & ME.predecessors = PARALLEL_B

				# all operations are NlogN with very low const
				child_anc = GitRevision.set_hashes(child.ancestors)
				nodes = child_anc - my_ancestors_hashes
				nodes = nodes - set([self.hash])
				parallel_b = nodes & my_predecessors_hashes
				if len(parallel_b) == 0:
				# if there is no one that is between me and my child, then
				# it's a 'direct child'
				self.children.append(child)
				direct_fathers = set(get_parents(child.hash))
				fathers = child.other_fathers
				if child.hash != child.father.hash:
				fathers\|= set([child.father.hash])
				fathers\|= set([self.hash])
				real_fathers = fathers & direct_fathers
				if len(real_fathers) > 0:
				father_hash = real_fathers.pop()
				child.other_fathers = fathers - set([father_hash])
				child.father = GitRevision.get_rev(father_hash)
				child.real_father = True
				else:
				father_hash = fathers.pop()
				child.other_fathers = fathers - set([father_hash])
				child.father = GitRevision.get_rev(father_hash)
				child.real_father = False

				def is_same_hash(self, hash_str):
				len_hash = min(len(self.hash), len(hash_str))
				if self.hash[:len_hash] == hash_str[:len_hash]:
				return True
				return False

				def eval_rev(self, revision):
				if revision.hash == self.hash:
				return
				if revision.hash in self.evaluated:
				return
				self.evaluated.add(revision.hash)
				revision.evaluated.add(self.hash)
				ancestor = git_common_ancestor(self.hash, revision.hash)
				if self.is_same_hash(ancestor):
				self.predecessors.append(revision)
				revision.ancestors.append(self)
				elif revision.is_same_hash(ancestor):
				self.ancestors.append(revision)
				revision.predecessors.append(self)
				else:
				anc_rev = GitRevision.get_rev(ancestor)
				anc_rev.eval_rev(self)
				anc_rev.eval_rev(revision)

				def __str__(self):
				return '\n'.join(reversed(list(self.tree())))

				def tree(self):
				yield " " if self.root != self else "\|"
				for line in self.twolines_ref():
				yield line
				last = self.children[-1] if len(self.children) > 0 else None
				for child in self.children:
				if child.father is not self:
				# this guy is a child of someone else too. let he print it
				continue
				prefix = '\|' if child == last else '\|/'
				for line in child.tree():
				yield prefix + line
				prefix = '' if child == last else '\| '

				def twolines_ref(self):
				bullet = "@ " if self.me_head else "o "
				text = self.small_hash + " " + self.author
				if self.me_head:
				lines = bullet + ColorOutput.str("green", text)
				longref = ColorOutput.str("green", self.longref)
				else:
				lines = bullet + text
				longref = self.longref
				if self.ref != self.hash:
				refv = [
				x + "*" if x == GitRevision.current_branch else x
				for x in self.ref
				]
				text = " (" + ", ".join(refv) + ")"
				if self.me_head:
				lines += ColorOutput.str("yellow", text)
				else:
				lines += ColorOutput.str("blue", text)
				if self.real_father:
				trace = "\| "
				else:
				trace = ": "
				if len(self.other_fathers) == 0:
				return [trace + longref, lines]
				else:
				other = [GitRevision.get_rev(x).small_hash for x in
				self.other_fathers]
				other = ColorOutput.str("cyan", "Also son of: " + ", ".join(other))
				return [trace + other, trace + longref, lines]

				def get_my_info(self):
				[name, longref, committime, small_hash] = get_info(self.hash)
				self.author = name
				self.longref = longref
				self.commit_timestamp = int(committime)
				self.small_hash = small_hash

				def run_cmd(cmd, swallow_error=False):
				p = Popen(["git"] + cmd,
				stdout=subprocess.PIPE,
				stderr=subprocess.PIPE)
				out, err = p.communicate()
				if p.returncode != 0:
				if swallow_error:
				return '', ''
				print(
				"git %s returned code %d:\nstdout:\n%s\nstderr:\n%s" %
				(cmd, p.returncode, out, err)
				)
				exit(p.returncode)
				return out, err

				def get_info(revref):
				out, _ = run_cmd(["log", revref, "--format=%ae%x00%s%x00%ct%x00%h", "-n1"])
				result = out.split('\n')[0].split("\x00")
				result[0] = result[0].split('@')[0]
				return result

				def get_parents(rev):
				out, _ = run_cmd(["log", "--pretty=%P", "-n1", rev])
				return out.split()

				def git_rev_parse_many(refs):
				out, _ = run_cmd(["rev-parse"] + refs)
				return out.split()

				def git_rev_parse(ref):
				return git_rev_parse_many([ref])[0]

				# Git Branch (git branch)
				def git_branch_names():
				out, _ = run_cmd(["branch"])
				reg = r"\\s(\w*)"
				GitRevision.current_branch = re.search(reg, out).groups()[0]
				return list(set(out.split()) - set(["*"]))

				def git_common_ancestor(branch1, branch2):
				out, _ = run_cmd(["merge-base", branch1, branch2], swallow_error=True)
				return out.strip()

				if __name__ == "__main__":
				parser = argparse.ArgumentParser(description='Git Smart Log - prints a '
				'tree representation of your branches')
				parser.add_argument('-a', '--all', action='store_true',
				help='By default it will only look into features not older than 2 weeks'
				', if this is not what you want and you don\'t care about waiting '
				'for 10 minutes, use this')
				# defaults for
				parser.add_argument('-t', '--time', metavar='FLOAT_TIME_IN_DAYS',
				default=str(14), help='time in days to look for features.')
				gitsl_args = parser.parse_args()
				GitRevision.show_all = gitsl_args.all
				GitRevision.origin_timestamp_threshold = (time() -
				float(gitsl_args.time) * seconds_in_a_day)
				GitRevision.build_revmap(git_branch_names() + ["HEAD"])
				GitRevision.prepare()
				print(GitRevision.root)
				GitRevision.print_ignored_if_any()

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	393		Jul 24 2017, 9:02 AM	★	★
Diff 2	438	rFBHGXba70497b534049c3040377a75486dba55210148b	Jul 27 2017, 5:32 AM	★	★