#!/usr/bin/env python

import os

import sys

import optparse

import string

from subprocess import Popen, PIPE

import urllib

import re

masterBugsForBranch = {

    "393a82ea2fb151c5c47a7c86a48a41617f608dc1": [68616],

    "f48a90f4577389c423ae2ea783a6ba31c7fbaae7": [59935],

    "54ecd4d4473ddea4fe630726cab29ff06278ca2e": [39121],

    "d362c2e1c4559bf5ab4b4efaf3b8b09613f7c3fd": [54202]

}

# export PYTHONPATH="/path/to/your/webkit//WebKitTools/Scripts/"

env = os.environ;

# called from toplevel?

if os.path.exists("%s/WebKitTools/Scripts" % os.getcwd()):

    sys.path.append("%s/WebKitTools/Scripts" % os.getcwd())

if env.has_key("WEBKITDIR"):

    sys.path.append("%s/WebKitTools/Scripts/" % env["WEBKITDIR"])

# XXX last fallback

sys.path.append("%s/dev/webkit/land/WebKitTools/Scripts/" % env["HOME"])

from webkitpy.common.net.bugzilla import Bugzilla

from webkitpy.thirdparty.BeautifulSoup import BeautifulStoneSoup, SoupStrainer

from webkitpy.common.system.user import User

def die(msg):

    sys.stderr.write(msg + "\n")

    sys.exit(1)

class CommentBugzilla(Bugzilla):

    def _parse_bug_dictionary_from_xml(self, page):

        dict = Bugzilla._parse_bug_dictionary_from_xml(self, page)

        page.seek(0)

        soup = BeautifulStoneSoup(page)

        dict['comments'] = []

        for element in soup.findAll('thetext'):

            encodedString = element.string

            decodedString = unicode(BeautifulStoneSoup(encodedString, convertEntities=BeautifulStoneSoup.XML_ENTITIES))

            dict["comments"].append(decodedString)

        dict["blocked"] = [int(element.string) for element in soup.findAll("blocked")]

        dict["dependson"] = [int(element.string) for element in soup.findAll("dependson")]

        return dict

    def update_blockers_and_submit_comment(self, bug_id, new_blockers=None, comment_text="", cc=None):

        self.authenticate()

        self.browser.open(self.bug_url_for_bug_id(bug_id))

        self.browser.select_form(name="changeform")

        # blockers

        if new_blockers is not None:

            blockString = ""

            for blocker in new_blockers:

                if len(blockString) > 0:

                    blockString += ","

                blockString += str(blocker)

            self.browser['blocked'] = blockString

        # comment

        if comment_text:

            self.browser["comment"] = comment_text

            if cc:

                self.browser["newcc"] = ", ".join(cc)

        self.browser.submit()

def run(cmd, ignore_error=False):

    return Popen(cmd, stdout=PIPE).communicate()[0]

def commentForCherryPick(revision, sha1, branch):

    return "Revision r%s cherry-picked into %s with commit %s <http://gitorious.org/webkit/qtwebkit/commit/%s>" % (revision, branch, sha1[:7], sha1[:7])

def determineIfCherryPickedFromComments(comments, revision, sha1, branch):

    # matches new and old style comments (with/without the URL)

    commentText = "Revision r%s cherry-picked into %s with commit %s" % (revision, branch, sha1[:7])

    for comment in comments:

        if comment.find(commentText) != -1:

            return True

    return False

def normalizeBranchName(branch):

    branch = branch.translate(string.maketrans("._/", "---")) # XXX

    return branch;

def prompt(message):

    if options.always_no:

        print message, "n"

        return "n"

    return User.prompt(message)

def securityBugsInRange(releaseBranch, commitsRange, ignoreSkipped=False):

    skippedBugs = run(["git", "config", "--get-all", "skippedbugs.%s" % normalizeBranchName(releaseBranch)])

    fullLog = run(["git", "log", "%s" % commitsRange, "--grep=bugs.webkit.org/show_bug.cgi", "--grep=webkit.org/b/"])

    bugs = []

    for line in fullLog.split("\n"):

        if "bugs.webkit.org/show_bug.cgi" in line or "webkit.org/b/" in line:

            match = re.search("show_bug.cgi.id=(?P<bugId>\d+)(>|\.| )?", line)

            if not match:

                match = re.search("webkit.org/b/(?P<bugId>\d+)(>|\.| )?", line)

            if not match:

                continue

            bugId = match.group("bugId")

            bugs.append(bugId)

    bugs = set(bugs)

    print "%d bugs to check." % (len(bugs))

    secBugs = []

    count = 0

    for bug in bugs:

        count += 1

        if bug in skippedBugs and not ignoreSkipped:

            print "Warning: skipping bug %s" % bug

            continue

        url = "https://bugs.webkit.org/show_bug.cgi?id=%s" % bug

        print "[%03d/%03d] Checking %s" % (count, len(bugs), url)

        f = urllib.urlopen(url)

        page = "".join(f.readlines())

        if "<title>Access Denied</title>" in page:

            secBugs.append(bug)

            print " * security bug: %s" % url

    secBugs.sort()

    return secBugs

def bugsThatNeedToBeCherryPicked(masterBugs, releaseBranch, ignoreSkipped=False):

    skippedBugs = run(["git", "config", "--get-all", "skippedbugs.%s" % normalizeBranchName(releaseBranch)])

    bugs = []

    for masterBug in masterBugs:

        print "Querying master bug %s" % masterBug

        f = urllib.urlopen("https://bugs.webkit.org/showdependencytree.cgi?id=%s&hide_resolved=0" % masterBug)

        data = f.readlines()

        for line in data:

            if "view as bug list" in line:

                line = line.strip()

                match = re.search('href="(.*?)"', line)

                buglist = "https://bugs.webkit.org/%s&bug_status=RESOLVED&bug_status=VERIFIED&resolution=FIXED&ctype=csv" % match.group(1)

                f = urllib.urlopen(buglist)

                data = f.readlines()

                data = data[1:]

                for bug in data:

                    id = bug.split(",")[0]

                    if id in skippedBugs and not ignoreSkipped:

                        print "Warning: skipping bug %s" % id

                        continue

                    bugs.append(id)

    l = list(set(bugs))

    l.sort()

    return l

def addBugToSkipList(bug, branch):

    branch = normalizeBranchName(branch)

    run(["git", "config", "--add", "skippedbugs.%s" % branch, bug])

def main():

    releaseBranch = run(["git", "symbolic-ref", "HEAD"])[11:-1]

    masterBugs = []

    for commit in masterBugsForBranch.keys():

        branches = run(["git", "branch", "--contains=%s" % commit]).splitlines()

        for branch in branches:

            if branch.startswith("* "):

                masterBugs = masterBugsForBranch[commit]

                break

        if masterBugs:

            break

    if not masterBugs:

        die("Error, cannot find a master bug for the current branch!")

    if not options.no_git_pull:

        print "Running 'git pull' to make sure the branch is updated..."

        run(["git", "pull"])

    if options.base_commit:

        baseCommit = options.base_commit.strip()

    else:

        baseCommit = run(["git", "merge-base", "HEAD", "master"]).strip()

    baseRevision = int(run(["git", "svn", "find-rev", "%s" % baseCommit]).strip())

    print "Base commit for this branch: %s:r%d" % (baseCommit, baseRevision)

    if options.bugs:

        bugs = options.bugs.split(",")

    elif options.security_bugs_from:

        print "Checking which bugs are security-related in the range %s" % options.security_bugs_from

        bugs = securityBugsInRange(releaseBranch, options.security_bugs_from, options.ignore_skipped)

    else:

        print "Querying master bugs for a list of bugs with patches that need to be cherry-picked"

        bugs = bugsThatNeedToBeCherryPicked(masterBugs, releaseBranch, options.ignore_skipped)

    print "%s bugs: %s" % (len(bugs), [ int(i) for i in bugs ])

    if len(bugs) is 0:

        sys.exit(0)

    bugzilla = CommentBugzilla(dryrun = False)

    bugzilla.authenticate()

    commits = []

    count = 0

    for bug in bugs:

        count = count + 1

        dict = bugzilla.fetch_bug_dictionary(bug)

        print "--- [%03d of %03d] https://bugs.webkit.org/show_bug.cgi?id=%s - %s" % (count, len(bugs), dict["id"], dict["title"])

        # Figure out which revisions  this bug has been landed as

        revisions = set()

        for comment in dict['comments']:

            # Look for "landed in r1233"

            match = re.search("(comm?itt?ed|landed) ?(in)? ?(revision|r) ?(?P<revision>\d+)", comment, re.IGNORECASE)

            if not match:

                match = re.search("Landed .*in r?(?P<revision>\d+)\.?", comment, re.IGNORECASE)

            if not match:

                match = re.search("(Landed|comm?itt?ed)\n?.*\n??<?http://trac.webkit.org/changeset/(?P<revision>\d+)\.?", comment, re.IGNORECASE)

            if not match:

                match = re.search("Landed .*as r?(?P<revision>\d+)\.?", comment, re.IGNORECASE)

            if not match:

                match = re.search("Landed .*at r?(?P<revision>\d+)\.?", comment, re.IGNORECASE)

            if not match:

                match = re.search("Fixed in r?(?P<revision>\d+)\.?", comment, re.IGNORECASE)

            if not match:

                match = re.search("cherry-pick-for-backport: ?<r(?P<revision>\d+)>", comment, re.IGNORECASE)

            if not match:

                match = re.search("<cherry-pick-for-backport: ?r?(?P<revision>\d+)>", comment, re.IGNORECASE)

            if not match:

                match = re.search("^r?(?P<revision>\d+)\.?$", comment, re.IGNORECASE)

            if not match:

                match = re.search("^<?http://trac.webkit.org/changeset/(?P<revision>\d+)>?$", comment, re.IGNORECASE)

            if match:

                rev = int(match.group('revision'))

                if rev > baseRevision / 3: ## XXX arbitrary workaround for a few bogus detections such as "fixed in 4.7" (qt)

                    revisions.add(rev)

        if len(revisions) == 0:

            # TODO: Look in the repo for references to the bug URL

            print "Could not deduct commit revisions for this bug, please resolve manually."

            continue

        revisions = sorted(revisions)

        print "  Revisions: %s" % revisions

        if options.list_only:

            continue

        for rev in revisions:

            if rev <= baseRevision:

                continue

            found = run(["git", "log", "%s.." % baseCommit, "--pretty=found %H", "--grep=git-svn-id:.*@%s " % rev]).strip()

            if not "found" in found:

                print "  Revision %s has not been cherry-picked into this branch" % rev

                sha = run(["git", "svn", "find-rev", "r%s" % rev]).strip()

                if len(sha) == 0:

                    die("Cannot determine sha1 of revision %s. Did you forget to run git-svn fetch?" % rev)

                cmd = "git cherry-pick %s" % sha

                if prompt("Cherry-pick revision %s (%s)? (y/n) " % (rev, sha)) == "y":

                    if os.system(cmd) != 0:

                        die("Executing %s failed." % cmd)

        allCherryPicked = True

        foundCommentsForAllCherryPicks = True

        comment = ""

        for rev in revisions:

            if rev <= baseRevision:

                continue

            found = run(["git", "log", "%s.." % baseCommit, "--pretty=found %H", "--grep=git-svn-id:.*@%s " % rev]).strip()

            if "found" in found:

                sha1 = found[6:]

                print "%s for revision %s"  %(found, rev)

                if determineIfCherryPickedFromComments(dict["comments"], rev, sha1, releaseBranch):

                    print "Looks like it was already cherry-picked"

                elif prompt("Post comment about cherry-pick? (y/n) ") == "y":

                    comment += commentForCherryPick(rev, sha1, releaseBranch) + "\n"

                else:

                    foundCommentsForAllCherryPicks = False

            else:

                allCherryPicked = False

                foundCommentsForAllCherryPicks = False

        newBlockers = None

        if allCherryPicked:

            blockedBugs = set(dict["blocked"]).intersection(set(masterBugs))

            if blockedBugs:

                response = prompt("Bug has all patches cherry-picked and there are comments for all of them. Remove it from the blockers list? (y/n) ")

                if response == "y":

                    blockers = dict["blocked"]

                    [blockers.remove(bug) for bug in blockedBugs]

                    newBlockers = blockers

            elif foundCommentsForAllCherryPicks:

                print "Bug has all patches cherry-picked and there are comments for all of them. But the bug isn't directly blocking any master bug, so let's skip it."

                if not options.no_auto_skip:

                    print "(bug has been added to the skip list)"

                    addBugToSkipList(bug, releaseBranch)

            else:

                print "Bug has all patches cherry-picked but there are no comments in there... Please check manually."

        if comment or newBlockers is not None:

            print "Committing changes to bugzilla..."

            bugzilla.update_blockers_and_submit_comment(dict["id"], newBlockers, comment)

if __name__ == "__main__":

    try:

        op = optparse.OptionParser(usage="usage: %prog [options]")

        op.add_option("", "--no-auto-skip", default=False, action="store_true", help="Don't add bugs to the skipped list automatically")

        op.add_option("", "--no-git-pull", default=False, action="store_true", help="Don't run 'git pull' on the branch in the beginning")

        op.add_option("", "--ignore-skipped", default=False, action="store_true", help="Ignore the skipped list")

        op.add_option("", "--always-no", default=False, action="store_true", help="Automatically answer no to all questions")

        op.add_option("", "--bugs", type="string", action="store", help="Instead of querying the master bugs, use the list from BUGS (a comma separated list)")

        op.add_option("", "--base-commit", type="string", action="store", help="Use BASE_COMMIT as the starting point to check for cherry-picks")

        op.add_option("", "--security-bugs-from", type="string", action="store", help="Cherry-pick fixes for all security bugs in the given git range")

        op.add_option("", "--list-only", default=False, action="store_true", help="Only list the bugs, don't try to cherry-pick them")

        options = op.parse_args()[0]

        main()

    except KeyboardInterrupt:

        sys.exit(1)

# vim:et tw=0 ts=4 sw=4: