# 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.

"""

import getopt

import re

from mercurial.i18n import _

from mercurial import (

    encoding,

    error,

    fancyopts,

    pycompat,

    registrar,

    scmutil,

)

from mercurial.utils import procutil

# 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 = b'ships-with-hg-core'

cmdtable = {}

command = registrar.command(cmdtable)

def convert(s):

    if s.startswith(b"origin/"):

        return s[7:]

    if b'HEAD' in s:

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

    # HEAD~ in git is .~1 in mercurial

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

    return s

@command(

    b'githelp|git',

    [],

    _(b'hg githelp'),

    helpcategory=command.CATEGORY_HELP,

    helpbasic=True,

)

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] == b'git'):

        raise error.Abort(

            _(b'missing git command - usage: hg githelp -- <git command>')

        )

    if args[0] == b'git':

        args = args[1:]

    cmd = args[0]

    if not cmd in gitcommands:

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

    ui.pager(b'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:

            if "requires argument" in ex.msg:

                raise

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

                flag = b'--' + pycompat.bytestr(ex.opt)

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

                flag = b'-' + pycompat.bytestr(ex.opt)

            else:

                raise error.Abort(

                    _(b"unknown option %s") % pycompat.bytestr(ex.opt)

                )

            try:

                args.remove(flag)

            except Exception:

                msg = _(b"unknown option '%s' packed with other options")

                hint = _(b"please try passing the option as its own flag: -%s")

                raise error.Abort(

                    msg % pycompat.bytestr(ex.opt),

                    hint=hint % pycompat.bytestr(ex.opt),

                )

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

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

    opts = dict(

        [

            (k, convert(v)) if isinstance(v, bytes) else (k, v)

            for k, v in opts.items()

        ]

    )

    return args, opts

class Command:

    def __init__(self, name):

        self.name = name

        self.args = []

        self.opts = {}

    def __bytes__(self):

        cmd = b"hg " + self.name

        if self.opts:

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

                for v in values:

                    if v:

                        if isinstance(v, int):

                            fmt = b' %s %d'

                        else:

                            fmt = b' %s %s'

                        cmd += fmt % (k, v)

                    else:

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

        if self.args:

            cmd += b" "

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

        return cmd

    __str__ = encoding.strmethod(__bytes__)

    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:

    def __init__(self, left, right):

        self.left = left

        self.right = right

    def __str__(self):

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

    def __and__(self, other):

        return AndCommand(self, other)

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

    cmdoptions = [

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

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

    ]

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

    if opts.get(b'patch'):

        ui.status(

            _(

                b"note: Mercurial will commit when complete, "

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

            )

        )

        cmd = Command(b'commit --interactive')

    else:

        cmd = Command(b"add")

        if not opts.get(b'all'):

            cmd.extend(args)

        else:

            ui.status(

                _(

                    b"note: use hg addremove to remove files that have "

                    b"been deleted\n\n"

                )

            )

    ui.status((bytes(cmd)), b"\n")

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

    cmdoptions = []

    parseoptions(ui, cmdoptions, args)

    cmd = Command(b'import')

    ui.status(bytes(cmd), b"\n")

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

    cmdoptions = [

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

        (b'', b'directory', b'', b''),

    ]

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

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

    if opts.get(b'p'):

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

    if opts.get(b'directory'):

        cmd[b'--prefix'] = opts.get(b'directory')

    cmd.extend(args)

    ui.status((bytes(cmd)), b"\n")

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

    ui.status(_(b"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(b'annotate -udl')

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

    ui.status((bytes(cmd)), b"\n")

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

    cmdoptions = [

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

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

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

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

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

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

    ]

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

    cmd = Command(b"bookmark")

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

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

        return

    elif opts.get(b'delete'):

        cmd = Command(b"strip")

        for branch in args:

            cmd[b'-B'] = branch

        else:

            cmd[b'-B'] = None

    elif opts.get(b'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 = b'`hg log -T"{activebookmark}" -r .`'

        else:

            raise error.Abort(_(b'missing newbranch argument'))

        new = args[0]

        cmd[b'-m'] = old

        cmd.append(new)

    else:

        if len(args) > 1:

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

            cmd.append(args[0])

        elif len(args) == 1:

            cmd.append(args[0])

    ui.status((bytes(cmd)), b"\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 scmutil.isrevsymbol(repo, string):

        # 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 == b'':

        repopath = string

    else:

        repopath = cwd + b'/' + string

    exists = repo.wvfs.exists(repopath)

    if exists:

        return True

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

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

    return didexist

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

    cmdoptions = [

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

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

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

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

    ]

    paths = []

    if b'--' in args:

        sepindex = args.index(b'--')

        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(b'update')

    if opts.get(b'force'):

        if paths or rev:

            cmd[b'-C'] = None

    if opts.get(b'patch'):

        cmd = Command(b'revert')

        cmd[b'-i'] = None

    if opts.get(b'branch'):

        if len(args) == 0:

            cmd = Command(b'bookmark')

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

        else:

            cmd.append(args[0])

            bookcmd = Command(b'bookmark')

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

            cmd = cmd & bookcmd

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

    elif len(paths) > 0:

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

        cmd = Command(b'revert')

        if opts.get(b'patch'):

            cmd[b'-i'] = None

        if rev:

            cmd[b'-r'] = rev

        cmd.extend(paths)

    elif rev:

        if opts.get(b'patch'):

            cmd[b'-r'] = rev

        else:

            cmd.append(rev)

    elif opts.get(b'force'):

        cmd = Command(b'revert')

        cmd[b'--all'] = None