diff options
| -rwxr-xr-x | git-coverage | 384 |
1 files changed, 384 insertions, 0 deletions
diff --git a/git-coverage b/git-coverage new file mode 100755 index 0000000..ac837c9 --- /dev/null +++ b/git-coverage @@ -0,0 +1,384 @@ +#!/usr/bin/env python + +import fnmatch +import getopt +import os +import re +import subprocess +import sys + +COVERAGE_EXTENSIONS = [".c", ".cpp", ".cc"] + +# Portions of the code: +# +# Copyright (C) 2005-2010 Aaron Bentley, Canonical Ltd +# <aaron.bentley@utoronto.ca> +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +# + +BINARY_FILES_RE = re.compile('Binary files (.*) and (.*) differ\n') + +class MalformedHunkHeader(Exception): + def __init__(self, desc, line): + self.desc = desc + self.line = line + + def __str__(self): + return "Malformed hunk header. %(desc)s\n%(line)r" % self.__dict__ + +class BadPatch(Exception): + def __init(self, message): + self.message = message + + 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): + self.orig_pos = orig_pos + self.orig_range = orig_range + self.mod_pos = mod_pos + self.mod_range = mod_range + self.tail = tail + self.lines = [] + + +def iter_hunks(iter_lines, allow_dirty=False): + hunk = None + for line in iter_lines: + if line == "\n": + if hunk is not None: + yield hunk + hunk = None + continue + 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.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 + + +# +# End of code from bzr +# --------------------------------------------------------------------------- + +def iter_process_lines(argv): + proc = subprocess.Popen(argv, stdout=subprocess.PIPE) + while True: + line = proc.stdout.readline() + if line != "": + yield line + 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 find_all_gcno_files(directory): + paths = [] + def visit(paths, dirname, names): + for name in names: + path = os.path.normpath(os.path.join(dirname, name)) + if os.path.isdir(path): + 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) + os.path.walk(".", visit, paths) + return paths + + +def match_gcno_files(filename, gcno_cache): + matches = [] + (directory, base) = os.path.split(filename) + (base, ext) = os.path.splitext(base) + match = "%s/*%s.gcno" % (directory, base) + for gcno in gcno_cache: + if fnmatch.fnmatch(gcno, match): + matches.append(gcno) + return matches + +CREATING_RE = re.compile(".*'(.+\.gcov)'.*") + +def gcov_lines_for_files(filename, gcno_cache): + gcno = match_gcno_files(filename, gcno_cache) + if not gcno: + return + + # gcov wants to be in the directory with the source files + # so we make all the gcno paths absolute and change to that + # directory + + absgcno = [os.path.abspath(path) for path in gcno] + (directory, base) = os.path.split(filename) + + oldpwd = os.getcwd() + os.chdir(directory) + + # We scrape the output of the command for the names of the + # gcov files created, which we process, and then remove + gcovs = [] + + cmd = ['gcov', '--preserve-paths', '--relative-only'] + for line in iter_process_lines(cmd + absgcno): + match = CREATING_RE.match(line) + if not match: + continue + gcov = match.group(1) + if os.path.exists(gcov): + gcovs.append(os.path.abspath(gcov)) + + # Because we change the directory, we have to take care not + # to yield while the current directory is changed + + os.chdir(oldpwd) + + for gcov in gcovs: + with open(gcov, 'r') as f: + for l in f: + yield l + os.unlink(gcov) + + +def gcov_coverage_lines(gcov_iter): + coverage = { } + for line in gcov_iter: + + # Each gcov coverage output line looks something like this + # coverage: lineno: remainder is actual line content + parts = line.split(':', 2) + if len(parts) != 3: + continue + + covered = parts[0].strip() + try: + no = int(parts[1].strip()) + if covered == '-': + count = 0 + else: + count = int(covered) + coverage[no] = parts[2] + except ValueError: + 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 + else: + assert False, "unhandled option" + + if len(args) == 0: + cmd = ['git', 'diff', 'HEAD'] + else: + cmd = ['git', 'show'] + args + + # 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 + + gcno_cache = find_all_gcno_files(".") + + for (filename, needed) in needed_coverage.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, + +if __name__ == '__main__': + sys.exit(main(sys.argv)) |