blob: c27aab1fb89cf8e57a6a66abe902f004fbf7a57d [file] [log] [blame]
#!/usr/bin/env python2.7
#
# Copyright (c) 2017-2018 Arm Limited
# All rights reserved
#
# The license below extends only to copyright in the software and shall
# not be construed as granting a license to any other intellectual
# property including but not limited to intellectual property relating
# to a hardware implementation of the functionality of the software
# licensed hereunder. You may use the software subject to the license
# terms below provided that you ensure that this notice is replicated
# unmodified and in its entirety in all distributions of the software,
# modified or unmodified, in source code or in binary form.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met: redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer;
# redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution;
# neither the name of the copyright holders nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# Authors: Andreas Sandberg
import subprocess
import re
from functools import wraps
class Commit(object):
_re_tag = re.compile(r"^((?:\w|-)+): (.*)$")
def __init__(self, rev):
self.rev = rev
self._log = None
self._tags = None
def _git(self, args):
return subprocess.check_output([ "git", ] + args)
@property
def log(self):
"""Log message belonging to a commit returned as a list with on line
per element.
"""
if self._log is None:
self._log = self._git(
["show", "--format=%B", "--no-patch", str(self.rev) ]
).rstrip("\n").split("\n")
return self._log
@property
def tags(self):
"""Get all commit message tags in the current commit.
Returns: { tag, [ value, ... ] }
"""
if self._tags is None:
tags = {}
for l in self.log[1:]:
m = Commit._re_tag.match(l)
if m:
key, value = m.group(1), m.group(2)
try:
tags[key].append(value)
except KeyError:
tags[key] = [ value ]
self._tags = tags
return self._tags
@property
def change_id(self):
"""Get the Change-Id tag from the commit
Returns: A change ID or None if no change ID has been
specified.
"""
try:
cids = self.tags["Change-Id"]
except KeyError:
return None
assert len(cids) == 1
return cids[0]
def __str__(self):
return "%s: %s" % (self.rev[0:8], self.log[0])
def list_revs(branch, baseline=None, paths=[]):
"""Get a generator that lists git revisions that exist in 'branch'. If
the optional parameter 'baseline' is specified, the generator
excludes commits that exist on that branch.
Returns: Generator of Commit objects
"""
if baseline is not None:
query = "%s..%s" % (branch, baseline)
else:
query = str(branch)
changes = subprocess.check_output(
[ "git", "rev-list", query, '--'] + paths
)
if changes == "":
return
for rev in changes.rstrip("\n").split("\n"):
assert rev != ""
yield Commit(rev)
def list_changes(upstream, feature, paths=[]):
feature_revs = tuple(list_revs(upstream, feature, paths=paths))
upstream_revs = tuple(list_revs(feature, upstream, paths=paths))
feature_cids = dict([
(c.change_id, c) for c in feature_revs if c.change_id is not None ])
upstream_cids = dict([
(c.change_id, c) for c in upstream_revs if c.change_id is not None ])
incoming = filter(
lambda r: r.change_id and r.change_id not in feature_cids,
reversed(upstream_revs))
outgoing = filter(
lambda r: r.change_id and r.change_id not in upstream_cids,
reversed(feature_revs))
common = filter(
lambda r: r.change_id in upstream_cids,
reversed(feature_revs))
upstream_unknown = filter(
lambda r: r.change_id is None,
reversed(upstream_revs))
feature_unknown = filter(
lambda r: r.change_id is None,
reversed(feature_revs))
return incoming, outgoing, common, upstream_unknown, feature_unknown
def _main():
import argparse
parser = argparse.ArgumentParser(
description="List incoming and outgoing changes in a feature branch")
parser.add_argument("--upstream", "-u", type=str, default="origin/master",
help="Upstream branch for comparison. " \
"Default: %(default)s")
parser.add_argument("--feature", "-f", type=str, default="HEAD",
help="Feature branch for comparison. " \
"Default: %(default)s")
parser.add_argument("--show-unknown", action="store_true",
help="Print changes without Change-Id tags")
parser.add_argument("--show-common", action="store_true",
help="Print common changes")
parser.add_argument("--deep-search", action="store_true",
help="Use a deep search to find incorrectly " \
"rebased changes")
parser.add_argument("paths", metavar="PATH", type=str, nargs="*",
help="Paths to list changes for")
args = parser.parse_args()
incoming, outgoing, common, upstream_unknown, feature_unknown = \
list_changes(args.upstream, args.feature, paths=args.paths)
if incoming:
print "Incoming changes:"
for rev in incoming:
print rev
print
if args.show_unknown and upstream_unknown:
print "Upstream changes without change IDs:"
for rev in upstream_unknown:
print rev
print
if outgoing:
print "Outgoing changes:"
for rev in outgoing:
print rev
print
if args.show_common and common:
print "Common changes:"
for rev in common:
print rev
print
if args.show_unknown and feature_unknown:
print "Outgoing changes without change IDs:"
for rev in feature_unknown:
print rev
if args.deep_search:
print "Incorrectly rebased changes:"
all_upstream_revs = list_revs(args.upstream, paths=args.paths)
all_upstream_cids = dict([
(c.change_id, c) for c in all_upstream_revs \
if c.change_id is not None ])
incorrect_outgoing = filter(
lambda r: r.change_id in all_upstream_cids,
outgoing)
for rev in incorrect_outgoing:
print rev
if __name__ == "__main__":
_main()