# githelp.py - Try to map Git commands to Mercurial equivalents.

#

# Copyright 2013 Facebook, Inc.

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

"""try mapping git commands to Mercurial commands

Tries to map a given git command to a Mercurial command:

  $ hg githelp -- git checkout master

  hg update master

If an unknown command or parameter combination is detected, an error is

produced.

"""

from __future__ import absolute_import

import getopt

import re

from mercurial.i18n import _

from mercurial import (

    error,

    fancyopts,

    registrar,

    util,

)

# Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for

# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should

# be specifying the version(s) of Mercurial they are tested with, or

# leave the attribute unspecified.

testedwith = 'ships-with-hg-core'

cmdtable = {}

command = registrar.command(cmdtable)

def convert(s):

    if s.startswith("origin/"):

        return s[7:]

    if 'HEAD' in s:

        s = s.replace('HEAD', '.')

    # HEAD~ in git is .~1 in mercurial

    s = re.sub('~$', '~1', s)

    return s

@command('^githelp|git', [

    ], _('hg githelp'))

def githelp(ui, repo, *args, **kwargs):

    '''suggests the Mercurial equivalent of the given git command

    Usage: hg githelp -- <git command>

    '''

    if len(args) == 0 or (len(args) == 1 and args[0] =='git'):

        raise error.Abort(_('missing git command - '

                            'usage: hg githelp -- <git command>'))

    if args[0] == 'git':

        args = args[1:]

    cmd = args[0]

    if not cmd in gitcommands:

        raise error.Abort("error: unknown git command %s" % (cmd))

    ui.pager('githelp')

    args = args[1:]

    return gitcommands[cmd](ui, repo, *args, **kwargs)

def parseoptions(ui, cmdoptions, args):

    cmdoptions = list(cmdoptions)

    opts = {}

    args = list(args)

    while True:

        try:

            args = fancyopts.fancyopts(list(args), cmdoptions, opts, True)

            break

        except getopt.GetoptError as ex:

            flag = None

            if "requires argument" in ex.msg:

                raise

            if ('--' + ex.opt) in ex.msg:

                flag = '--' + ex.opt

            elif ('-' + ex.opt) in ex.msg:

                flag = '-' + ex.opt

            else:

                raise error.Abort("unknown option %s" % ex.opt)

            try:

                args.remove(flag)

            except Exception:

                raise error.Abort(

                    "unknown option {0} packed with other options\n"

                    "Please try passing the option as it's own flag: -{0}" \

                    .format(ex.opt))

            ui.warn(_("ignoring unknown option %s\n") % flag)

    args = list([convert(x) for x in args])

    opts = dict([(k, convert(v)) if isinstance(v, str) else (k, v)

                                 for k, v in opts.iteritems()])

    return args, opts

class Command(object):

    def __init__(self, name):

        self.name = name

        self.args = []

        self.opts = {}

    def __str__(self):

        cmd = "hg " + self.name

        if self.opts:

            for k, values in sorted(self.opts.iteritems()):

                for v in values:

                    if v:

                        cmd += " %s %s" % (k, v)

                    else:

                        cmd += " %s" % (k,)

        if self.args:

            cmd += " "

            cmd += " ".join(self.args)

        return cmd

    def append(self, value):

        self.args.append(value)

    def extend(self, values):

        self.args.extend(values)

    def __setitem__(self, key, value):

        values = self.opts.setdefault(key, [])

        values.append(value)

    def __and__(self, other):

        return AndCommand(self, other)

class AndCommand(object):

    def __init__(self, left, right):

        self.left = left

        self.right = right

    def __str__(self):

        return "%s && %s" % (self.left, self.right)

    def __and__(self, other):

        return AndCommand(self, other)

def add(ui, repo, *args, **kwargs):

    cmdoptions = [

        ('A', 'all', None, ''),

        ('p', 'patch', None, ''),

    ]

    args, opts = parseoptions(ui, cmdoptions, args)

    if (opts.get('patch')):

        ui.status(_("note: Mercurial will commit when complete, "

                    "as there is no staging area in Mercurial\n\n"))

        cmd = Command('commit --interactive')

    else:

        cmd = Command("add")

        if not opts.get('all'):

            cmd.extend(args)

        else:

            ui.status(_("note: use hg addremove to remove files that have "

                        "been deleted.\n\n"))

    ui.status((str(cmd)), "\n")

def am(ui, repo, *args, **kwargs):

    cmdoptions=[

    ]

    args, opts = parseoptions(ui, cmdoptions, args)

    cmd = Command('import')

    ui.status(str(cmd), "\n")

def apply(ui, repo, *args, **kwargs):

    cmdoptions = [

        ('p', 'p', int, ''),

    ]

    args, opts = parseoptions(ui, cmdoptions, args)

    cmd = Command('import --no-commit')

    if (opts.get('p')):

        cmd['-p'] = opts.get('p')

    cmd.extend(args)

    ui.status((str(cmd)), "\n")

def bisect(ui, repo, *args, **kwargs):

    ui.status(_("See 'hg help bisect' for how to use bisect.\n\n"))

def blame(ui, repo, *args, **kwargs):

    cmdoptions = [

    ]

    args, opts = parseoptions(ui, cmdoptions, args)

    cmd = Command('annotate -udl')

    cmd.extend([convert(v) for v in args])

    ui.status((str(cmd)), "\n")

def branch(ui, repo, *args, **kwargs):

    cmdoptions = [

        ('', 'set-upstream', None, ''),

        ('', 'set-upstream-to', '', ''),

        ('d', 'delete', None, ''),

        ('D', 'delete', None, ''),

        ('m', 'move', None, ''),

        ('M', 'move', None, ''),

    ]

    args, opts = parseoptions(ui, cmdoptions, args)

    cmd = Command("bookmark")

    if opts.get('set_upstream') or opts.get('set_upstream_to'):

        ui.status(_("Mercurial has no concept of upstream branches\n"))

        return

    elif opts.get('delete'):

        cmd = Command("strip")

        for branch in args:

            cmd['-B'] = branch

        else:

            cmd['-B'] = None

    elif opts.get('move'):

        if len(args) > 0:

            if len(args) > 1:

                old = args.pop(0)

            else:

                # shell command to output the active bookmark for the active

                # revision

                old = '`hg log -T"{activebookmark}" -r .`'

        new = args[0]

        cmd['-m'] = old

        cmd.append(new)

    else:

        if len(args) > 1:

            cmd['-r'] = args[1]

            cmd.append(args[0])

        elif len(args) == 1:

            cmd.append(args[0])

    ui.status((str(cmd)), "\n")

def ispath(repo, string):

    """

    The first argument to git checkout can either be a revision or a path. Let's

    generally assume it's a revision, unless it's obviously a path. There are

    too many ways to spell revisions in git for us to reasonably catch all of

    them, so let's be conservative.

    """

    if string in repo:

        # if it's definitely a revision let's not even check if a file of the

        # same name exists.

        return False

    cwd = repo.getcwd()

    if cwd == '':

        repopath = string

    else:

        repopath = cwd + '/' + string

    exists = repo.wvfs.exists(repopath)

    if exists:

        return True

    manifest = repo['.'].manifest()

    didexist = (repopath in manifest) or manifest.hasdir(repopath)

    return didexist

def checkout(ui, repo, *args, **kwargs):

    cmdoptions = [

        ('b', 'branch', '', ''),

        ('B', 'branch', '', ''),

        ('f', 'force', None, ''),

        ('p', 'patch', None, ''),

    ]

    paths = []

    if '--' in args:

        sepindex = args.index('--')

        paths.extend(args[sepindex + 1:])

        args = args[:sepindex]

    args, opts = parseoptions(ui, cmdoptions, args)

    rev = None

    if args and ispath(repo, args[0]):

        paths = args + paths

    elif args:

        rev = args[0]

        paths = args[1:] + paths

    cmd = Command('update')

    if opts.get('force'):

        if paths or rev:

            cmd['-C'] = None

    if opts.get('patch'):

        cmd = Command('revert')

        cmd['-i'] = None

    if opts.get('branch'):

        if len(args) == 0:

            cmd = Command('bookmark')

            cmd.append(opts.get('branch'))

        else:

            cmd.append(args[0])

            bookcmd = Command('bookmark')

            bookcmd.append(opts.get('branch'))

            cmd = cmd & bookcmd

    # if there is any path argument supplied, use revert instead of update

    elif len(paths) > 0:

        ui.status(_("note: use --no-backup to avoid creating .orig files\n\n"))

        cmd = Command('revert')

        if opts.get('patch'):

            cmd['-i'] = None

        if rev:

            cmd['-r'] = rev

        cmd.extend(paths)

    elif rev:

        if opts.get('patch'):

            cmd['-r'] = rev

        else:

            cmd.append(rev)

    elif opts.get('force'):

        cmd = Command('revert')

        cmd['--all'] = None

    else:

        raise error.Abort("a commit must be specified")

    ui.status((str(cmd)), "\n")

def cherrypick(ui, repo, *args, **kwargs):

    cmdoptions = [

        ('', 'continue', None, ''),

        ('', 'abort', None, ''),

        ('e', 'edit', None, ''),

    ]

    args, opts = parseoptions(ui, cmdoptions, args)

    cmd = Command('graft')

    if opts.get('edit'):

        cmd['--edit'] = None

    if opts.get('continue'):

        cmd['--continue'] = None

    elif opts.get('abort'):

        ui.status(_("note: hg graft does not have --abort.\n\n"))

        return

    else:

        cmd.extend(args)

    ui.status((str(cmd)), "\n")

def clean(ui, repo, *args, **kwargs):

    cmdoptions = [

        ('d', 'd', None, ''),

        ('f', 'force', None, ''),

        ('x', 'x', None, ''),

    ]

    args, opts = parseoptions(ui, cmdoptions, args)

    cmd = Command('purge')

    if opts.get('x'):

        cmd['--all'] = None

    cmd.extend(args)

    ui.status((str(cmd)), "\n")

def clone(ui, repo, *args, **kwargs):

    cmdoptions = [

        ('', 'bare', None, ''),

        ('n', 'no-checkout', None, ''),

        ('b', 'branch', '', ''),

    ]

    args, opts = parseoptions(ui, cmdoptions, args)

    if len(args) == 0:

        raise error.Abort("a repository to clone must be specified")

    cmd = Command('clone')

    cmd.append(args[0])

    if len(args) > 1:

        cmd.append(args[1])

    if opts.get('bare'):

        cmd['-U'] = None

        ui.status(_("note: Mercurial does not have bare clones. " +

            "-U will clone the repo without checking out a commit\n\n"))