From d166ccf4304d6fa3878093a2c0688bf79c8c5832 Mon Sep 17 00:00:00 2001
From: Stef Walter <stefw@gnome.org>
Date: Tue, 6 Nov 2012 12:55:07 +0100
Subject: Lots more work and cleanup

---
 git-coverage | 473 ++++++++++++++++++++++++++++++++++-------------------------
 1 file changed, 272 insertions(+), 201 deletions(-)

diff --git a/git-coverage b/git-coverage
index ac837c9..09c803d 100755
--- a/git-coverage
+++ b/git-coverage
@@ -8,6 +8,9 @@ import subprocess
 import sys
 
 COVERAGE_EXTENSIONS = [".c", ".cpp", ".cc"]
+SKIP_PATTERNS = [
+        'assert_not_reached'
+]
 
 # Portions of the code:
 #
@@ -46,179 +49,155 @@ class BadPatch(Exception):
     def __str__(self):
         return self.message
 
-
-def get_patch_names(iter_lines):
-    try:
-        line = iter_lines.next()
-        if not line.startswith("--- "):
-            raise BadPatch("No orig name: %s" % line)
-        else:
-            orig_name = line[4:].rstrip("\n")
-    except StopIteration:
-        raise BadPatch("No orig line")
-    try:
-        line = iter_lines.next()
-        if not line.startswith("+++ "):
-            raise BadPatch("No mod name")
-        else:
-            mod_name = line[4:].rstrip("\n")
-    except StopIteration:
-        raise BadPatch("No mod line")
-    return (orig_name, mod_name)
-
-
-def parse_range(textrange):
-    tmp = textrange.split(',')
-    if len(tmp) == 1:
-        pos = tmp[0]
-        range = "1"
-    else:
-        (pos, range) = tmp
-    pos = int(pos)
-    range = int(range)
-    return (pos, range)
-
-
-def hunk_from_header(line):
-    matches = re.match(r'\@\@ ([^@]*) \@\@( (.*))?\n', line)
-    if matches is None:
-        raise MalformedHunkHeader("Does not match format.", line)
-    try:
-        (orig, mod) = matches.group(1).split(" ")
-    except (ValueError, IndexError), e:
-        raise MalformedHunkHeader(str(e), line)
-    if not orig.startswith('-') or not mod.startswith('+'):
-        raise MalformedHunkHeader("Positions don't start with + or -.", line)
-    try:
-        (orig_pos, orig_range) = parse_range(orig[1:])
-        (mod_pos, mod_range) = parse_range(mod[1:])
-    except (ValueError, IndexError), e:
-        raise MalformedHunkHeader(str(e), line)
-    if mod_range < 0 or orig_range < 0:
-        raise MalformedHunkHeader("Hunk range is negative", line)
-    tail = matches.group(3)
-    return Hunk(orig_pos, orig_range, mod_pos, mod_range, tail)
-
-
-class HunkLine:
-    def __init__(self, contents):
-        self.contents = contents
-
-
-class ContextLine(HunkLine):
-    def __init__(self, contents):
-        HunkLine.__init__(self, contents)
-
-
-class InsertLine(HunkLine):
-    def __init__(self, contents):
-        HunkLine.__init__(self, contents)
-
-
-class RemoveLine(HunkLine):
-    def __init__(self, contents):
-        HunkLine.__init__(self, contents)
-
-
-def parse_line(line):
-    if line.startswith("\n"):
-        return ContextLine(line)
-    elif line.startswith(" "):
-        return ContextLine(line[1:])
-    elif line.startswith("+"):
-        return InsertLine(line[1:])
-    elif line.startswith("-"):
-        return RemoveLine(line[1:])
-    else:
-        raise BadPatch("Unknown line type" % line)
-
-
 class Hunk:
-    def __init__(self, orig_pos, orig_range, mod_pos, mod_range, tail=None):
+    def __init__(self, orig_pos, orig_range, mod_pos, mod_range, header=None):
         self.orig_pos = orig_pos
         self.orig_range = orig_range
         self.mod_pos = mod_pos
         self.mod_range = mod_range
-        self.tail = tail
+        self.header = header
         self.lines = []
 
-
-def iter_hunks(iter_lines, allow_dirty=False):
-    hunk = None
-    for line in iter_lines:
-        if line == "\n":
+    @staticmethod
+    def parse_range(textrange):
+        tmp = textrange.split(',')
+        if len(tmp) == 1:
+            pos = tmp[0]
+            range = "1"
+        else:
+            (pos, range) = tmp
+        pos = int(pos)
+        range = int(range)
+        return (pos, range)
+
+    @staticmethod
+    def from_header(line):
+        matches = re.match(r'\@\@ ([^@]*) \@\@( (.*))?\n', line)
+        if matches is None:
+            raise MalformedHunkHeader("Does not match format.", line)
+        try:
+            (orig, mod) = matches.group(1).split(" ")
+        except (ValueError, IndexError), e:
+            raise MalformedHunkHeader(str(e), line)
+        if not orig.startswith('-') or not mod.startswith('+'):
+            raise MalformedHunkHeader("Positions don't start with + or -.", line)
+        try:
+            (orig_pos, orig_range) = Hunk.parse_range(orig[1:])
+            (mod_pos, mod_range) = Hunk.parse_range(mod[1:])
+        except (ValueError, IndexError), e:
+            raise MalformedHunkHeader(str(e), line)
+        if mod_range < 0 or orig_range < 0:
+            raise MalformedHunkHeader("Hunk range is negative", line)
+        tail = matches.group(3)
+        return Hunk(orig_pos, orig_range, mod_pos, mod_range, line)
+
+    @staticmethod
+    def parse(lines, allow_dirty=True):
+        hunk = None
+        lines = iter(lines)
+        for line in lines:
+            if line == "\n":
+                if hunk is not None:
+                    yield hunk
+                    hunk = None
+                continue
             if hunk is not None:
                 yield hunk
-                hunk = None
-            continue
+            try:
+                hunk = Hunk.from_header(line)
+            except MalformedHunkHeader:
+                if allow_dirty:
+                    # If the line isn't a hunk header, then we've reached the end
+                    # of this patch and there's "junk" at the end.  Ignore the
+                    # rest of this patch.
+                    return
+                raise
+            orig_size = 0
+            mod_size = 0
+            offset = hunk.mod_pos
+            while orig_size < hunk.orig_range or mod_size < hunk.mod_range:
+                hunk_line = lines.next()
+                if hunk_line.startswith("-"):
+                    orig_size += 1
+                elif hunk_line.startswith("\n"):
+                    orig_size += 1
+                    mod_size += 1
+                elif hunk_line.startswith(" "):
+                    orig_size += 1
+                    mod_size += 1
+                elif hunk_line.startswith("+"):
+                    mod_size += 1
+                else:
+                    raise BadPatch("Unknown line type: %s" % hunk_line)
+                hunk.lines.append((offset, hunk_line))
+                if not hunk_line.startswith("-"):
+                    offset += 1
         if hunk is not None:
             yield hunk
-        try:
-            hunk = hunk_from_header(line)
-        except MalformedHunkHeader:
-            if allow_dirty:
-                # If the line isn't a hunk header, then we've reached the end
-                # of this patch and there's "junk" at the end.  Ignore the
-                # rest of this patch.
-                return
-            raise
-        orig_size = 0
-        mod_size = 0
-        while orig_size < hunk.orig_range or mod_size < hunk.mod_range:
-            hunk_line = parse_line(iter_lines.next())
-            hunk.lines.append(hunk_line)
-            if isinstance(hunk_line, (RemoveLine, ContextLine)):
-                orig_size += 1
-            if isinstance(hunk_line, (InsertLine, ContextLine)):
-                mod_size += 1
-    if hunk is not None:
-        yield hunk
 
 
 class Patch(object):
     def __init__(self, oldname, newname):
         self.oldname = oldname
         self.newname = newname
+        self.prefix = []
         self.hunks = []
 
-
-def parse_patch(iter_lines, allow_dirty=False):
-    (orig_name, mod_name) = get_patch_names(iter_lines)
-    patch = Patch(orig_name, mod_name)
-    for hunk in iter_hunks(iter_lines, allow_dirty):
-        patch.hunks.append(hunk)
-    return patch
-
-
-def iter_file_patch(iter_lines, allow_dirty=False):
-    saved_lines = []
-    orig_range = 0
-    beginning = True
-    for line in iter_lines:
-        if BINARY_FILES_RE.match(line):
-            continue
-        if line.startswith('=== ') or line.startswith('*** '):
-            continue
-        if line.startswith('#'):
-            continue
-        elif orig_range > 0:
-            if line.startswith('-') or line.startswith(' '):
-                orig_range -= 1
-        elif line.startswith('--- '):
-            if allow_dirty and beginning:
-                # Patches can have "junk" at the beginning
-                # Stripping junk from the end of patches is handled when we
-                # parse the patch
-                beginning = False
-            elif len(saved_lines) > 0:
-                yield saved_lines
-            saved_lines = []
-        elif line.startswith('@@'):
-            hunk = hunk_from_header(line)
-            orig_range = hunk.orig_range
-        saved_lines.append(line)
-    if len(saved_lines) > 0:
-        yield saved_lines
+    @staticmethod
+    def parse_one(lines, allow_dirty=True):
+        try:
+            first = lines.next()
+            if not first.startswith("--- "):
+                raise BadPatch("No orig name: %s" % first)
+            else:
+                orig_name = first[4:].rstrip("\n")
+        except StopIteration:
+            raise BadPatch("No orig line")
+        try:
+            second = lines.next()
+            if not second.startswith("+++ "):
+                raise BadPatch("No mod name")
+            else:
+                mod_name = second[4:].rstrip("\n")
+        except StopIteration:
+            raise BadPatch("No mod line")
+
+        patch = Patch(orig_name, mod_name)
+        for hunk in Hunk.parse(lines, allow_dirty):
+            patch.hunks.append(hunk)
+        patch.prefix = [first, second]
+        return patch
+
+    @staticmethod
+    def parse(lines, allow_dirty=True):
+        saved_lines = []
+        orig_range = 0
+        beginning = True
+        for line in lines:
+            if BINARY_FILES_RE.match(line):
+                continue
+            if line.startswith('=== ') or line.startswith('*** '):
+                continue
+            if line.startswith('#'):
+                continue
+            elif orig_range > 0:
+                if line.startswith('-') or line.startswith(' '):
+                    orig_range -= 1
+            elif line.startswith('--- '):
+                if allow_dirty and beginning:
+                    # Patches can have "junk" at the beginning
+                    # Stripping junk from the end of patches is handled when we
+                    # parse the patch
+                    beginning = False
+                elif len(saved_lines) > 0:
+                    yield Patch.parse_one(iter(saved_lines), allow_dirty)
+                saved_lines = []
+            elif line.startswith('@@'):
+                hunk = Hunk.from_header(line)
+                orig_range = hunk.orig_range
+            saved_lines.append(line)
+        if len(saved_lines) > 0:
+            yield Patch.parse_one(iter(saved_lines), allow_dirty)
 
 
 #
@@ -234,23 +213,38 @@ def iter_process_lines(argv):
         else:
             return
 
-def iter_desired_coverage(iter_lines):
-    for fil in iter_file_patch(iter_lines, allow_dirty=True):
-        patch = parse_patch(fil.__iter__(), allow_dirty=True)
-        filename = os.path.normpath(patch.newname.split("/", 1)[1])
-        (root, ext) = os.path.splitext(filename)
-        if ext not in COVERAGE_EXTENSIONS:
-            continue
-        for hunk in patch.hunks:
-            offset = hunk.mod_pos
-            for line in hunk.lines:
-                if isinstance(line, RemoveLine):
-                    yield (filename, offset, line.contents)
-                elif isinstance(line, InsertLine):
-                    yield (filename, offset, line.contents)
-                    offset += 1
-                else:
-                    offset += 1
+def ensure_gcda_file(gcno):
+    (base, ext) = os.path.splitext(gcno)
+    gcda = base + ".gcda"
+
+    # From gcov-io.h
+    #   The basic format of the files is
+    #
+    #   file : int32:magic int32:version int32:stamp record*
+    #
+    # magic for gcno files is 'gcno' as an integer, big or little endian
+    # and for gcda files it is 'gcda'
+
+    if os.path.exists(gcda):
+        return True
+
+    return False
+
+    # with open(gcno, 'r') as fi:
+    #       bytes = fi.read(12)
+    # if len(bytes) != 12:
+    #       return False
+    # if bytes[0:4] == 'gcno':
+    #       bytes = 'gcda' + bytes[4:]
+    # elif bytes[0:4] == 'oncg':
+    #       bytes = 'adcg' + bytes[4:]
+    # else:
+    #       print "bad", bytes[0:4]
+    #       return False
+    # with open(gcda, 'w') as fo:
+    #       fo.write(bytes)
+    # return True
+
 
 def find_all_gcno_files(directory):
     paths = []
@@ -261,10 +255,8 @@ def find_all_gcno_files(directory):
                 continue
             if not fnmatch.fnmatch(name, "*.gcno"):
                 continue
-            (base, ext) = os.path.splitext(path)
-            if not os.path.exists(base + ".gcda"):
-                continue
-            paths.append(path)
+            if ensure_gcda_file(path):
+                paths.append(path)
     os.path.walk(".", visit, paths)
     return paths
 
@@ -343,42 +335,121 @@ def gcov_coverage_lines(gcov_iter):
             pass
     return coverage
 
-
-def main(argv):
-    try:
-        opts, args = getopt.getopt(argv[1:], "h", ["help"])
-    except getopt.GetoptError, err:
-        print str(err)
-        return 2
-    for o, a in opts:
-        if o in ("-h", "--help"):
-            usage()
-            return 0
+class Output:
+    defaults = {
+            'diff.new': 'green',
+            'diff.meta': 'bold',
+            'diff.plain': 'normal',
+            'diff.frag': 'cyan',
+            'diff.old': 'red',
+            'diff.whitespace': 'normal red',
+            'diff.problem': 'normal red'
+    }
+
+    def __init__(self, output):
+        self.output = output
+        self.escapes = { }
+
+        cmd = ['git', 'config', '--get-colorbool',
+               'color.diff', output.isatty() and 'true' or 'false']
+        self.with_colors = subprocess.check_output(cmd).strip() == 'true'
+
+    def write_meta(self, data, meta):
+        if not self.with_colors:
+            pass
+        elif not meta:
+            self.output.write('\033[0m')
+        elif meta in self.escapes:
+            self.output.write(self.escapes[meta])
         else:
-            assert False, "unhandled option"
+            default = self.defaults.get(meta, 'normal')
+            cmd = ['git', 'config', '--get-color', "color.%s" % meta, default]
+            escape = subprocess.check_output(cmd)
+            self.output.write(escape)
+            self.escapes[meta] = escape
+        self.write(data)
+        if self.with_colors:
+            self.output.write('\033[0m')
+
+    def write(self, data):
+        self.output.write(data)
+
+def print_patch_hunks(patch, hunks, coverage, output):
+    for line in patch.prefix:
+        output.write_meta(line, 'diff.meta')
+    for hunk in hunks:
+        output.write_meta(hunk.header, 'diff.frag')
+        for (no, line) in hunk.lines:
+            if no in coverage:
+                output.write(" ")
+            else:
+                output.write_meta("!", 'diff.problem')
+            if line.startswith("-"):
+                output.write_meta(line, 'diff.old')
+            elif line.startswith("+"):
+                output.write_meta(line, 'diff.new')
+            else:
+                output.write_meta(line, 'diff.plain')
+
+def is_hunk_covered(hunk, coverage, patterns):
+    for (no, contents) in hunk.lines:
+        if no not in coverage:
+            for pattern in patterns:
+                data = contents[1:].strip()
+                if pattern.search(data):
+                    break
+            else:
+                return False
+    return True
 
-    if len(args) == 0:
-        cmd = ['git', 'diff', 'HEAD']
+
+def main(argv):
+    have_target = False
+    for arg in argv[1:]:
+        if not arg.startswith("-"):
+            have_target = True
+            break;
+
+    if have_target:
+        cmd = ['git', 'diff'] + argv[1:]
     else:
-        cmd = ['git', 'show'] + args
+        cmd = ['git', 'diff', 'HEAD']
 
-    # First process all the lines that we need
-    needed_coverage = { }
-    iterator = iter_process_lines(cmd)
-    for (filename, no, content) in iter_desired_coverage(iterator):
-        if filename not in needed_coverage:
-            needed_coverage[filename] = { }
-        needed_coverage[filename][no] = content
+    printed_any = 0
+    output = Output(sys.stdout)
+    patches_by_filename = { }
 
+    # Pull all the patches appart into the hunks that we need
+    for patch in Patch.parse(iter_process_lines(cmd)):
+        (name, ext) = os.path.splitext(patch.newname)
+        if ext not in COVERAGE_EXTENSIONS:
+            continue
+        filename = os.path.normpath(patch.newname.split("/", 1)[1])
+        if filename not in patches_by_filename:
+            patches_by_filename[filename] = []
+        patches_by_filename[filename].append(patch)
+
+    # Find all the gcno files in the directory
     gcno_cache = find_all_gcno_files(".")
 
-    for (filename, needed) in needed_coverage.items():
+    # Compile all the skip patterns
+    patterns = [re.compile(p) for p in SKIP_PATTERNS]
+
+    # Now go through and calculate coverage
+    for (filename, patches) in patches_by_filename.items():
         gcov = gcov_lines_for_files(filename, gcno_cache)
         coverage = gcov_coverage_lines(gcov)
 
-        for (no, content) in needed.items():
-            if no not in coverage:
-                print filename, no, content,
+        for patch in patches:
+            to_print = []
+            for hunk in patch.hunks:
+                if not is_hunk_covered(hunk, coverage, patterns):
+                    to_print.append(hunk)
+            if to_print:
+                print_patch_hunks(patch, to_print, coverage, output)
+                printed_any = 1
+
+    return printed_any
 
 if __name__ == '__main__':
     sys.exit(main(sys.argv))
-- 
cgit v1.2.3