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

import repo, changegroup

import changelog, dirstate, filelog, manifest, context

import re, lock, transaction, tempfile, stat, mdiff, errno, ui

import os, revlog, time, util

class localrepository(repo.repository):

    capabilities = ('lookup', 'changegroupsubset')

    supported = ('revlogv1', 'store')

    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.root = os.path.realpath(path)

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

        self.origroot = path

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

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

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

            if create:

                if not os.path.exists(path):

                    os.mkdir(path)

                os.mkdir(self.path)

                requirements = ["revlogv1"]

                if parentui.configbool('format', 'usestore', True):

                    os.mkdir(os.path.join(self.path, "store"))

                    requirements.append("store")

                    # create an invalid changelog

                    self.opener("00changelog.i", "a").write(

                        '\0\0\0\2' # represents revlogv2

                        ' dummy changelog to prevent using the old repo layout'

                    )

                reqfile = self.opener("requires", "w")

                for r in requirements:

                    reqfile.write("%s\n" % r)

                reqfile.close()

            else:

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

        elif create:

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

        else:

            # find requirements

            try:

                requirements = self.opener("requires").read().splitlines()

            except IOError, inst:

                if inst.errno != errno.ENOENT:

                    raise

                requirements = []

        # check them

        for r in requirements:

            if r not in self.supported:

                raise repo.RepoError(_("requirement '%s' not supported") % r)

        # setup store

        if "store" in requirements:

            self.encodefn = util.encodefilename

            self.decodefn = util.decodefilename

            self.spath = os.path.join(self.path, "store")

        else:

            self.encodefn = lambda x: x

            self.decodefn = lambda x: x

            self.spath = self.path

        self.sopener = util.encodedopener(util.opener(self.spath), self.encodefn)

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

        try:

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

        except IOError:

            pass

        self.changelog = changelog.changelog(self.sopener)

        self.sopener.defversion = self.changelog.version

        self.manifest = manifest.manifest(self.sopener)

        fallback = self.ui.config('ui', 'fallbackencoding')

        if fallback:

            util._fallbackencoding = fallback

        self.tagscache = None

        self.branchcache = None

        self.nodetagscache = None

        self.filterpats = {}

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

            obj = funcname

            if not callable(obj):

                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 callable(cmd):

                r = callhook(hname, cmd) or r

            elif 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, parent=None):

        use_dirstate = parent is None

        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:

            # local tags are stored in the current charset

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

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

            return

        # committed tags are stored in UTF-8

        line = '%s %s\n' % (hex(node), util.fromlocal(name))

        if use_dirstate:

            self.wfile('.hgtags', 'ab').write(line)

        else:

            ntags = self.filectx('.hgtags', parent).data()

            self.wfile('.hgtags', 'ab').write(ntags + line)

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

            self.add(['.hgtags'])

        tagnode = self.commit(['.hgtags'], message, user, date, p1=parent)

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

        return tagnode

    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 x in self.status()[:5]:

            if '.hgtags' in x:

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

                                   '(please commit .hgtags manually)'))

        self._tag(name, node, message, local, user, date)

    def tags(self):

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

        if self.tagscache:

            return self.tagscache

        globaltags = {}

        def readtags(lines, fn):

            filetags = {}

            count = 0

            def warn(msg):

                self.ui.warn(_("%s, line %s: %s\n") % (fn, count, msg))

            for l in lines:

                count += 1

                if not l:

                    continue

                s = l.split(" ", 1)

                if len(s) != 2:

                    warn(_("cannot parse entry"))

                    continue

                node, key = s

                key = util.tolocal(key.strip()) # stored in UTF-8

                try:

                    bin_n = bin(node)

                except TypeError:

                    warn(_("node '%s' is not well formed") % node)

                    continue

                if bin_n not in self.changelog.nodemap:

                    warn(_("tag '%s' refers to unknown node") % key)

                    continue

                h = []

                if key in filetags:

                    n, h = filetags[key]

                    h.append(n)

                filetags[key] = (bin_n, h)

            for k,nh in filetags.items():

                if k not in globaltags:

                    globaltags[k] = nh

                    continue

                # we prefer the global tag if:

                #  it supercedes us OR

                #  mutual supercedes and it has a higher rank

                # otherwise we win because we're tip-most

                an, ah = nh

                bn, bh = globaltags[k]

                if bn != an and an in bh and \

                   (bn not in ah or len(bh) > len(ah)):

                    an = bn

                ah.append([n for n in bh if n not in ah])

                globaltags[k] = an, ah

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

        f = None

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

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

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

            readtags(f.data().splitlines(), f)

        try:

            data = util.fromlocal(self.opener("localtags").read())

            # localtags are stored in the local character set

            # while the internal tag table is stored in UTF-8

            readtags(data.splitlines(), "localtags")

        except IOError:

            pass

        self.tagscache = {}

        for k,nh in globaltags.items():

            n = nh[0]

            if n != nullid:

                self.tagscache[k] = n

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

        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)

        return partial

    def branchtags(self):

        if self.branchcache is not None:

            return self.branchcache

        self.branchcache = {} # avoid recursion in changectx

        partial = self._branchtags()

        # the branch cache is stored on disk as UTF-8, but in the local

        # charset internally

        for k, v in partial.items():

            self.branchcache[util.tolocal(k)] = v

        return self.branchcache

    def _readbranchcache(self):

        partial = {}

        try:

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

            lines = f.read().split('\n')

            f.close()

        except (IOError, OSError):

            return {}, nullid, nullrev

        try:

            last, lrev = lines.pop(0).split(" ", 1)

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

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

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

                # invalidate the cache

                raise ValueError('Invalid branch cache: unknown tip')

            for l in lines:

                if not l: continue

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

                partial[label.strip()] = bin(node)

        except (KeyboardInterrupt, util.SignalInterrupt):

            raise

        except Exception, inst:

            if self.ui.debugflag:

                self.ui.warn(str(inst), '\n')

            partial, last, lrev = {}, nullid, nullrev

        return partial, last, lrev

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

        try:

            f = self.opener("branch.cache", "w", atomictemp=True)

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

            for label, node in branches.iteritems():

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

            f.rename()

        except (IOError, OSError):

            pass

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

        for r in xrange(start, end):

            c = self.changectx(r)

            b = c.branch()

            partial[b] = c.node()

    def lookup(self, key):

        if key == '.':

            key = self.dirstate.parents()[0]

            if key == nullid:

                raise repo.RepoError(_("no revision checked out"))

        elif key == 'null':

            return nullid

        n = self.changelog._match(key)

        if n:

            return n

        if key in self.tags():

            return self.tags()[key]

        if key in self.branchtags():

            return self.branchtags()[key]

        n = self.changelog._partialmatch(key)

        if n:

            return n

        raise repo.RepoError(_("unknown revision '%s'") % key)

    def dev(self):

        return os.lstat(self.path).st_dev

    def local(self):

        return True

    def join(self, f):

        return os.path.join(self.path, f)

    def sjoin(self, f):

        f = self.encodefn(f)

        return os.path.join(self.spath, f)

    def wjoin(self, f):

        return os.path.join(self.root, f)

    def file(self, f):

        if f[0] == '/':

            f = f[1:]

        return filelog.filelog(self.sopener, f)

    def changectx(self, changeid=None):

        return context.changectx(self, changeid)

    def workingctx(self):

        return context.workingctx(self)

    def parents(self, changeid=None):