# Copyright (C) 2012 by the Massachusetts Institute of Technology.

# All rights reserved.

#

# Export of this software from the United States of America may

#   require a specific license from the United States Government.

#   It is the responsibility of any person or organization contemplating

#   export to obtain such a license before exporting.

#

# WITHIN THAT CONSTRAINT, permission to use, copy, modify, and

# distribute this software and its documentation for any purpose and

# without fee is hereby granted, provided that the above copyright

# notice appear in all copies and that both that copyright notice and

# this permission notice appear in supporting documentation, and that

# the name of M.I.T. not be used in advertising or publicity pertaining

# to distribution of the software without specific, written prior

# permission.  Furthermore if you modify this software you must label

# your software as modified software and not distribute it in such a

# fashion that it might be confused with the original M.I.T. software.

# M.I.T. makes no representations about the suitability of

# this software for any purpose.  It is provided "as is" without express

# or implied warranty.

# This program attempts to detect MIT krb5 coding style violations

# attributable to the changes a series of git commits.  It can be run

# from anywhere within a git working tree.

import getopt

import os

import re

import sys

from subprocess import Popen, PIPE, call

def usage():

    u = ['Usage: cstyle [-w] [rev|rev1..rev2]',

         '',

         'By default, checks working tree against HEAD, or checks changes in',

         'HEAD if the working tree is clean.  With a revision option, checks',

         'changes in rev or the series rev1..rev2.  With the -w option,',

         'checks working tree against rev (defaults to HEAD).']

    sys.stderr.write('\n'.join(u) + '\n')

    sys.exit(1)

# Run a command and return a list of its output lines.

def run(args):

    # subprocess.check_output would be ideal here, but requires Python 2.7.

    p = Popen(args, stdout=PIPE, stderr=PIPE, universal_newlines=True)

    out, err = p.communicate()

    if p.returncode != 0:

        sys.stderr.write('Failed command: ' + ' '.join(args) + '\n')

        if err != '':

            sys.stderr.write('stderr:\n' + err)

        sys.stderr.write('Unexpected command failure, exiting\n')

        sys.exit(1)

    return out.splitlines()

# Find the top level of the git working tree, or None if we're not in

# one.

def find_toplevel():

    # git doesn't seem to have a way to do this, so we search by hand.

    dir = os.getcwd()

    while True:

        if os.path.exists(os.path.join(dir, '.git')):

            break

        parent = os.path.dirname(dir)

        if (parent == dir):

            return None

        dir = parent

    return dir

# Check for style issues in a file within rev (or within the current

# checkout if rev is None).  Report only problems on line numbers in

# new_lines.

line_re = re.compile(r'^\s*(\d+)  (.*)$')

def check_file(filename, rev, new_lines):

    # Process only C source files under src.

    root, ext = os.path.splitext(filename)

    if not filename.startswith('src/') or ext not in ('.c', '.h', '.hin'):

        return

    dispname = filename[4:]

    if rev is None:

        p1 = Popen(['cat', filename], stdout=PIPE)

    else:

        p1 = Popen(['git', 'show', rev + ':' + filename], stdout=PIPE)

    p2 = Popen([sys.executable, 'src/util/cstyle-file.py'], stdin=p1.stdout,

               stdout=PIPE, universal_newlines=True)

    p1.stdout.close()

    out, err = p2.communicate()

    if p2.returncode != 0:

        sys.exit(1)

    first = True

    for line in out.splitlines():

        m = line_re.match(line)

        if int(m.group(1)) in new_lines:

            if first:

                print('  ' + dispname + ':')

                first = False

            print('    ' + line)

# Determine the lines of each file modified by diff (a sequence of

# strings) and check for style violations in those lines.  rev

# indicates the version in which the new contents of each file can be

# found, or is None if the current contents are in the working copy.

chunk_header_re = re.compile(r'^@@ -\d+(,(\d+))? \+(\d+)(,(\d+))? @@')

def check_diff(diff, rev):

    old_count, new_count, lineno = 0, 0, 0

    filename = None

    for line in diff:

        if not line or line.startswith('\\ No newline'):

            continue

        if old_count > 0 or new_count > 0:

            # We're in a chunk.

            if line[0] == '+':

                new_lines.append(lineno)

            if line[0] in ('+', ' '):

                new_count = new_count - 1

                lineno = lineno + 1

            if line[0] in ('-', ' '):

                old_count = old_count - 1

        elif line.startswith('+++ b/'):

            # We're starting a new file.  Check the last one.

            if filename:

                check_file(filename, rev, new_lines)

            filename = line[6:]

            new_lines = []

        else:

            m = chunk_header_re.match(line)

            if m:

                old_count = int(m.group(2) or '1')

                lineno = int(m.group(3))

                new_count = int(m.group(5) or '1')

    # Check the last file in the diff.

    if filename:

        check_file(filename, rev, new_lines)

# Check a sequence of revisions for style issues.

def check_series(revlist):

    for rev in revlist:

        sys.stdout.flush()

        call(['git', 'show', '-s', '--oneline', rev])

        diff = run(['git', 'diff-tree', '--no-commit-id', '--root', '-M',

                    '--cc', rev])

        check_diff(diff, rev)

# Parse arguments.

try:

    opts, args = getopt.getopt(sys.argv[1:], 'w')

except getopt.GetoptError as err:

    print(str(err))

    usage()

if len(args) > 1:

    usage()

# Change to the top level of the working tree so we easily run the file

# checker and refer to working tree files.

toplevel = find_toplevel()

if toplevel is None:

    sys.stderr.write('%s must be run within a git working tree')

os.chdir(toplevel)

if ('-w', '') in opts:

    # Check the working tree against a base revision.

    arg = 'HEAD'

    if args:

        arg = args[0]

    check_diff(run(['git', 'diff', arg]), None)

elif args:

    # Check the differences in a rev or a series of revs.

    if '..' in args[0]:

        check_series(run(['git', 'rev-list', '--reverse', args[0]]))

    else:

        check_series([args[0]])

else:

    # No options or arguments.  Check the differences against HEAD, or

    # the differences in HEAD if the working tree is clean.

    diff = run(['git', 'diff', 'HEAD'])

    if diff:

        check_diff(diff, None)

    else:

        check_series(['HEAD'])