# commands.py - command processing for mercurial

#

# Copyright 2005-2007 Matt Mackall <mpm@selenic.com>

#

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

# of the GNU General Public License, incorporated herein by reference.

import demandimport; demandimport.enable()

from node import *

from i18n import _

import bisect, os, re, sys, urllib, shlex, stat

import ui, hg, util, revlog, bundlerepo, extensions

import difflib, patch, time, help, mdiff, tempfile

import errno, version, socket

import archival, changegroup, cmdutil, hgweb.server, sshserver

# Commands start here, listed alphabetically

def add(ui, repo, *pats, **opts):

    """add the specified files on the next commit

    Schedule files to be version controlled and added to the repository.

    The files will be added to the repository at the next commit. To

    undo an add before that, see hg revert.

    If no names are given, add all files in the repository.

    """

    names = []

    for src, abs, rel, exact in cmdutil.walk(repo, pats, opts):

        if exact:

            if ui.verbose:

                ui.status(_('adding %s\n') % rel)

            names.append(abs)

        elif repo.dirstate.state(abs) == '?':

            ui.status(_('adding %s\n') % rel)

            names.append(abs)

    if not opts.get('dry_run'):

        repo.add(names)

def addremove(ui, repo, *pats, **opts):

    """add all new files, delete all missing files

    Add all new files and remove all missing files from the repository.

    New files are ignored if they match any of the patterns in .hgignore. As

    with add, these changes take effect at the next commit.

    Use the -s option to detect renamed files.  With a parameter > 0,

    this compares every removed file with every added file and records

    those similar enough as renames.  This option takes a percentage

    between 0 (disabled) and 100 (files must be identical) as its

    parameter.  Detecting renamed files this way can be expensive.

    """

    sim = float(opts.get('similarity') or 0)

    if sim < 0 or sim > 100:

        raise util.Abort(_('similarity must be between 0 and 100'))

    return cmdutil.addremove(repo, pats, opts, similarity=sim/100.)

def annotate(ui, repo, *pats, **opts):

    """show changeset information per file line

    List changes in files, showing the revision id responsible for each line

    This command is useful to discover who did a change or when a change took

    place.

    Without the -a option, annotate will avoid processing files it

    detects as binary. With -a, annotate will generate an annotation

    anyway, probably with undesirable results.

    """

    getdate = util.cachefunc(lambda x: util.datestr(x.date()))

    if not pats:

        raise util.Abort(_('at least one file name or pattern required'))

    opmap = [['user', lambda x: ui.shortuser(x.user())],

             ['number', lambda x: str(x.rev())],

             ['changeset', lambda x: short(x.node())],

             ['date', getdate], ['follow', lambda x: x.path()]]

    if (not opts['user'] and not opts['changeset'] and not opts['date']

        and not opts['follow']):

        opts['number'] = 1

    ctx = repo.changectx(opts['rev'])

    for src, abs, rel, exact in cmdutil.walk(repo, pats, opts,

                                             node=ctx.node()):

        fctx = ctx.filectx(abs)

        if not opts['text'] and util.binary(fctx.data()):

            ui.write(_("%s: binary file\n") % ((pats and rel) or abs))

            continue

        lines = fctx.annotate(follow=opts.get('follow'))

        pieces = []

        for o, f in opmap:

            if opts[o]:

                l = [f(n) for n, dummy in lines]

                if l:

                    m = max(map(len, l))

                    pieces.append(["%*s" % (m, x) for x in l])

        if pieces:

            for p, l in zip(zip(*pieces), lines):

                ui.write("%s: %s" % (" ".join(p), l[1]))

def archive(ui, repo, dest, **opts):

    '''create unversioned archive of a repository revision

    By default, the revision used is the parent of the working

    directory; use "-r" to specify a different revision.

    To specify the type of archive to create, use "-t".  Valid

    types are:

    "files" (default): a directory full of files

    "tar": tar archive, uncompressed

    "tbz2": tar archive, compressed using bzip2

    "tgz": tar archive, compressed using gzip

    "uzip": zip archive, uncompressed

    "zip": zip archive, compressed using deflate

    The exact name of the destination archive or directory is given

    using a format string; see "hg help export" for details.

    Each member added to an archive file has a directory prefix

    prepended.  Use "-p" to specify a format string for the prefix.

    The default is the basename of the archive, with suffixes removed.

    '''

    node = repo.changectx(opts['rev']).node()

    dest = cmdutil.make_filename(repo, dest, node)

    if os.path.realpath(dest) == repo.root:

        raise util.Abort(_('repository root cannot be destination'))

    dummy, matchfn, dummy = cmdutil.matchpats(repo, [], opts)

    kind = opts.get('type') or 'files'

    prefix = opts['prefix']

    if dest == '-':

        if kind == 'files':

            raise util.Abort(_('cannot archive plain files to stdout'))

        dest = sys.stdout

        if not prefix: prefix = os.path.basename(repo.root) + '-%h'

    prefix = cmdutil.make_filename(repo, prefix, node)

    archival.archive(repo, dest, node, kind, not opts['no_decode'],

                     matchfn, prefix)

def backout(ui, repo, node=None, rev=None, **opts):

    '''reverse effect of earlier changeset

    Commit the backed out changes as a new changeset.  The new

    changeset is a child of the backed out changeset.

    If you back out a changeset other than the tip, a new head is

    created.  This head is the parent of the working directory.  If

    you back out an old changeset, your working directory will appear

    old after the backout.  You should merge the backout changeset

    with another head.

    The --merge option remembers the parent of the working directory

    before starting the backout, then merges the new head with that

    changeset afterwards.  This saves you from doing the merge by

    hand.  The result of this merge is not committed, as for a normal

    merge.'''

    if rev and node:

        raise util.Abort(_("please specify just one revision"))

    if not rev:

        rev = node

    if not rev:

        raise util.Abort(_("please specify a revision to backout"))

    cmdutil.bail_if_changed(repo)

    op1, op2 = repo.dirstate.parents()

    if op2 != nullid:

        raise util.Abort(_('outstanding uncommitted merge'))

    node = repo.lookup(rev)

    p1, p2 = repo.changelog.parents(node)

    if p1 == nullid:

        raise util.Abort(_('cannot back out a change with no parents'))

    if p2 != nullid:

        if not opts['parent']:

            raise util.Abort(_('cannot back out a merge changeset without '

                               '--parent'))

        p = repo.lookup(opts['parent'])

        if p not in (p1, p2):

            raise util.Abort(_('%s is not a parent of %s') %

                             (short(p), short(node)))

        parent = p

    else:

        if opts['parent']:

            raise util.Abort(_('cannot use --parent on non-merge changeset'))

        parent = p1

    hg.clean(repo, node, show_stats=False)

    revert_opts = opts.copy()

    revert_opts['date'] = None

    revert_opts['all'] = True

    revert_opts['rev'] = hex(parent)

    revert(ui, repo, **revert_opts)

    commit_opts = opts.copy()

    commit_opts['addremove'] = False

    if not commit_opts['message'] and not commit_opts['logfile']:

        commit_opts['message'] = _("Backed out changeset %s") % (short(node))

        commit_opts['force_editor'] = True

    commit(ui, repo, **commit_opts)

    def nice(node):

        return '%d:%s' % (repo.changelog.rev(node), short(node))

    ui.status(_('changeset %s backs out changeset %s\n') %

              (nice(repo.changelog.tip()), nice(node)))

    if op1 != node:

        if opts['merge']:

            ui.status(_('merging with changeset %s\n') % nice(op1))

            hg.merge(repo, hex(op1))

        else:

            ui.status(_('the backout changeset is a new head - '

                        'do not forget to merge\n'))

            ui.status(_('(use "backout --merge" '

                        'if you want to auto-merge)\n'))

def branch(ui, repo, label=None, **opts):

    """set or show the current branch name

    With no argument, show the current branch name. With one argument,

    set the working directory branch name (the branch does not exist in

    the repository until the next commit).

    Unless --force is specified, branch will not let you set a

    branch name that shadows an existing branch.

    """

    if label:

        if not opts.get('force') and label in repo.branchtags():

            if label not in [p.branch() for p in repo.workingctx().parents()]:

                raise util.Abort(_('a branch of the same name already exists'

                                   ' (use --force to override)'))

        repo.dirstate.setbranch(util.fromlocal(label))

        ui.status(_('marked working directory as branch %s\n') % label)

    else:

        ui.write("%s\n" % util.tolocal(repo.dirstate.branch()))

def branches(ui, repo, active=False):

    """list repository named branches

    List the repository's named branches, indicating which ones are

    inactive.  If active is specified, only show active branches.

    A branch is considered active if it contains unmerged heads.

    """

    b = repo.branchtags()

    heads = dict.fromkeys(repo.heads(), 1)

    l = [((n in heads), repo.changelog.rev(n), n, t) for t, n in b.items()]

    l.sort()

    l.reverse()

    for ishead, r, n, t in l:

        if active and not ishead:

            # If we're only displaying active branches, abort the loop on

            # encountering the first inactive head

            break

        else:

            hexfunc = ui.debugflag and hex or short

            if ui.quiet:

                ui.write("%s\n" % t)

            else:

                spaces = " " * (30 - util.locallen(t))

                # The code only gets here if inactive branches are being

                # displayed or the branch is active.

                isinactive = ((not ishead) and " (inactive)") or ''

                ui.write("%s%s %s:%s%s\n" % (t, spaces, r, hexfunc(n), isinactive))

def bundle(ui, repo, fname, dest=None, **opts):

    """create a changegroup file

    Generate a compressed changegroup file collecting changesets not

    found in the other repository.

    If no destination repository is specified the destination is assumed

    to have all the nodes specified by one or more --base parameters.

    The bundle file can then be transferred using conventional means and

    applied to another repository with the unbundle or pull command.

    This is useful when direct push and pull are not available or when

    exporting an entire repository is undesirable.

    Applying bundles preserves all changeset contents including

    permissions, copy/rename information, and revision history.

    """

    revs = opts.get('rev') or None

    if revs:

        revs = [repo.lookup(rev) for rev in revs]

    base = opts.get('base')

    if base:

        if dest:

            raise util.Abort(_("--base is incompatible with specifiying "

                               "a destination"))

        base = [repo.lookup(rev) for rev in base]

        # create the right base

        # XXX: nodesbetween / changegroup* should be "fixed" instead

        o = []

        has = {nullid: None}

        for n in base:

            has.update(repo.changelog.reachable(n))

        if revs:

            visit = list(revs)

        else:

            visit = repo.changelog.heads()

        seen = {}

        while visit:

            n = visit.pop(0)

            parents = [p for p in repo.changelog.parents(n) if p not in has]

            if len(parents) == 0:

                o.insert(0, n)

            else:

                for p in parents:

                    if p not in seen:

                        seen[p] = 1

                        visit.append(p)

    else:

        cmdutil.setremoteconfig(ui, opts)

        dest, revs = cmdutil.parseurl(

            ui.expandpath(dest or 'default-push', dest or 'default'), revs)

        other = hg.repository(ui, dest)

        o = repo.findoutgoing(other, force=opts['force'])

    if revs:

        cg = repo.changegroupsubset(o, revs, 'bundle')

    else:

        cg = repo.changegroup(o, 'bundle')

    changegroup.writebundle(cg, fname, "HG10BZ")

def cat(ui, repo, file1, *pats, **opts):

    """output the current or given revision of files

    Print the specified files as they were at the given revision.

    If no revision is given, the parent of the working directory is used,

    or tip if no revision is checked out.

    Output may be to a file, in which case the name of the file is

    given using a format string.  The formatting rules are the same as

    for the export command, with the following additions:

    %s   basename of file being printed

    %d   dirname of file being printed, or '.' if in repo root

    %p   root-relative path name of file being printed

    """

    ctx = repo.changectx(opts['rev'])

    err = 1

    for src, abs, rel, exact in cmdutil.walk(repo, (file1,) + pats, opts,

                                             ctx.node()):

        fp = cmdutil.make_file(repo, opts['output'], ctx.node(), pathname=abs)

        fp.write(ctx.filectx(abs).data())

        err = 0

    return err

def clone(ui, source, dest=None, **opts):

    """make a copy of an existing repository

    Create a copy of an existing repository in a new directory.

    If no destination directory name is specified, it defaults to the

    basename of the source.

    The location of the source is added to the new repository's

    .hg/hgrc file, as the default to be used for future pulls.

    For efficiency, hardlinks are used for cloning whenever the source

    and destination are on the same filesystem (note this applies only

    to the repository data, not to the checked out files).  Some

    filesystems, such as AFS, implement hardlinking incorrectly, but

    do not report errors.  In these cases, use the --pull option to

    avoid hardlinking.

    You can safely clone repositories and checked out files using full

    hardlinks with

      $ cp -al REPO REPOCLONE

    which is the fastest way to clone. However, the operation is not

    atomic (making sure REPO is not modified during the operation is

    up to you) and you have to make sure your editor breaks hardlinks

    (Emacs and most Linux Kernel tools do so).

    If you use the -r option to clone up to a specific revision, no

    subsequent revisions will be present in the cloned repository.

    This option implies --pull, even on local repositories.

    See pull for valid source format details.

    It is possible to specify an ssh:// URL as the destination, but no

    .hg/hgrc and working directory will be created on the remote side.

    Look at the help text for the pull command for important details

    about ssh:// URLs.

    """

    cmdutil.setremoteconfig(ui, opts)

    hg.clone(ui, source, dest,

             pull=opts['pull'],

             stream=opts['uncompressed'],

             rev=opts['rev'],

             update=not opts['noupdate'])

def commit(ui, repo, *pats, **opts):

    """commit the specified files or all outstanding changes

    Commit changes to the given files into the repository.

    If a list of files is omitted, all changes reported by "hg status"

    will be committed.

    If no commit message is specified, the editor configured in your hgrc

    or in the EDITOR environment variable is started to enter a message.

    """

    message = cmdutil.logmessage(opts)

    if opts['addremove']:

        cmdutil.addremove(repo, pats, opts)

    fns, match, anypats = cmdutil.matchpats(repo, pats, opts)

    if pats:

        status = repo.status(files=fns, match=match)

        modified, added, removed, deleted, unknown = status[:5]

        files = modified + added + removed

        slist = None

        for f in fns:

            if f == '.':

                continue

            if f not in files:

                rf = repo.wjoin(f)

                try:

                    mode = os.lstat(rf)[stat.ST_MODE]

                except OSError:

                    raise util.Abort(_("file %s not found!") % rf)

                if stat.S_ISDIR(mode):

                    name = f + '/'

                    if slist is None:

                        slist = list(files)

                        slist.sort()

                    i = bisect.bisect(slist, name)

                    if i >= len(slist) or not slist[i].startswith(name):

                        raise util.Abort(_("no match under directory %s!")

                                         % rf)

                elif not (stat.S_ISREG(mode) or stat.S_ISLNK(mode)):

                    raise util.Abort(_("can't commit %s: "

                                       "unsupported file type!") % rf)

                elif repo.dirstate.state(f) == '?':

                    raise util.Abort(_("file %s not tracked!") % rf)

    else:

        files = []

    try:

        repo.commit(files, message, opts['user'], opts['date'], match,

                    force_editor=opts.get('force_editor'))

    except ValueError, inst:

        raise util.Abort(str(inst))

def docopy(ui, repo, pats, opts, wlock):

    # called with the repo lock held

    #

    # hgsep => pathname that uses "/" to separate directories

    # ossep => pathname that uses os.sep to separate directories

    cwd = repo.getcwd()

    errors = 0

    copied = []

    targets = {}

    # abs: hgsep

    # rel: ossep

    # return: hgsep

    def okaytocopy(abs, rel, exact):

        reasons = {'?': _('is not managed'),

                   'r': _('has been marked for remove')}

        state = repo.dirstate.state(abs)

        reason = reasons.get(state)

        if reason:

            if state == 'a':

                origsrc = repo.dirstate.copied(abs)

                if origsrc is not None:

                    return origsrc

            return abs

    # origsrc: hgsep