1 files changed, 77 insertions, 11 deletions

diff --git a/scripts/contrib/patchreview.py b/scripts/contrib/patchreview.py
index a4d5ba6867..bceae06561 100755
--- a/scripts/contrib/patchreview.py
+++ b/scripts/contrib/patchreview.py
@@ -1,10 +1,25 @@
 #! /usr/bin/env python3
+#
+# Copyright OpenEmbedded Contributors
+#
+# SPDX-License-Identifier: GPL-2.0-only
+#
+
+import argparse
+import collections
+import json
+import os
+import os.path
+import pathlib
+import re
+import subprocess
 
 # TODO
 # - option to just list all broken files
 # - test suite
 # - validate signed-off-by
 
+status_values = ("accepted", "pending", "inappropriate", "backport", "submitted", "denied", "inactive-upstream")
 
 class Result:
     # Whether the patch has an Upstream-Status or not
@@ -29,27 +44,25 @@ def blame_patch(patch):
     From a patch filename, return a list of "commit summary (author name <author
     email>)" strings representing the history.
     """
-    import subprocess
     return subprocess.check_output(("git", "log",
                                     "--follow", "--find-renames", "--diff-filter=A",
                                     "--format=%s (%aN <%aE>)",
                                     "--", patch)).decode("utf-8").splitlines()
 
 def patchreview(patches):
-    import re
 
     # General pattern: start of line, optional whitespace, tag with optional
     # hyphen or spaces, maybe a colon, some whitespace, then the value, all case
     # insensitive.
     sob_re = re.compile(r"^[\t ]*(Signed[-_ ]off[-_ ]by:?)[\t ]*(.+)", re.IGNORECASE | re.MULTILINE)
-    status_re = re.compile(r"^[\t ]*(Upstream[-_ ]Status:?)[\t ]*(\w*)", re.IGNORECASE | re.MULTILINE)
-    status_values = ("accepted", "pending", "inappropriate", "backport", "submitted", "denied")
+    status_re = re.compile(r"^[\t ]*(Upstream[-_ ]Status:?)[\t ]*([\w-]*)", re.IGNORECASE | re.MULTILINE)
     cve_tag_re = re.compile(r"^[\t ]*(CVE:)[\t ]*(.*)", re.IGNORECASE | re.MULTILINE)
     cve_re = re.compile(r"cve-[0-9]{4}-[0-9]{4,6}", re.IGNORECASE)
 
     results = {}
 
     for patch in patches:
+
         result = Result()
         results[patch] = result
 
@@ -122,6 +135,8 @@ def analyse(results, want_blame=False, verbose=True):
             missing_status += 1
         if r.malformed_upstream_status or r.unknown_upstream_status:
             malformed_status += 1
+            # Count patches with no status as pending
+            pending_patches +=1
         if r.missing_cve:
             missing_cve += 1
         if r.upstream_status == "pending":
@@ -132,7 +147,6 @@ def analyse(results, want_blame=False, verbose=True):
             need_blame = True
             if verbose:
                 print("Missing Signed-off-by tag (%s)" % patch)
-
         if r.malformed_sob:
             need_blame = True
             if verbose:
@@ -185,27 +199,79 @@ Patches in Pending state: %s""" % (total_patches,
 def histogram(results):
     from toolz import recipes, dicttoolz
     import math
+
     counts = recipes.countby(lambda r: r.upstream_status, results.values())
     bars = dicttoolz.valmap(lambda v: "#" * int(math.ceil(float(v) / len(results) * 100)), counts)
     for k in bars:
         print("%-20s %s (%d)" % (k.capitalize() if k else "No status", bars[k], counts[k]))
 
+def find_layers(candidate):
+    # candidate can either be the path to a layer directly (eg meta-intel), or a
+    # repository that contains other layers (meta-arm). We can determine what by
+    # looking for a conf/layer.conf file. If that file exists then it's a layer,
+    # otherwise its a repository of layers and we can assume they're called
+    # meta-*.
+
+    if (candidate / "conf" / "layer.conf").exists():
+        return [candidate.absolute()]
+    else:
+        return [d.absolute() for d in candidate.iterdir() if d.is_dir() and (d.name == "meta" or d.name.startswith("meta-"))]
+
+# TODO these don't actually handle dynamic-layers/
+
+def gather_patches(layers):
+    patches = []
+    for directory in layers:
+        filenames = subprocess.check_output(("git", "-C", directory, "ls-files", "recipes-*/**/*.patch", "recipes-*/**/*.diff"), universal_newlines=True).split()
+        patches += [os.path.join(directory, f) for f in filenames]
+    return patches
+
+def count_recipes(layers):
+    count = 0
+    for directory in layers:
+        output = subprocess.check_output(["git", "-C", directory, "ls-files", "recipes-*/**/*.bb"], universal_newlines=True)
+        count += len(output.splitlines())
+    return count
 
 if __name__ == "__main__":
-    import argparse, subprocess, os
-
     args = argparse.ArgumentParser(description="Patch Review Tool")
     args.add_argument("-b", "--blame", action="store_true", help="show blame for malformed patches")
     args.add_argument("-v", "--verbose", action="store_true", help="show per-patch results")
     args.add_argument("-g", "--histogram", action="store_true", help="show patch histogram")
-    args.add_argument("directory", nargs="?", help="directory to scan")
+    args.add_argument("-j", "--json", help="update JSON")
+    args.add_argument("directory", type=pathlib.Path, metavar="DIRECTORY", help="directory to scan (layer, or repository of layers)")
     args = args.parse_args()
 
-    if args.directory:
-        os.chdir(args.directory)
-    patches = subprocess.check_output(("git", "ls-files", "recipes-*/**/*.patch", "recipes-*/**/*.diff")).decode("utf-8").split()
+    layers = find_layers(args.directory)
+    print(f"Found layers {' '.join((d.name for d in layers))}")
+    patches = gather_patches(layers)
     results = patchreview(patches)
     analyse(results, want_blame=args.blame, verbose=args.verbose)
+
+    if args.json:
+        if os.path.isfile(args.json):
+            data = json.load(open(args.json))
+        else:
+            data = []
+
+        row = collections.Counter()
+        row["total"] = len(results)
+        row["date"] = subprocess.check_output(["git", "-C", args.directory, "show", "-s", "--pretty=format:%cd", "--date=format:%s"], universal_newlines=True).strip()
+        row["commit"] = subprocess.check_output(["git", "-C", args.directory, "rev-parse", "HEAD"], universal_newlines=True).strip()
+        row['commit_count'] = subprocess.check_output(["git", "-C", args.directory, "rev-list", "--count", "HEAD"], universal_newlines=True).strip()
+        row['recipe_count'] = count_recipes(layers)
+
+        for r in results.values():
+            if r.upstream_status in status_values:
+                row[r.upstream_status] += 1
+            if r.malformed_upstream_status or r.missing_upstream_status:
+                row['malformed-upstream-status'] += 1
+            if r.malformed_sob or r.missing_sob:
+                row['malformed-sob'] += 1
+
+        data.append(row)
+        json.dump(data, open(args.json, "w"), sort_keys=True, indent="\t")
+
     if args.histogram:
         print()
         histogram(results)