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

from i18n import gettext as _

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

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

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

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

demandload(globals(), "archival changegroup")

class UnknownCommand(Exception):

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

class AmbiguousCommand(Exception):

    """Exception raised if command shortcut matches more than one command."""

def bail_if_changed(repo):

    modified, added, removed, deleted, unknown = repo.changes()

    if modified or added or removed or deleted:

        raise util.Abort(_("outstanding uncommitted changes"))

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, pats=[], opts={}, head=''):

    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']]

        cwd = ''

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

                           opts.get('exclude'), head)

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

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

    exact = dict(zip(files, files))

    def walk():

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

                                 badmatch=badmatch):

            yield src, fn, util.pathto(repo.getcwd(), fn), fn in exact

    return files, matchfn, walk()

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

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

    for r in results:

        yield r

def walkchangerevs(ui, repo, 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, matchfn) tuple.  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'''

    def increasing_windows(start, end, windowsize=8, sizelimit=512):

        if start < end:

            while start < end:

                yield start, min(windowsize, end-start)

                start += windowsize

                if windowsize < sizelimit:

                    windowsize *= 2

        else:

            while start > end:

                yield start, min(windowsize, start-end-1)

                start -= windowsize

                if windowsize < sizelimit:

                    windowsize *= 2

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

    if repo.changelog.count() == 0:

        return [], False, matchfn

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

    wanted = {}

    slowpath = anypats

    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, window in increasing_windows(filelog.count()-1, -1):

                revs = []

                for j in xrange(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, window in increasing_windows(repo.changelog.count()-1, -1):

                for j in xrange(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, window in increasing_windows(0, len(revs)):

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

            nrevs = [rev for rev in revs[i:i+window]

                     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, matchfn

revrangesep = ':'

        try:

    seen = {}

    for spec in revs:

        if spec.find(revrangesep) >= 0:

            start, end = spec.split(revrangesep, 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:

            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, pathname=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)))

        if pathname is not None:

            expander['s'] = lambda: os.path.basename(pathname)

            expander['d'] = lambda: os.path.dirname(pathname) or '.'

            expander['p'] = lambda: pathname

        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', pathname=None):

    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,

                              pathname),

                mode)

def write_bundle(cg, filename=None, compress=True):

    """Write a bundle file and return its filename.

    Existing files will not be overwritten.

    If no filename is specified, a temporary file is created.

    bz2 compression can be turned off.

    The bundle file will be deleted in case of errors.

    """

    class nocompress(object):

        def compress(self, x):

            return x

        def flush(self):

            return ""

    fh = None

    cleanup = None

    try:

        if filename:

            if os.path.exists(filename):

                raise util.Abort(_("file '%s' already exists"), filename)

            fh = open(filename, "wb")

        else:

            fd, filename = tempfile.mkstemp(prefix="hg-bundle-", suffix=".hg")

            fh = os.fdopen(fd, "wb")

        cleanup = filename

        if compress:

            fh.write("HG10")

            z = bz2.BZ2Compressor(9)

        else:

            fh.write("HG10UN")

            z = nocompress()

        # parse the changegroup data, otherwise we will block

        # in case of sshrepo because we don't know the end of the stream

        # an empty chunkiter is the end of the changegroup

        empty = False

        while not empty:

            empty = True

            for chunk in changegroup.chunkiter(cg):

                empty = False

                fh.write(z.compress(changegroup.genchunk(chunk)))

            fh.write(z.compress(changegroup.closechunk()))

        fh.write(z.flush())

        cleanup = None

        return filename

    finally:

        if fh is not None:

            fh.close()

        if cleanup is not None:

            os.unlink(cleanup)