git-project

#!/usr/bin/python

import subprocess
import os
import sys

argv = sys.argv
argc = len(argv)

cwd = os.getcwd()

FLAGS = argv[2:]
PROMPT_ENABLED = True if '--prompt' in FLAGS else False

CURRENT_VERSION = '0.1.0'

using_version = '0.0.0'


def flag_dec(func):
    """flags to check function call

    :func: function to be executed based on flag
    :returns: result of the function call or handles when flag is disabled

    """
    def wrapfunc_and_call(*args, **kwargs):
        if func.__name__ == 'prompt':
            if PROMPT_ENABLED:
                return func(*args, **kwargs)
            else:
                return ''  # use empty string to indicate default
        else:
            return None
    return wrapfunc_and_call


@flag_dec
def prompt(msg):
    return raw_input(msg)


def finish(exitcode=0):
    os.chdir(cwd)
    sys.exit(exitcode)


def usage(exitcode=0):
    print "Usage: git project <init|save|load|version> [-- <subrepos>]"
    finish(exitcode)


def check_version(v1):
    version_diff = 0

    v1_arr = v1.split('.')
    v2_arr = CURRENT_VERSION.split('.')

    if v1_arr[0] > v2_arr[0]:
        version_diff = 1
    elif v1_arr[0] < v2_arr[0]:
        version_diff = -1
    elif v1_arr[1] > v2_arr[1]:
        version_diff = 1
    elif v1_arr[1] < v2_arr[1]:
        version_diff = -1
    elif v1_arr[2] > v2_arr[2]:
        version_diff = 1
    elif v1_arr[2] < v2_arr[2]:
        version_diff = -1

    if version_diff < 0:
        print '\n WARNING: .gitproj uses older version of git-project. Consider upgrading.'
    elif version_diff > 0:
        print 'git-project install is out of date. .gitproj version: {}, git-project version: {}. Aborting'.format(using_version, CURRENT_VERSION)
        finish(1)
    else:
        print 'Using .gitproj {}'.format(CURRENT_VERSION)


if argc < 2:
    usage(1)


darwin = False
if subprocess.check_output('uname', shell=True).strip() == 'Darwin':
    darwin = True

if darwin:
    sedi = '/usr/bin/sed -i .bak'
else:
    sedi = 'sed -i'

# --- Determine Mode ---

MODE = argv[1]

if MODE not in ['init', 'save', 'load', 'status', 'version']:
    usage(1)

if MODE == 'version':
    print CURRENT_VERSION
    finish(0)


# --- Find .gitproj ---

root = subprocess.check_output(
    'git rev-parse --show-toplevel', shell=True).strip()

os.chdir(root)

if not os.path.isfile('.gitproj'):
    print '.gitproj file missing. Refer to the git-project readme'
    finish(1)

# use the cwd .gitproj if exists
if os.path.exists(cwd+'/.gitproj'):
    # if there is a gitproj at cwd use it
    root = cwd
    os.chdir(root)
else:
    # look for .gitproj in the parent dir, ask for confirmation if found
    cwd_tmp = cwd
    last_slash = cwd_tmp.rfind('/')
    while (last_slash != -1):
        cwd_tmp = cwd_tmp[:last_slash]
        gitproj_tmpdir = cwd_tmp + '/.gitproj'
        if cwd_tmp.lower() == root.lower():
            print(
                'Hit the root of the project. '
                '\nUses project root .gitproj file: ', cwd_tmp)
            break
        if os.path.isfile(gitproj_tmpdir):
            load_confirm = prompt(
                'Found gitproj at ' + gitproj_tmpdir +
                '\nAre you sure you want to use it(y/n)?'
                )
            found_gitproj = False
            # make sure user gives either y/n
            while not found_gitproj:
                if load_confirm.lower() == 'y' or load_confirm == '':
                    root = cwd_tmp
                    os.chdir(root)
                    print 'using .gitproj found at: ' \
                        '\n\t{}'.format(gitproj_tmpdir)
                    found_gitproj = True
                    break
                elif load_confirm.lower() == 'n':
                    print 'continue searching'
                    break
                else:
                    load_confirm = prompt(
                        ' invalid input ' + load_confirm +
                        '\n Are you sure you want to use ' + gitproj_tmpdir
                        + '(y/n)?')
            # break while loop after found gitproj
            if found_gitproj:
                break
        last_slash = cwd_tmp.rfind('/')

gitproj_location = os.path.abspath('.gitproj')

BASE = os.path.dirname(gitproj_location).split(os.sep)[-1]

force = False
autopush = False
usecommit = False
autoclone = False
automerge = False
update = False


# ------------------------------------------------------------------------
# parse args

only_these = []
flags_done = False
args_iter = 2
while args_iter < argc:
    arg = argv[args_iter]
    if flags_done:
        only_these.append(arg)
    elif arg == '-f' or arg == '--force':
        force = True
    elif arg == '-c' or arg == '--commit':
        usecommit = True
    elif arg == '-a' or arg == '--autoclone':
        autoclone = True
    elif arg == '-m' or arg == '--automerge':
        automerge = True
    elif arg == '-u' or arg == '--update':
        update = True
    elif arg == '--autopush':
        autopush = True  # for testing purposes only
    elif arg == '--':
        flags_done = True
    else:
        usage()

    args_iter += 1

# ------------------------------------------------------------------------
# parse .gitproj

with open(gitproj_location) as f:
    lines = [line.strip() for line in f]

subrepos = []
subrepo_info = {}
parsing = 0
firstline = True
for line in lines:
    splitline = line.split(' ')
    if line.strip() == '':
        continue
    if parsing == 0 and splitline[0] == 'version:':
        using_version = splitline[1]
        check_version(using_version)
    elif parsing == 0 and line == 'repos:':
        parsing = 1
        if firstline:
            using_version = '0.0.0'
            check_version(using_version)
    elif parsing == 1 and line == 'states:':
        parsing = 2
    elif parsing == 1:
        # parse subrepos info
        info = line.split(' ')
        if using_version == '0.0.0':
            repo = info[0]
            local = repo
            remote = info[1]
        else:
            repo = info[0]
            local = info[1]
            remote = info[2]

        subrepo_info[repo] = {
            'local': local,
            'remote': remote
        }
        subrepos.append(repo)
    elif parsing == 2:
        info = line.split(' ')
        repo = info[0]
        branch = info[1]
        commit = info[2]
        if repo not in subrepo_info:
            print('Error parsing .gitproj. Unknown repo {}'.format(info[0]))
            finish(1)
        subrepo_info[repo]['branch'] = branch.strip()
        subrepo_info[repo]['commit'] = commit.strip()

    firstline = False


# ------------------------------------------------------------------------
# init case

if MODE == 'init':

    for repo in subrepos:
        repo_info = subrepo_info[repo]
        local = repo_info['local']
        url = repo_info['remote']

        print 'cloning repo {} from {}'.format(repo, url)

        if not os.path.exists(repo):
            result = subprocess.call(
                'git clone {} {}'.format(url, local),
                shell=True)
            if result != 0:
                print 'Error cloning repository {}'.format(repo)
                finish(1)
            subprocess.call(
                'echo "{}" >> .gitignore'.format(local),
                shell=True
            )
        else:
            print 'repo already exists!'

elif MODE == 'status':

    print 'TO BE IMPLEMENTED. Use "cat .gitproj" instead.'

elif MODE == 'save':

    if not (subprocess.call('git status | grep "working tree clean"', shell=True) == 0 or
            subprocess.call('git status | grep "working directory clean"', shell=True) == 0):
        print 'You have uncommitted changes. Please commit these before proceeding'
        finish(1)
    if not force and os.path.exists(gitproj_location):
        char = 'a'
        while True:
            print 'Saved State already exists. Overwrite? [y/n/q]'
            char = sys.stdin.readline().strip()
            if char == 'q' or char == 'n':
                finish(0)
            elif char == 'y':
                break

    if len(only_these) > 0:
        repos_to_update = only_these
    else:
        repos_to_update = subrepos

    for repo in repos_to_update:
        repo_info = subrepo_info[repo]
        local = repo_info['local']
        os.chdir(local)
        branch = subprocess.check_output(
            'git branch | grep "*" | awk \'{ print $2 }\'',
            shell=True
        ).strip()
        commit = subprocess.check_output(
            'git log | head -n1 | awk \'{ print $2 }\'',
            shell=True
        ).strip()

        repo_info['branch'] = branch
        repo_info['commit'] = commit

        os.chdir(root)

    with open(gitproj_location, 'w') as f:
        # iterate through subrepos (to ensure we preserve order)
        if using_version != '0.0.0':
            f.write('version: {}\n'.format(using_version))
        f.write('repos:\n')
        for repo in subrepos:
            repo_info = subrepo_info[repo]
            local = repo_info['local']
            remote = repo_info['remote']
            if using_version != '0.0.0':
                f.write('\t{} {} {}\n'.format(repo, local, remote))
            else:
                f.write('\t{} {}\n'.format(repo, remote))

        f.write('states:\n')
        for repo in subrepos:
            f.write('\t{} {} {}\n'.format(repo, subrepo_info[repo]['branch'], subrepo_info[repo]['commit']))

    if subprocess.call('git status | grep "working tree clean"', shell=True) == 0 or \
            subprocess.call('git status | grep "working directory clean"', shell=True) == 0:
        print 'No changes to be saved'
        finish(0)

#    if subprocess.call('git add {}'.format(gitproj_location), shell=True) != 0:
#        print 'Error'
#        finish(1)

#    if subprocess.call('git commit -m "Save Sub-Repository State"', shell=True) != 0:
#        print 'Error committing .gitproj'
#        finish(1)

elif MODE == 'load':

    if not os.path.exists(gitproj_location):
        print 'No Saved State to load'
        finish(1)

    print '\n\n***Loading {}***\n\n'.format(BASE)

    branch = subprocess.check_output('git branch | grep "*" | awk \'{print $2}\'', shell=True).strip()

    subprocess.call('git fetch origin --prune', shell=True)

    # if we are behind...
    if subprocess.call('git status | grep "behind"', shell=True) == 0:
        if update or automerge or force:
            if automerge or force:
                merge = 'y'
            else:
                while True:
                    print 'There are new commits in {}:{}. Do you want to merge them in? [y/n/q] '.format(BASE, branch)
                    merge = sys.stdin.readline().strip()
                    if merge == 'q':
                        finish(0)
                    elif merge == 'y' or merge == 'n':
                        break

            if merge == 'y':
                subprocess.call('git merge origin/{}'.format(branch), shell=True)
    else:
        print 'Your branch is up to date with origin/{}'.format(branch)

    print

    for repo in subrepos:

        repo_info = subrepo_info[repo]
        local = repo_info['local']
        branch = repo_info['branch']
        commit = repo_info['commit']

        # clone repo if it doesn't exist
        try:
            os.chdir(local)
        except OSError:
            if autoclone or force:
                clone = 'y'
            else:
                while True:
                    print '\n\nUnknown sub-repo {}, do you want to try to clone it? [y/n/q] '.format(local)
                    clone = sys.stdin.readline().strip()

                    if clone == 'q':
                        finish(0)
                    elif clone == 'y' or clone == 'n':
                        break

            if clone == 'y':
                if repo not in subrepo_info:
                    print 'Error: could not find url for repo {}'.format(repo)
                    finish(1)
                url = subrepo_info[repo]['remote']
                branch = subrepo_info[repo]['branch']

                print 'Attempting to clone {} from {}'.format(repo, url)
                if subprocess.call('git clone {} {} -b {}'.format(url, local, branch), shell=True) != 0:
                    print 'Error cloning repo {}'.format(repo)
                    finish(1)

                os.chdir(local)
            elif clone == 'n':
                continue

        print '\n\n***Loading {}***\n\n'.format(repo)

        if usecommit:
            res = subprocess.call('git checkout {}'.format(commit), shell=True)
            if res:
                print 'Error cloning repo {}'.format(repo)
                finish(1)
        else:
            checkout = 'y'
            # if ahead
            if subprocess.call('git status -sb | grep "ahead"', shell=True) == 0:
                checkout = 'n'
                push = 'n'
                if autopush:
                    push = 'y'
                else:
                    while True:
                        print 'You have un-pushed work in {}. Attempt to push to default remote? [y/n/q]'.format(repo)
                        push = sys.stdin.readline().strip()
                        if push == 'q':
                            finish(0)
                        elif push == 'y' or push == 'n':
                            break

                if push == 'y':
                    if subprocess.call('git push', shell=True) != 0:
                        print 'You have an un-pushed state and a simple push failed; refusing to orphan your commits'
                        finish(1)
                    checkout = 'y'

            if checkout == 'y':
                subprocess.call('git fetch origin --prune', shell=True)
                res = subprocess.call('git checkout -B {} {}'.format(branch, commit), shell=True)
                if res != 0:
                    print '\n\nError checking out commit {} on branch {}. Is {} pushed?'.format(commit, branch, repo)
                    finish(1);

                if subprocess.call('git status | grep "behind"', shell=True) == 0:
                    if update or automerge or force:
                        if automerge or force:
                            merge = 'y'
                        else:
                            while True:
                                print 'There are new commits on {}:{}, merge? [y/n/q] '.format(repo, branch)
                                merge = sys.stdin.readline().strip()
                                if merge == 'q':
                                    finish(0)
                                elif merge == 'y' or merge == 'n':
                                    break
                        if merge == 'y':
                            subprocess.call('git merge origin/{}'.format(branch), shell=True)

        os.chdir(root)


finish(0)