util/maint/list_changes.py

   1 #!/usr/bin/env python2
   2 #
   3 # Copyright (c) 2017 ARM Limited
   4 # All rights reserved
   5 #
   6 # The license below extends only to copyright in the software and shall
   7 # not be construed as granting a license to any other intellectual
   8 # property including but not limited to intellectual property relating
   9 # to a hardware implementation of the functionality of the software
  10 # licensed hereunder.  You may use the software subject to the license
  11 # terms below provided that you ensure that this notice is replicated
  12 # unmodified and in its entirety in all distributions of the software,
  13 # modified or unmodified, in source code or in binary form.
  14 #
  15 # Redistribution and use in source and binary forms, with or without
  16 # modification, are permitted provided that the following conditions are
  17 # met: redistributions of source code must retain the above copyright
  18 # notice, this list of conditions and the following disclaimer;
  19 # redistributions in binary form must reproduce the above copyright
  20 # notice, this list of conditions and the following disclaimer in the
  21 # documentation and/or other materials provided with the distribution;
  22 # neither the name of the copyright holders nor the names of its
  23 # contributors may be used to endorse or promote products derived from
  24 # this software without specific prior written permission.
  25 #
  26 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  27 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  28 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  29 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  30 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  31 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  32 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  33 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  34 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  35 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  36 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  37 #
  38 # Authors: Andreas Sandberg
  39
  40
  41 import subprocess
  42 import re
  43 from functools import wraps
  44
  45 class Commit(object):
  46     _re_tag = re.compile(r"^((?:\w|-)+): (.*)$")
  47
  48     def __init__(self, rev):
  49         self.rev = rev
  50         self._log = None
  51         self._tags = None
  52
  53     def _git(self, args):
  54         return subprocess.check_output([ "git", ] + args)
  55
  56     @property
  57     def log(self):
  58         """Log message belonging to a commit returned as a list with on line
  59         per element.
  60
  61         """
  62         if self._log is None:
  63             self._log = self._git(
  64                 ["show", "--format=%B", "--no-patch", str(self.rev) ]
  65             ).rstrip("\n").split("\n")
  66         return self._log
  67
  68     @property
  69     def tags(self):
  70         """Get all commit message tags in the current commit.
  71
  72         Returns: { tag, [ value, ... ] }
  73
  74         """
  75         if self._tags is None:
  76             tags = {}
  77             for l in self.log[1:]:
  78                 m = Commit._re_tag.match(l)
  79                 if m:
  80                     key, value = m.group(1), m.group(2)
  81                     try:
  82                         tags[key].append(value)
  83                     except KeyError:
  84                         tags[key] = [ value ]
  85             self._tags = tags
  86
  87         return self._tags
  88
  89     @property
  90     def change_id(self):
  91         """Get the Change-Id tag from the commit
  92
  93         Returns: A change ID or None if no change ID has been
  94         specified.
  95
  96         """
  97         try:
  98             cids = self.tags["Change-Id"]
  99         except KeyError:
 100             return None
 101
 102         assert len(cids) == 1
 103         return cids[0]
 104
 105     def __str__(self):
 106         return "%s: %s" % (self.rev[0:8], self.log[0])
 107
 108 def list_revs(branch, baseline=None):
 109     """Get a generator that lists git revisions that exist in 'branch'. If
 110     the optional parameter 'baseline' is specified, the generator
 111     excludes commits that exist on that branch.
 112
 113     Returns: Generator of Commit objects
 114
 115     """
 116
 117     if baseline is not None:
 118         query = "%s..%s" % (branch, baseline)
 119     else:
 120         query = str(branch)
 121
 122     changes = subprocess.check_output([ "git", "rev-list", query ])
 123
 124     if changes == "":
 125         return
 126
 127     for rev in changes.rstrip("\n").split("\n"):
 128         assert rev != ""
 129         yield Commit(rev)
 130
 131 def list_changes(upstream, feature):
 132     feature_revs = tuple(list_revs(upstream, feature))
 133     upstream_revs = tuple(list_revs(feature, upstream))
 134
 135     feature_cids = dict([
 136         (c.change_id, c) for c in feature_revs if c.change_id is not None ])
 137     upstream_cids = dict([
 138         (c.change_id, c) for c in upstream_revs if c.change_id is not None ])
 139
 140     incoming = filter(
 141         lambda r: r.change_id and r.change_id not in feature_cids,
 142         reversed(upstream_revs))
 143     outgoing = filter(
 144         lambda r: r.change_id and r.change_id not in upstream_cids,
 145         reversed(feature_revs))
 146     common = filter(
 147         lambda r: r.change_id in upstream_cids,
 148         reversed(feature_revs))
 149     upstream_unknown = filter(
 150         lambda r: r.change_id is None,
 151         reversed(upstream_revs))
 152     feature_unknown = filter(
 153         lambda r: r.change_id is None,
 154         reversed(feature_revs))
 155
 156     return incoming, outgoing, common, upstream_unknown, feature_unknown
 157
 158 def _main():
 159     import argparse
 160     parser = argparse.ArgumentParser(
 161         description="List incoming and outgoing changes in a feature branch")
 162
 163     parser.add_argument("--upstream", "-u", type=str, default="origin/master",
 164                         help="Upstream branch for comparison. " \
 165                         "Default: %(default)s")
 166     parser.add_argument("--feature", "-f", type=str, default="HEAD",
 167                         help="Feature branch for comparison. " \
 168                         "Default: %(default)s")
 169     parser.add_argument("--show-unknown", action="store_true",
 170                         help="Print changes without Change-Id tags")
 171     parser.add_argument("--show-common", action="store_true",
 172                         help="Print common changes")
 173     parser.add_argument("--deep-search", action="store_true",
 174                         help="Use a deep search to find incorrectly " \
 175                         "rebased changes")
 176
 177     args = parser.parse_args()
 178
 179     incoming, outgoing, common, upstream_unknown, feature_unknown = \
 180         list_changes(args.upstream, args.feature)
 181
 182     if incoming:
 183         print "Incoming changes:"
 184         for rev in incoming:
 185             print rev
 186         print
 187
 188     if args.show_unknown and upstream_unknown:
 189         print "Upstream changes without change IDs:"
 190         for rev in upstream_unknown:
 191             print rev
 192         print
 193
 194     if outgoing:
 195         print "Outgoing changes:"
 196         for rev in outgoing:
 197             print rev
 198         print
 199
 200     if args.show_common and common:
 201         print "Common changes:"
 202         for rev in common:
 203             print rev
 204         print
 205
 206     if args.show_unknown and feature_unknown:
 207         print "Outgoing changes without change IDs:"
 208         for rev in feature_unknown:
 209             print rev
 210
 211     if args.deep_search:
 212         print "Incorrectly rebased changes:"
 213         all_upstream_revs = list_revs(args.upstream)
 214         all_upstream_cids = dict([
 215             (c.change_id, c) for c in all_upstream_revs \
 216             if c.change_id is not None ])
 217         incorrect_outgoing = filter(
 218             lambda r: r.change_id in all_upstream_cids,
 219             outgoing)
 220         for rev in incorrect_outgoing:
 221             print rev
 222
 223
 224
 225
 226 if __name__ == "__main__":
 227     _main()