# localrepo.py - read/write repository class for mercurial

#

# Copyright 2005, 2006 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 node import *

from i18n import gettext as _

from demandload import *

import repo

demandload(globals(), "appendfile changegroup")

demandload(globals(), "changelog dirstate filelog manifest context")

demandload(globals(), "re lock transaction tempfile stat mdiff errno ui")

demandload(globals(), "os revlog time util")

class localrepository(repo.repository):

    capabilities = ('lookup', 'changegroupsubset')

    def __del__(self):

        self.transhandle = None

    def __init__(self, parentui, path=None, create=0):

        repo.repository.__init__(self)

        if not path:

            p = os.getcwd()

            while not os.path.isdir(os.path.join(p, ".hg")):

                oldp = p

                p = os.path.dirname(p)

                if p == oldp:

                    raise repo.RepoError(_("There is no Mercurial repository"

                                           " here (.hg not found)"))

            path = p

        self.path = os.path.join(path, ".hg")

        if not os.path.isdir(self.path):

            if create:

                if not os.path.exists(path):

                    os.mkdir(path)

                os.mkdir(self.path)

                os.mkdir(self.join("data"))

            else:

                raise repo.RepoError(_("repository %s not found") % path)

        elif create:

            raise repo.RepoError(_("repository %s already exists") % path)

        self.origroot = path

        self.ui = ui.ui(parentui=parentui)

        self.opener = util.opener(self.path)

        self.sopener = util.opener(self.path)

        self.wopener = util.opener(self.root)

        try:

            self.ui.readconfig(self.join("hgrc"), self.root)

        except IOError:

            pass

        v = self.ui.configrevlog()

        self.revlogversion = int(v.get('format', revlog.REVLOG_DEFAULT_FORMAT))

        self.revlogv1 = self.revlogversion != revlog.REVLOGV0

        fl = v.get('flags', None)

        flags = 0

        if fl != None:

            for x in fl.split():

                flags |= revlog.flagstr(x)

        elif self.revlogv1:

            flags = revlog.REVLOG_DEFAULT_FLAGS

        v = self.revlogversion | flags

        self.manifest = manifest.manifest(self.sopener, v)

        self.changelog = changelog.changelog(self.sopener, v)

        # the changelog might not have the inline index flag

        # on.  If the format of the changelog is the same as found in

        # .hgrc, apply any flags found in the .hgrc as well.

        # Otherwise, just version from the changelog

        v = self.changelog.version

        if v == self.revlogversion:

            v |= flags

        self.revlogversion = v

        self.tagscache = None

        self.branchcache = None

        self.nodetagscache = None

        self.encodepats = None

        self.decodepats = None

        self.transhandle = None

        self.dirstate = dirstate.dirstate(self.opener, self.ui, self.root)

    def url(self):

        return 'file:' + self.root

    def hook(self, name, throw=False, **args):

        def callhook(hname, funcname):

            '''call python hook. hook is callable object, looked up as

            name in python module. if callable returns "true", hook

            fails, else passes. if hook raises exception, treated as

            hook failure. exception propagates if throw is "true".

            reason for "true" meaning "hook failed" is so that

            unmodified commands (e.g. mercurial.commands.update) can

            be run as hooks without wrappers to convert return values.'''

            self.ui.note(_("calling hook %s: %s\n") % (hname, funcname))

            d = funcname.rfind('.')

            if d == -1:

                raise util.Abort(_('%s hook is invalid ("%s" not in a module)')

                                 % (hname, funcname))

            modname = funcname[:d]

            try:

                obj = __import__(modname)

            except ImportError:

                try:

                    # extensions are loaded with hgext_ prefix

                    obj = __import__("hgext_%s" % modname)

                except ImportError:

                    raise util.Abort(_('%s hook is invalid '

                                       '(import of "%s" failed)') %

                                     (hname, modname))

            try:

                for p in funcname.split('.')[1:]:

                    obj = getattr(obj, p)

            except AttributeError, err:

                raise util.Abort(_('%s hook is invalid '

                                   '("%s" is not defined)') %

                                 (hname, funcname))

            if not callable(obj):

                raise util.Abort(_('%s hook is invalid '

                                   '("%s" is not callable)') %

                                 (hname, funcname))

            try:

                r = obj(ui=self.ui, repo=self, hooktype=name, **args)

            except (KeyboardInterrupt, util.SignalInterrupt):

                raise

            except Exception, exc:

                if isinstance(exc, util.Abort):

                    self.ui.warn(_('error: %s hook failed: %s\n') %

                                 (hname, exc.args[0]))

                else:

                    self.ui.warn(_('error: %s hook raised an exception: '

                                   '%s\n') % (hname, exc))

                if throw:

                    raise

                self.ui.print_exc()

                return True

            if r:

                if throw:

                    raise util.Abort(_('%s hook failed') % hname)

                self.ui.warn(_('warning: %s hook failed\n') % hname)

            return r

        def runhook(name, cmd):

            self.ui.note(_("running hook %s: %s\n") % (name, cmd))

            env = dict([('HG_' + k.upper(), v) for k, v in args.iteritems()])

            r = util.system(cmd, environ=env, cwd=self.root)

            if r:

                desc, r = util.explain_exit(r)

                if throw:

                    raise util.Abort(_('%s hook %s') % (name, desc))

                self.ui.warn(_('warning: %s hook %s\n') % (name, desc))

            return r

        r = False

        hooks = [(hname, cmd) for hname, cmd in self.ui.configitems("hooks")

                 if hname.split(".", 1)[0] == name and cmd]

        hooks.sort()

        for hname, cmd in hooks:

            if cmd.startswith('python:'):

                r = callhook(hname, cmd[7:].strip()) or r

            else:

                r = runhook(hname, cmd) or r

        return r

    tag_disallowed = ':\r\n'

    def tag(self, name, node, message, local, user, date):

        '''tag a revision with a symbolic name.

        if local is True, the tag is stored in a per-repository file.

        otherwise, it is stored in the .hgtags file, and a new

        changeset is committed with the change.

        keyword arguments:

        local: whether to store tag in non-version-controlled file

        (default False)

        message: commit message to use if committing

        user: name of user to use if committing

        date: date tuple to use if committing'''

        for c in self.tag_disallowed:

            if c in name:

                raise util.Abort(_('%r cannot be used in a tag name') % c)

        self.hook('pretag', throw=True, node=hex(node), tag=name, local=local)

        if local:

            self.opener('localtags', 'a').write('%s %s\n' % (hex(node), name))

            self.hook('tag', node=hex(node), tag=name, local=local)

            return

        for x in self.status()[:5]:

            if '.hgtags' in x:

                raise util.Abort(_('working copy of .hgtags is changed '

                                   '(please commit .hgtags manually)'))

        self.wfile('.hgtags', 'ab').write('%s %s\n' % (hex(node), name))

        if self.dirstate.state('.hgtags') == '?':

            self.add(['.hgtags'])

        self.commit(['.hgtags'], message, user, date)

        self.hook('tag', node=hex(node), tag=name, local=local)

    def tags(self):

        '''return a mapping of tag to node'''

        if not self.tagscache:

            self.tagscache = {}

            def parsetag(line, context):

                if not line:

                    return

                s = l.split(" ", 1)

                if len(s) != 2:

                    self.ui.warn(_("%s: cannot parse entry\n") % context)

                    return

                node, key = s

                key = key.strip()

                try:

                    bin_n = bin(node)

                except TypeError:

                    self.ui.warn(_("%s: node '%s' is not well formed\n") %

                                 (context, node))

                    return

                if bin_n not in self.changelog.nodemap:

                    self.ui.warn(_("%s: tag '%s' refers to unknown node\n") %

                                 (context, key))

                    return

                self.tagscache[key] = bin_n

            # read the tags file from each head, ending with the tip,

            # and add each tag found to the map, with "newer" ones

            # taking precedence

            f = None

            for rev, node, fnode in self._hgtagsnodes():

                f = (f and f.filectx(fnode) or

                     self.filectx('.hgtags', fileid=fnode))

                count = 0

                for l in f.data().splitlines():

                    count += 1

                    parsetag(l, _("%s, line %d") % (str(f), count))

            try:

                f = self.opener("localtags")

                count = 0

                for l in f:

                    count += 1

                    parsetag(l, _("localtags, line %d") % count)

            except IOError:

                pass

            self.tagscache['tip'] = self.changelog.tip()

        return self.tagscache

    def _hgtagsnodes(self):

        heads = self.heads()

        heads.reverse()

        last = {}

        ret = []

        for node in heads:

            c = self.changectx(node)

            rev = c.rev()

            try:

                fnode = c.filenode('.hgtags')

            except repo.LookupError:

                continue

            ret.append((rev, node, fnode))

            if fnode in last:

                ret[last[fnode]] = None

            last[fnode] = len(ret) - 1

        return [item for item in ret if item]

    def tagslist(self):

        '''return a list of tags ordered by revision'''

        l = []

        for t, n in self.tags().items():

            try:

                r = self.changelog.rev(n)

            except:

                r = -2 # sort to the beginning of the list if unknown

            l.append((r, t, n))

        l.sort()

        return [(t, n) for r, t, n in l]

    def nodetags(self, node):

        '''return the tags associated with a node'''

        if not self.nodetagscache:

            self.nodetagscache = {}

            for t, n in self.tags().items():

                self.nodetagscache.setdefault(n, []).append(t)

        return self.nodetagscache.get(node, [])

    def branchtags(self):

        if self.branchcache != None:

            return self.branchcache

        self.branchcache = {} # avoid recursion in changectx

        partial, last, lrev = self._readbranchcache()

        tiprev = self.changelog.count() - 1

        if lrev != tiprev:

            self._updatebranchcache(partial, lrev+1, tiprev+1)

            self._writebranchcache(partial, self.changelog.tip(), tiprev)

        self.branchcache = partial

        return self.branchcache

    def _readbranchcache(self):

        partial = {}

        try:

            f = self.opener("branches.cache")

            last, lrev = f.readline().rstrip().split(" ", 1)

            last, lrev = bin(last), int(lrev)

            if (lrev < self.changelog.count() and

                self.changelog.node(lrev) == last): # sanity check

                for l in f:

                    node, label = l.rstrip().split(" ", 1)

                    partial[label] = bin(node)

            else: # invalidate the cache

                last, lrev = nullid, nullrev

            f.close()

        except IOError:

            last, lrev = nullid, nullrev

        return partial, last, lrev

    def _writebranchcache(self, branches, tip, tiprev):

        try:

            f = self.opener("branches.cache", "w")

            f.write("%s %s\n" % (hex(tip), tiprev))

            for label, node in branches.iteritems():

                f.write("%s %s\n" % (hex(node), label))

        except IOError:

            pass

    def _updatebranchcache(self, partial, start, end):

        for r in xrange(start, end):

            c = self.changectx(r)