# 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

demandload(globals(), "os re sys signal shutil")

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

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

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

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, cwd, pats or ['.'], opts.get('include'),

                        opts.get('exclude'), head)

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

    cwd = repo.getcwd()

    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

revrangesep = ':'

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

    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

    for spec in revs:

        if spec.find(revrangesep) >= 0:

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

            start = fix(start, 0)

            end = fix(end, revcount - 1)

            if end > start:

                end += 1

                step = 1

            else:

                end -= 1

                step = -1

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

                yield str(rev)

        else:

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

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

    node_expander = {

        'H': lambda: hg.hex(node),

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

        'h': lambda: hg.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 == '-':

        if 'w' in mode: return sys.stdout

        else: return 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 hg.hex or hg.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))

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

    if ui.quiet:

        return

    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 hg.hex(p) or hg.short(p))

               if ui.debugflag or p != hg.nullid]

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

        parents = []

    if ui.verbose:

    else:

    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]),

                                      hg.hex(changes[0])))

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

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

    if ui.debugflag:

        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):

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

    if cmd and cmd != 'shortlist':

        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())

        # aliases

        if not ui.quiet:

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

            if aliases:

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

        # options

        if not ui.quiet and i[1]:

            ui.write("\noptions:\n\n")

            for s, l, d, c in i[1]:

                opt = ' '

                if s:

                    opt = opt + '-' + s + ' '

                if l:

                    opt = opt + '--' + l + ' '

                if d:

                    opt = opt + '(' + str(d) + ')'

                ui.write(opt, "\n")

                if c:

                    ui.write('   %s\n' % c)

    else:

        # program name

        if ui.verbose:

            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:

        ui.write("\nglobal options:\n\n")

        for s, l, d, c in globalopts:

            opt = ' '

            if s:

                opt = opt + '-' + s + ' '

            if l:

                opt = opt + '--' + l + ' '

            if d:

                opt = opt + '(' + str(d) + ')'

            ui.write(opt, "\n")

            if c:

                ui.write('    %s\n' % c)

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

            names.append(abs)

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

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

            names.append(abs)

    repo.add(names)

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

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

    add, remove = [], []

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

        if src == 'f' and repo.dirstate.state(abs) == '?':

            add.append(abs)

            if not exact: ui.status('adding ', rel, '\n')

        if repo.dirstate.state(abs) != 'r' and not os.path.exists(rel):

            remove.append(abs)

            if not exact: ui.status('removing ', rel, '\n')

    repo.add(add)

    repo.remove(remove)

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

    """show changeset information per file line"""

    def getnode(rev):

        return hg.short(repo.changelog.node(rev))

    def getname(rev):

        try:

            return bcache[rev]

        except KeyError:

            cl = repo.changelog.read(repo.changelog.node(rev))

            name = cl[1]

            f = name.find('@')

            if f >= 0:

                name = name[:f]

            f = name.find('<')

            if f >= 0:

                name = name[f+1:]

            bcache[rev] = name

            return name

    if not pats:

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

    bcache = {}

    opmap = [['user', getname], ['number', str], ['changeset', getnode]]

    if not opts['user'] and not opts['changeset']:

        opts['number'] = 1

    if opts['rev']:

        node = repo.changelog.lookup(opts['rev'])

    else:

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

    change = repo.changelog.read(node)

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

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

        if abs not in mmap:

            ui.warn("warning: %s is not in the repository!\n" % rel)

            continue

        f = repo.file(abs)

        if not opts['text'] and util.binary(f.read(mmap[abs])):

            ui.write("%s: binary file\n" % rel)

            continue

        lines = f.annotate(mmap[abs])

        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 cat(ui, repo, file1, rev=None, **opts):

    """output the latest or given revision of a file"""

    r = repo.file(relpath(repo, [file1])[0])

    if rev:

        try:

            # assume all revision numbers are for changesets

            n = repo.lookup(rev)

            change = repo.changelog.read(n)

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

            n = m[relpath(repo, [file1])[0]]

        except hg.RepoError, KeyError:

            n = r.lookup(rev)

    else:

        n = r.tip()

    fp = make_file(repo, r, opts['output'], node=n)

    fp.write(r.read(n))

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

    """make a copy of an existing repository"""

    if dest is None:

        dest = os.path.basename(os.path.normpath(source))

    if os.path.exists(dest):

        ui.warn("abort: destination '%s' already exists\n" % dest)

        return 1

    dest = os.path.realpath(dest)

    class Dircleanup:

        def __init__(self, dir_):

            self.rmtree = shutil.rmtree

            self.dir_ = dir_

            os.mkdir(dir_)

        def close(self):

            self.dir_ = None