comparison mercurial/filemerge.py @ 16127:14dc2bbba6d2

filemerge: remove some redundancy in decorators/docstrings

16126:0c4bec9596d8

internals = {}

def internaltool(name, trymerge, onfailure=None):
    '''return a decorator for populating internal merge tool table'''
    def decorator(func):
        internals[name] = func
        func.trymerge = trymerge
        func.onfailure = onfailure
        return func
    return decorator

        if style:
            newdata = data.replace(style, tostyle)
            if newdata != data:
                util.writefile(file, newdata)

@internaltool('internal:prompt', False)
def _iprompt(repo, mynode, orig, fcd, fco, fca, toolconf):
    """``internal:prompt``
    Asks the user which of the local or the other version to keep as
    the merged version."""
    ui = repo.ui
    fd = fcd.path()

    if ui.promptchoice(_(" no tool found to merge %s\n"

                       (_("&Local"), _("&Other")), 0):
        return _iother(repo, mynode, orig, fcd, fco, fca, toolconf)
    else:
        return _ilocal(repo, mynode, orig, fcd, fco, fca, toolconf)

@internaltool('internal:local', False)
def _ilocal(repo, mynode, orig, fcd, fco, fca, toolconf):
    """``internal:local``
    Uses the local version of files as the merged version."""
    return 0

@internaltool('internal:other', False)
def _iother(repo, mynode, orig, fcd, fco, fca, toolconf):
    """``internal:other``
    Uses the other version of files as the merged version."""
    repo.wwrite(fcd.path(), fco.data(), fco.flags())
    return 0

@internaltool('internal:fail', False)
def _ifail(repo, mynode, orig, fcd, fco, fca, toolconf):
    """``internal:fail``
    Rather than attempting to merge files that were modified on both
    branches, it marks them as unresolved. The resolve command must be
    used to resolve these conflicts."""
    return 1

            return 0
        if premerge != 'keep':
            util.copyfile(back, a) # restore from backup and try again
    return 1 # continue merging

@internaltool('internal:merge', True,
              _("merging %s incomplete! "
                "(edit conflicts, then use 'hg resolve --mark')\n"))
def _imerge(repo, mynode, orig, fcd, fco, fca, toolconf, files):
    """``internal:merge``
    Uses the internal non-interactive simple merge algorithm for merging
    files. It will fail if there are any conflicts and leave markers in
    the partially merged file."""
    r = _premerge(repo, toolconf, files)
    if r:

        r = simplemerge.simplemerge(ui, a, b, c, label=['local', 'other'])
        return True, r
    return False, 0

@internaltool('internal:dump', True)
def _idump(repo, mynode, orig, fcd, fco, fca, toolconf, files):
    """``internal:dump``
    Creates three versions of the files to merge, containing the
    contents of local, other and base. These files can then be used to
    perform a merge manually. If the file to be merged is named
    ``a.txt``, these files will accordingly be named ``a.txt.local``,
    ``a.txt.other`` and ``a.txt.base`` and they will be placed in the

16127:14dc2bbba6d2

internals = {}

def internaltool(name, trymerge, onfailure=None):
    '''return a decorator for populating internal merge tool table'''
    def decorator(func):
        fullname = 'internal:' + name
        func.__doc__ = "``%s``\n" % fullname + func.__doc__.strip()
        internals[fullname] = func
        func.trymerge = trymerge
        func.onfailure = onfailure
        return func
    return decorator

        if style:
            newdata = data.replace(style, tostyle)
            if newdata != data:
                util.writefile(file, newdata)

@internaltool('prompt', False)
def _iprompt(repo, mynode, orig, fcd, fco, fca, toolconf):
    """Asks the user which of the local or the other version to keep as
    the merged version."""
    ui = repo.ui
    fd = fcd.path()

    if ui.promptchoice(_(" no tool found to merge %s\n"

                       (_("&Local"), _("&Other")), 0):
        return _iother(repo, mynode, orig, fcd, fco, fca, toolconf)
    else:
        return _ilocal(repo, mynode, orig, fcd, fco, fca, toolconf)

@internaltool('local', False)
def _ilocal(repo, mynode, orig, fcd, fco, fca, toolconf):
    """Uses the local version of files as the merged version."""
    return 0

@internaltool('other', False)
def _iother(repo, mynode, orig, fcd, fco, fca, toolconf):
    """Uses the other version of files as the merged version."""
    repo.wwrite(fcd.path(), fco.data(), fco.flags())
    return 0

@internaltool('fail', False)
def _ifail(repo, mynode, orig, fcd, fco, fca, toolconf):
    """
    Rather than attempting to merge files that were modified on both
    branches, it marks them as unresolved. The resolve command must be
    used to resolve these conflicts."""
    return 1

            return 0
        if premerge != 'keep':
            util.copyfile(back, a) # restore from backup and try again
    return 1 # continue merging

@internaltool('merge', True,
              _("merging %s incomplete! "
                "(edit conflicts, then use 'hg resolve --mark')\n"))
def _imerge(repo, mynode, orig, fcd, fco, fca, toolconf, files):
    """
    Uses the internal non-interactive simple merge algorithm for merging
    files. It will fail if there are any conflicts and leave markers in
    the partially merged file."""
    r = _premerge(repo, toolconf, files)
    if r:

        r = simplemerge.simplemerge(ui, a, b, c, label=['local', 'other'])
        return True, r
    return False, 0

@internaltool('dump', True)
def _idump(repo, mynode, orig, fcd, fco, fca, toolconf, files):
    """
    Creates three versions of the files to merge, containing the
    contents of local, other and base. These files can then be used to
    perform a merge manually. If the file to be merged is named
    ``a.txt``, these files will accordingly be named ``a.txt.local``,
    ``a.txt.other`` and ``a.txt.base`` and they will be placed in the