gitcommit

#!/usr/bin/env python3

# get the git difference
#   git diff <local branch> <remote>/<remote branch>
#    write output in temporary file
# if the user requests a force push:
#   git push -f -u origin <branch>
# If a PR is provided then
#   push the difference into the local repository and get the url
#   write a comment into the PR with the diff:
#       gh pr comment <PR> --body <url> -R <REPO>
#

import sys, git, os, argparse, subprocess, re, pathlib, shutil, json
from datetime import datetime
from command import Command
from util import prformat, fg, bg

dry_run = False
verbose = False
timeout = 1000

def gh_get_all_pr_users(pr, target, owner):
    global dry_run
    global verbose

    cmd = Command('gh pr view %d -R %s --json reviews' %
            (pr, target), verbose=verbose)
    rc, output = cmd.exec_cmd()
    if rc:
        prformat(fg.red, "Failed to get users in PR %d" % (pr))
        exit(1)

    cmd = Command('gh pr view %d -R %s --json comments' %
            (pr, target), verbose=verbose)
    rc, output2 = cmd.exec_cmd()
    if rc:
        prformat(fg.red, "Failed to get users in PR %d" % (pr))
        exit(1)
    jdata = json.loads(output)
    users = []
    for review in jdata['reviews']:
        if review['author']['login'] != owner and '@'+review['author']['login'] not in users:
            users.append('@'+review['author']['login'])

    jdata = json.loads(output2)
    for comment in jdata['comments']:
        if comment['author']['login'] != owner and '@'+comment['author']['login'] not in users:
            users.append('@'+comment['author']['login'])
    return users

def gh_add_comment(url, pr, target, owner):
    global dry_run
    global verbose

    users = ', '.join(gh_get_all_pr_users(pr, target, owner))

    comment = users + "\n" \
              "This is an automatically generated comment.\n" \
              "The link below:\n" \
              "%s\n" \
              "Shows the updates in the new revision of this PR\n" \
               % (url)
    cmd = Command('gh pr comment %d -R %s -b "%s"'%
            (pr, target, comment), fake=dry_run, verbose=verbose)
    rc, output = cmd.exec_cmd()
    if rc:
        prformat(fg.red, "Failed to add comment to github PR %d" % (pr))
        exit(1)

def generate_git_diff(repo, pr):
    remote = repo.remote().name
    local = repo.active_branch.name

    date = datetime.now()
    filename = "%d-%d-%d-%d-%d-%d-%d.%d.patch" % \
        (date.year, date.month, date.day, date.hour,
         date.minute, date.second, date.microsecond, pr)
    filename = os.path.join("/", "tmp", filename)

    cmd = Command("git diff %s/%s..%s" %
            (remote, local, local), verbose=verbose)
    rc, output = cmd.exec_cmd()
    if rc:
        prformat(fg.red, "Failed to generate a diff between %s and %s " % (remote, local))
        exit(1)

    if len(output) == 0:
        prformat(fg.red, "No changes detected")
        exit(0)

    with open(filename, 'w') as f:
        f.write(output)
        f.write('\n')

    return filename

def git_initialize_repo(fq_repo_name, repo_name):
    cwd = os.getcwd()
    tmpdir = os.path.join(os.path.sep, 'tmp')
    if verbose:
        prformat(fg.bold+fg.green, "changing dir to: %s" % (tmpdir))
    if not dry_run:
        os.chdir(tmpdir)

    # check if this already exists from previous runs
    if (os.path.isdir(os.path.join(tmpdir, repo_name))):
        shutil.rmtree(repo_name)

    cmd = Command("gh repo clone %s" % (fq_repo_name), fake=dry_run, verbose=verbose)
    rc, output = cmd.exec_cmd()
    if rc:
        prformat(fg.red, "Failed to clone newly created repo")
        exit(1)
    path = os.path.join(tmpdir, repo_name)
    if verbose:
        prformat(fg.bold+fg.green, "changing dir to: %s" % (path))
    if not dry_run:
        os.chdir(path)
    cmd = Command("git init", fake=dry_run, verbose=verbose)
    rc, output = cmd.exec_cmd()
    if rc:
        prformat(fg.red, "Failed to initialize repo")
        exit(1)
    with open("README.md", 'w') as f:
        f.write("This is an automatically created repo to track code changes\n")
    cmd = Command("git add README.md", fake=dry_run, verbose=verbose)
    rc, output = cmd.exec_cmd()
    if rc:
        prformat(fg.red, "failed to add README.md")
        exit(1)
    cmd = Command('git commit -m "first commit"', fake=dry_run, verbose=verbose)
    rc, output = cmd.exec_cmd()
    if rc:
        prformat(fg.red, "failed to commit README.md")
        exit(1)
    cmd = Command("git branch -M main", fake=dry_run, verbose=verbose)
    rc, output = cmd.exec_cmd()
    if rc:
        prformat(fg.red, "failed to create main branch")
        exit(1)
    try:
        cmd = Command("git remote add origin https://github.com/%s.git" % (fq_repo_name),
                    fake=dry_run, verbose=verbose)
        rc, output = cmd.exec_cmd()
    except:
        pass
    cmd = Command("git push -u origin main", fake=dry_run, verbose=verbose)
    rc, output = cmd.exec_cmd()
    if rc:
        prformat(fg.red, "Failed to push origin upstream")
        exit(1)

    if not dry_run:
        shutil.rmtree(os.path.join(tmpdir, repo_name))

    if verbose:
        prformat(fg.bold+fg.green, "removing " + repo_name)

    os.chdir(cwd)
    if verbose:
        prformat(fg.bold+fg.green, "changing dir to: %s" % (cwd))

def gh_create_diff_repo():
    # gh auth status
    cmd = Command("gh auth status", verbose=verbose)
    rc, output = cmd.exec_cmd()
    if rc:
        prformat(fg.red, "Failed gh auth status")
        exit(1)
    l = output.split('\n')
    username = None
    for e in l:
        if "Logged in to github.com as " in e:
            a = [elem for elem in re.split(r'Logged in to github.com as | ', e) if len(elem) > 0]
            username = a[1]
    if not username:
        prformat(fg.red, "couldn't find user name")
        exit(1)
    # gh repo list
    cmd = Command("gh repo list", verbose=verbose)
    rc, output = cmd.exec_cmd()
    if rc:
        prformat(fg.red, "Failed gh repo list")
        exit(1)
    l = output.split('\n')
    # check if gh_diff_<username> exists
    repo_name = "gh_diff_"+username
    fq_repo_name = username+'/'+"gh_diff_"+username
    for e in l:
        if fq_repo_name in e:
            return fq_repo_name, repo_name, username
    # gh repo create gh_diff_<username> --public -d "Repo for code difference"
    cmd = Command('gh repo create %s --public -d "Repo for github code differecence"' % (repo_name),
                  fake=dry_run, verbose=verbose)
    rc, output = cmd.exec_cmd()
    if rc:
        prformat(fg.red, "Failed to create %s", fq_repo_name)
        exit(1)

    git_initialize_repo(fq_repo_name, repo_name)

    return fq_repo_name, repo_name, username

def gh_push_change(fname, un, fq_repo_name, repo_name, pr, keep):
    repo_dir = os.path.join(os.path.sep, 'tmp', repo_name)
    if (os.path.isdir(repo_dir)):
        shutil.rmtree(repo_dir)
    # clone the repository in /tmp
    cmd = Command("gh repo clone %s %s" % (fq_repo_name, repo_dir),
                  fake=dry_run, verbose=verbose)
    rc, output = cmd.exec_cmd()
    if rc:
        prformat(fg.red, "Failed to clone diff repo")
        exit(1)
    # cp the file in the repo
    repo_dir = os.path.join(os.path.sep, 'tmp', repo_name)
    pr_dir = os.path.join(repo_dir, "%d" % (pr))
    if not dry_run:
        pathlib.Path(pr_dir).mkdir(parents=True, exist_ok=True)
        shutil.move(fname, os.path.join(pr_dir, os.path.basename(fname)))
    elif verbose:
        prformat(fg.green+fg.bold, "mkdir %s" % pr_dir)
        prformat(fg.green+fg.bold, "mv %s %s" % (fname, pr_dir))
    # git add and force push up
    if not dry_run:
        repo = git.Repo(os.path.join(repo_dir, ".git"))
        repo.git.add(all = True)
        repo.index.commit("Changes for PR-%d" % (pr))
        origin = repo.remote(name = "origin")
        origin.push()
        if not keep:
            shutil.rmtree(repo_dir)
    url = "https://github.com/%s/blob/main/%d/%s" % (fq_repo_name, pr, os.path.basename(fname))
    if verbose:
        prformat(fg.green+fg.bold, "Path to patch: %s" % (url))

    return url

def git_force_push(remote, branch):
    global dry_run
    global verbose

    cmd = Command("git push -f -u %s %s" % (remote, branch), fake=dry_run, verbose=verbose)
    rc, output = cmd.exec_cmd()
    if rc:
        prformat(fg.red, "Failed to commit changes")
        exit(1)

def print_help(parser):
    prformat(fg.red, "Always execute script from the top of a git repository")
    parser.print_help()

if __name__ == '__main__':
    argv = sys.argv[1:]

    parser = argparse.ArgumentParser()
    parser.add_argument("-p", "--pr", help = "Pull Request Number", type=int)
    parser.add_argument("-R", "--repo", help = "Target Github repository")
    parser.add_argument("-d", "--dry-run", help = "Do a dry run", action="store_true")
    parser.add_argument("-v", "--verbose", help = "Verbose mode", action="store_true")
    parser.add_argument("-k", "--keep", help = "Keep Patch", action="store_true")
    parser.add_argument("-f", "--force", help = "Force Push Change", action="store_true")
    #parser.add_argument("-k", "--keep", help = "Keep Patch", nargs='?', const=0, type=int)

    if len(argv) == 0:
        print_help(parser)
        exit()

    args = parser.parse_known_args()

    repo = git.Repo('.git')

    dry_run = args[0].dry_run
    verbose = args[0].verbose

    if args[0].pr == None:
        exit(0)

    if args[0].repo == None:
        exit(0)

    # generate difference between local branch and origin
    diff_file = generate_git_diff(repo, args[0].pr)

    fq_repo_name, repo_name, username = gh_create_diff_repo()
    change_url = gh_push_change(diff_file, username, fq_repo_name, repo_name, args[0].pr, args[0].keep)
    if args[0].force:
        git_force_push(repo.remote().name, repo.active_branch.name)
        gh_add_comment(change_url, args[0].pr, args[0].repo, username)