#!/usr/bin/env python

#

# prepares a report on the patches in a series file that do not yet have

# mainline tags.

#

# common usage: patch-report -s summary -r report < series

#

# -s specifies a file where a summary of patches per user is printed

# -r is a report with details about each patch

# -t does guards style tagging in the report of patches that can be reversed

# -f tries to reverse with rej.  This is very slow.

# -u prints only details on patches corresponding to a specific user.

#    this is everything before the @ sign in the email.

# 

# This can try to reverse all the untagged patches, use -p source-dir to

# specify the directory where it should try to reverse things.

#

# 

import os, sys, select, popen2, re

from optparse import OptionParser

# counts the number of times we find a given username.  We only

# consider emails from @suse and @novell, and don't include the domain

# name in the counting (so mason@suse.de and mason@suse.com are the same)

def countuser(s, users, foundusers, emailre):

    found = []

    for m in emailre.finditer(s):

        u = m.group(1)

        addr = m.group(2)

        if not addr.startswith('@suse') and not addr.startswith('@novell'):

            continue

        if u in foundusers:

            continue

        foundusers[u] = 1

        n = users.get(u, 0)

        users[u] = n + 1

        found.append(m.group(0))

    return found

parser = OptionParser(usage="usage: %prog [options]")

parser.add_option("-u", "--user", help="find a specific user", default="")

parser.add_option("-r", "--report-file", help="report output file", default="")

parser.add_option("-v", "--verbose", help="verbose", action="store_true",

                  default=False)

parser.add_option("-t", "--tag", help="tag patches in report",

                  action="store_true", default=False)

parser.add_option("-f", "--rej", help="try using rej", action="store_true",

                  default=False)

parser.add_option("-p", "--patch-dir", help="try to reverse patches in path",

                  default="")

parser.add_option("-s", "--summary-file", help="summary output file",

                  default="")

(options, args) = parser.parse_args()

# start a two way connection with xargs patch-tag.  

pipeout, pipein = popen2.popen2("xargs patch-tag -p From -p Signed-off-by -p Acked-by -p Patch-mainline -a Patch-mainline=empty -p Subject")

readers = [ sys.stdin, pipeout ]

writers = [ pipein ]

writeq = []

stdindone = False

patches = {}

# records details about all the patches

patchinfo = {}

# keeps the output in the same order as the series read over stdin

patchorder = []

# a count of the patches found for each user

users = {}

emailre = re.compile(r"([\w\.]+)(@[\w\.]+)")

goodwords = [ '2.6', 'yes', 'obsolete', 'never' ]

badwords = ['-mm', 'no', 'empty' ]

# ugly select loop to talk with patch-tag

while readers:

    (r, w, x) = select.select(readers, writers, [])

    for f in r:

        if f == sys.stdin:

            l = f.readline()

            if l:

                writeq.append(l)

            else:

                del readers[0]

                stdindone = True

                if len(writeq) == 0:

                    pipein.close()

                    writers = []

        elif f == pipeout:

            line = f.readline().rstrip()

            l = line.split()

            if l:

                # the format is:

                # file: Patch-mainline: data

                # data may be empty

                p = l[0].rstrip(':')

		if len(l) <= 1:

			continue

		htype = l[1].rstrip(':')

                if len(l) < 3:

                    t = 'empty'

                else:

                    t = " ".join(l[2:])

                patchinfo.setdefault(p, {}).setdefault(htype, []).append(t)

                if htype != 'Patch-mainline':

                    continue

                good = False

                t = t.lower()

                for x in goodwords:

                    if x in t:

                        good = True

                        break

                for x in badwords:

                    # For example, 2.6.16-mm2 is bad

                    if x in t:

                        good = False

                        break

                if not good:

                    patches[p] = t

                    patchorder.append(p)

            else:

                del readers[0]

    if w and writeq:

        w[0].write(writeq[0])

        del writeq[0]

        if stdindone and len(writeq) == 0:

            pipein.close()

            writers = []

if options.report_file:

    try:

        outf = file(options.report_file, "w")

    except IOError:

        sys.stderr.write("unable to open %s for writing\n" %

                         options.report_file);

        sys.exit(1)

else:

    outf = sys.stdout

# optionally try to figure out which patches we can reverse

if options.patch_dir:

    for i in xrange(len(patchorder)-1, -1, -1):

        p = patchorder[i]

        fuzz = 0

        failed = 0

        files = 0

        reject_files = 0

        # we want to be smart about counting the failed hunks

        patchf = os.popen("patch -f -p1 -d%s -R < '%s'" %

                        (options.patch_dir, p))

        for l in patchf:

            if options.verbose:

                sys.stderr.write(l)

            l = l.rstrip('\r\n')

            if l[:14] == 'patching file ':

                files += 1

            elif l.find('saving rejects to file') >= 0:

                reject_files += 1

            elif l.find('FAILED at') >= 0:

                failed += 1

            elif l.find('with fuzz') >= 0:

                fuzz += 1

        patcherr = patchf.close()

        if failed == 0 and patcherr == None:

            if fuzz:

                patchinfo[p]['Reverse'] = 'fuzzy'

            else:

                patchinfo[p]['Reverse'] = 'yes'

        else:

            str = "hunks failed %d fuzzy %d files %d reject files %d" % (failed,

                  fuzz, files, reject_files)

            if options.rej:

                patchpath = os.path.abspath(p)

                ret = os.system("cd '%s' ; rej -R -a --dry-run -F -M -p 1 '%s'"

                                % (options.patch_dir, patchpath))

                if ret == 0:

                    str = "rej resolved "  + str

            patchinfo[p]['Reverse'] = str

for p in patchorder:

    h = patchinfo[p]

    foundusers = {}

    if options.user:

        good = False

        for x in ['Acked-by', 'Signed-off-by', 'From']:

            if options.user in "".join(h.get(x, [])):

                good = True

                break

        if not good:

            continue

    tag = "+nag "

    # always print From and Subject.  Only print acked-by or signed-off-by

    # if it is a suse/novell person

    if 'From' in h:

        l = " ".join(h['From'])

        outf.write("# From: %s\n" % l)

        countuser(l, users, foundusers, emailre)

    if 'Subject' in h:

        outf.write("# Subject: %s\n" % " ".join(h['Subject']))

    for x in ['Acked-by', 'Signed-off-by']:

        if x in h:

            l = " ".join(h[x])

            found = countuser(l, users, foundusers, emailre)

            if found:

                outf.write("# %s: %s\n" % (x, " ".join(found)))

    if 'Reverse' in h:

        t = h['Reverse']

        if t == 'yes':

            tag = "+reverse "

        elif t == 'fuzzy':

            tag = "+reverse-fuzzy "

        outf.write("# Reverse: %s\n" % h['Reverse'])

    if options.tag:

        p = tag + p

    outf.write("%s\n\n" % (p))

if options.summary_file:

    try:

        outf = file(options.summary_file, "w")

    except IOError:

        sys.stderr.write("unable to open %s for writing\n" %

                         options.report_file);

        sys.exit(1)

else:

    outf = sys.stdout

userk = users.keys()

userk.sort()

outf.write("Total untagged patches: %d\n" % len(patchorder))

for u in userk:

    if options.user and options.user not in u:

        continue

    outf.write("%s:  %d\n" % (u, users[u]))