# commands.py - command processing for mercurial

#

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

from demandload import demandload

from node import *

demandload(globals(), "os re sys signal shutil imp urllib pdb")

demandload(globals(), "fancyopts ui hg util lock revlog")

demandload(globals(), "fnmatch hgweb mdiff random signal time traceback")

demandload(globals(), "errno socket version struct atexit sets bz2")

class UnknownCommand(Exception):

    """Exception raised if command is not in the command table."""

def filterfiles(filters, files):

    l = [x for x in files if x in filters]

    for t in filters:

        if t and t[-1] != "/":

            t += "/"

        l += [x for x in files if x.startswith(t)]

    return l

def relpath(repo, args):

    cwd = repo.getcwd()

    if cwd:

        return [util.normpath(os.path.join(cwd, x)) for x in args]

    return args

def matchpats(repo, cwd, pats=[], opts={}, head=''):

    return util.matcher(repo.root, cwd, pats or ['.'], opts.get('include'),

                        opts.get('exclude'), head)

def makewalk(repo, pats, opts, head=''):

    cwd = repo.getcwd()

    files, matchfn, anypats = matchpats(repo, cwd, pats, opts, head)

    exact = dict(zip(files, files))

    def walk():

        for src, fn in repo.walk(files=files, match=matchfn):

            yield src, fn, util.pathto(cwd, fn), fn in exact

    return files, matchfn, walk()

def walk(repo, pats, opts, head=''):

    files, matchfn, results = makewalk(repo, pats, opts, head)

    for r in results:

        yield r

def walkchangerevs(ui, repo, cwd, pats, opts):

    '''Iterate over files and the revs they changed in.

    Callers most commonly need to iterate backwards over the history

    it is interested in.  Doing so has awful (quadratic-looking)

    performance, so we use iterators in a "windowed" way.

    We walk a window of revisions in the desired order.  Within the

    window, we first walk forwards to gather data, then in the desired

    order (usually backwards) to display it.

    This function returns an (iterator, getchange) pair.  The

    getchange function returns the changelog entry for a numeric

    revision.  The iterator yields 3-tuples.  They will be of one of

    the following forms:

    "window", incrementing, lastrev: stepping through a window,

    positive if walking forwards through revs, last rev in the

    sequence iterated over - use to reset state for the current window

    "add", rev, fns: out-of-order traversal of the given file names

    fns, which changed during revision rev - use to gather data for

    possible display

    "iter", rev, None: in-order traversal of the revs earlier iterated

    over with "add" - use to display data'''

    cwd = repo.getcwd()

    if not pats and cwd:

        opts['include'] = [os.path.join(cwd, i) for i in opts['include']]

        opts['exclude'] = [os.path.join(cwd, x) for x in opts['exclude']]

    files, matchfn, anypats = matchpats(repo, (pats and cwd) or '',

                                        pats, opts)

    revs = map(int, revrange(ui, repo, opts['rev'] or ['tip:0']))

    wanted = {}

    slowpath = anypats

    window = 300

    fncache = {}

    chcache = {}

    def getchange(rev):

        ch = chcache.get(rev)

        if ch is None:

            chcache[rev] = ch = repo.changelog.read(repo.lookup(str(rev)))

        return ch

    if not slowpath and not files:

        # No files, no patterns.  Display all revs.

        wanted = dict(zip(revs, revs))

    if not slowpath:

        # Only files, no patterns.  Check the history of each file.

        def filerevgen(filelog):

            for i in xrange(filelog.count() - 1, -1, -window):

                revs = []

                for j in xrange(max(0, i - window), i + 1):

                    revs.append(filelog.linkrev(filelog.node(j)))

                revs.reverse()

                for rev in revs:

                    yield rev

        minrev, maxrev = min(revs), max(revs)

        for file in files:

            filelog = repo.file(file)

            # A zero count may be a directory or deleted file, so

            # try to find matching entries on the slow path.

            if filelog.count() == 0:

                slowpath = True

                break

            for rev in filerevgen(filelog):

                if rev <= maxrev:

                    if rev < minrev:

                        break

                    fncache.setdefault(rev, [])

                    fncache[rev].append(file)

                    wanted[rev] = 1

    if slowpath:

        # The slow path checks files modified in every changeset.

        def changerevgen():

            for i in xrange(repo.changelog.count() - 1, -1, -window):

                for j in xrange(max(0, i - window), i + 1):

                    yield j, getchange(j)[3]

        for rev, changefiles in changerevgen():

            matches = filter(matchfn, changefiles)

            if matches:

                fncache[rev] = matches

                wanted[rev] = 1

    def iterate():

        for i in xrange(0, len(revs), window):

            yield 'window', revs[0] < revs[-1], revs[-1]

            nrevs = [rev for rev in revs[i:min(i+window, len(revs))]

                     if rev in wanted]

            srevs = list(nrevs)

            srevs.sort()

            for rev in srevs:

                fns = fncache.get(rev) or filter(matchfn, getchange(rev)[3])

                yield 'add', rev, fns

            for rev in nrevs:

                yield 'iter', rev, None

    return iterate(), getchange

revrangesep = ':'

def revrange(ui, repo, revs, revlog=None):

    """Yield revision as strings from a list of revision specifications."""

    if revlog is None:

        revlog = repo.changelog

    revcount = revlog.count()

    def fix(val, defval):

        if not val:

            return defval

        try:

            num = int(val)

            if str(num) != val:

                raise ValueError

            if num < 0:

                num += revcount

            if not (0 <= num < revcount):

                raise ValueError

        except ValueError:

            try:

                num = repo.changelog.rev(repo.lookup(val))

            except KeyError:

                try:

                    num = revlog.rev(revlog.lookup(val))

                except KeyError:

                    raise util.Abort('invalid revision identifier %s', val)

        return num

    seen = {}

    for spec in revs:

        if spec.find(revrangesep) >= 0:

            start, end = spec.split(revrangesep, 1)

            start = fix(start, 0)

            end = fix(end, revcount - 1)

            step = start > end and -1 or 1

            for rev in xrange(start, end+step, step):

                if rev in seen: continue

                seen[rev] = 1

                yield str(rev)

        else:

            rev = fix(spec, None)

            if rev in seen: continue

            seen[rev] = 1

            yield str(rev)

def make_filename(repo, r, pat, node=None,

                  total=None, seqno=None, revwidth=None):

    node_expander = {

        'H': lambda: hex(node),

        'R': lambda: str(r.rev(node)),

        'h': lambda: short(node),

        }

    expander = {

        '%': lambda: '%',

        'b': lambda: os.path.basename(repo.root),

        }

    try:

        if node:

            expander.update(node_expander)

        if node and revwidth is not None:

            expander['r'] = lambda: str(r.rev(node)).zfill(revwidth)

        if total is not None:

            expander['N'] = lambda: str(total)

        if seqno is not None:

            expander['n'] = lambda: str(seqno)

        if total is not None and seqno is not None:

            expander['n'] = lambda:str(seqno).zfill(len(str(total)))

        newname = []

        patlen = len(pat)

        i = 0

        while i < patlen:

            c = pat[i]

            if c == '%':

                i += 1

                c = pat[i]

                c = expander[c]()

            newname.append(c)

            i += 1

        return ''.join(newname)

    except KeyError, inst:

        raise util.Abort("invalid format spec '%%%s' in output file name",

                    inst.args[0])

def make_file(repo, r, pat, node=None,

              total=None, seqno=None, revwidth=None, mode='wb'):

    if not pat or pat == '-':

        return 'w' in mode and sys.stdout or sys.stdin

    if hasattr(pat, 'write') and 'w' in mode:

        return pat

    if hasattr(pat, 'read') and 'r' in mode:

        return pat

    return open(make_filename(repo, r, pat, node, total, seqno, revwidth),

                mode)

def dodiff(fp, ui, repo, node1, node2, files=None, match=util.always,

           changes=None, text=False):

    def date(c):

        return time.asctime(time.gmtime(float(c[2].split(' ')[0])))

    if not changes:

        (c, a, d, u) = repo.changes(node1, node2, files, match=match)

    else:

        (c, a, d, u) = changes

    if files:

        c, a, d = map(lambda x: filterfiles(files, x), (c, a, d))

    if not c and not a and not d:

        return

    if node2:

        change = repo.changelog.read(node2)

        mmap2 = repo.manifest.read(change[0])

        date2 = date(change)

        def read(f):

            return repo.file(f).read(mmap2[f])

    else:

        date2 = time.asctime()

        if not node1:

            node1 = repo.dirstate.parents()[0]

        def read(f):

            return repo.wfile(f).read()

    if ui.quiet:

        r = None

    else:

        hexfunc = ui.verbose and hex or short

        r = [hexfunc(node) for node in [node1, node2] if node]

    change = repo.changelog.read(node1)

    mmap = repo.manifest.read(change[0])

    date1 = date(change)

    for f in c:

        to = None

        if f in mmap:

            to = repo.file(f).read(mmap[f])

        tn = read(f)

        fp.write(mdiff.unidiff(to, date1, tn, date2, f, r, text=text))

    for f in a:

        to = None

        tn = read(f)

        fp.write(mdiff.unidiff(to, date1, tn, date2, f, r, text=text))

    for f in d:

        to = repo.file(f).read(mmap[f])

        tn = None

        fp.write(mdiff.unidiff(to, date1, tn, date2, f, r, text=text))

def trimuser(ui, name, rev, revcache):

    """trim the name of the user who committed a change"""

    user = revcache.get(rev)

    if user is None:

        user = revcache[rev] = ui.shortuser(name)

    return user

def show_changeset(ui, repo, rev=0, changenode=None, brinfo=None):

    """show a single changeset or file revision"""

    log = repo.changelog

    if changenode is None:

        changenode = log.node(rev)

    elif not rev:

        rev = log.rev(changenode)

    if ui.quiet:

        ui.write("%d:%s\n" % (rev, short(changenode)))

        return

    changes = log.read(changenode)

    t, tz = changes[2].split(' ')

    # a conversion tool was sticking non-integer offsets into repos

    try:

        tz = int(tz)

    except ValueError:

        tz = 0

    date = time.asctime(time.localtime(float(t))) + " %+05d" % (int(tz)/-36)

    parents = [(log.rev(p), ui.verbose and hex(p) or short(p))

               for p in log.parents(changenode)

               if ui.debugflag or p != nullid]

    if not ui.debugflag and len(parents) == 1 and parents[0][0] == rev-1:

        parents = []

    if ui.verbose:

        ui.write("changeset:   %d:%s\n" % (rev, hex(changenode)))

    else:

        ui.write("changeset:   %d:%s\n" % (rev, short(changenode)))

    for tag in repo.nodetags(changenode):

        ui.status("tag:         %s\n" % tag)

    for parent in parents:

        ui.write("parent:      %d:%s\n" % parent)

    if brinfo and changenode in brinfo:

        br = brinfo[changenode]

        ui.write("branch:      %s\n" % " ".join(br))

    ui.debug("manifest:    %d:%s\n" % (repo.manifest.rev(changes[0]),

                                      hex(changes[0])))

    ui.status("user:        %s\n" % changes[1])

    ui.status("date:        %s\n" % date)

    if ui.debugflag:

        files = repo.changes(log.parents(changenode)[0], changenode)

        for key, value in zip(["files:", "files+:", "files-:"], files):

            if value:

                ui.note("%-12s %s\n" % (key, " ".join(value)))

    else:

        ui.note("files:       %s\n" % " ".join(changes[3]))

    description = changes[4].strip()

    if description:

        if ui.verbose:

            ui.status("description:\n")

            ui.status(description)

            ui.status("\n\n")

        else:

            ui.status("summary:     %s\n" % description.splitlines()[0])

    ui.status("\n")

def show_version(ui):

    """output version and copyright information"""

    ui.write("Mercurial Distributed SCM (version %s)\n"

             % version.get_version())

    ui.status(

        "\nCopyright (C) 2005 Matt Mackall <mpm@selenic.com>\n"

        "This is free software; see the source for copying conditions. "

        "There is NO\nwarranty; "

        "not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"

    )

def help_(ui, cmd=None, with_version=False):

    """show help for a given command or all commands"""

    option_lists = []

    if cmd and cmd != 'shortlist':

        if with_version:

            show_version(ui)

            ui.write('\n')

        key, i = find(cmd)

        # synopsis

        ui.write("%s\n\n" % i[2])

        # description

        doc = i[0].__doc__

        if ui.quiet:

            doc = doc.splitlines(0)[0]

        ui.write("%s\n" % doc.rstrip())

        if not ui.quiet:

            # aliases

            aliases = ', '.join(key.split('|')[1:])

            if aliases:

                ui.write("\naliases: %s\n" % aliases)

            # options

            if i[1]:

                option_lists.append(("options", i[1]))

    else:

        # program name

        if ui.verbose or with_version:

            show_version(ui)

        else:

            ui.status("Mercurial Distributed SCM\n")

        ui.status('\n')

        # list of commands

        if cmd == "shortlist":

            ui.status('basic commands (use "hg help" '

                      'for the full list or option "-v" for details):\n\n')

        elif ui.verbose:

            ui.status('list of commands:\n\n')

        else:

            ui.status('list of commands (use "hg help -v" '

                      'to show aliases and global options):\n\n')

        h = {}

        cmds = {}

        for c, e in table.items():

            f = c.split("|")[0]

            if cmd == "shortlist" and not f.startswith("^"):

                continue

            f = f.lstrip("^")

            if not ui.debugflag and f.startswith("debug"):

                continue

            d = ""

            if e[0].__doc__:

                d = e[0].__doc__.splitlines(0)[0].rstrip()

            h[f] = d

            cmds[f]=c.lstrip("^")

        fns = h.keys()

        fns.sort()

        m = max(map(len, fns))

        for f in fns:

            if ui.verbose:

                commands = cmds[f].replace("|",", ")

                ui.write(" %s:\n      %s\n"%(commands,h[f]))

            else:

                ui.write(' %-*s   %s\n' % (m, f, h[f]))

    # global options

    if ui.verbose:

        option_lists.append(("global options", globalopts))

    # list all option lists

    opt_output = []

    for title, options in option_lists:

        opt_output.append(("\n%s:\n" % title, None))

        for shortopt, longopt, default, desc in options:

            opt_output.append(("%2s%s" % (shortopt and "-%s" % shortopt,

                                          longopt and " --%s" % longopt),

                               "%s%s" % (desc,

                                         default and " (default: %s)" % default

                                         or "")))

    if opt_output:

        opts_len = max([len(line[0]) for line in opt_output if line[1]])

        for first, second in opt_output:

            if second:

                ui.write(" %-*s  %s\n" % (opts_len, first, second))

            else:

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

# Commands start here, listed alphabetically

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

    '''add the specified files on the next commit'''

    names = []

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

        if exact: