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

#

# Copyright 2005-2007 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 bin, hex, nullid, nullrev, short

from i18n import _

import repo, changegroup

import changelog, dirstate, filelog, manifest, context, weakref

import lock, transaction, stat, errno, ui, store

import os, revlog, time, util, extensions, hook, inspect

import match as match_

import merge as merge_

class localrepository(repo.repository):

    capabilities = util.set(('lookup', 'changegroupsubset'))

    supported = ('revlogv1', 'store', 'fncache')

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

        repo.repository.__init__(self)

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

                    requirements.append("fncache")

                    # 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

            requirements = []

            try:

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

                for r in requirements:

                    if r not in self.supported:

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

            except IOError, inst:

                if inst.errno != errno.ENOENT:

                    raise

        self.store = store.store(requirements, self.path, util.opener)

        self.spath = self.store.path

        self.sopener = self.store.opener

        self.sjoin = self.store.join

        self.opener.createmode = self.store.createmode

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

        try:

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

            extensions.loadall(self.ui)

        except IOError:

            pass

        self.tagscache = None

        self._tagstypecache = None

        self.branchcache = None

        self._ubranchcache = None  # UTF-8 version of branchcache

        self._branchcachetip = None

        self.nodetagscache = None

        self.filterpats = {}

        self._datafilters = {}

        self._transref = self._lockref = self._wlockref = None

    def __getattr__(self, name):

        if name == 'changelog':

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

            self.sopener.defversion = self.changelog.version

            return self.changelog

        if name == 'manifest':

            self.changelog

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

            return self.manifest

        if name == 'dirstate':

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

            return self.dirstate

        else:

            raise AttributeError(name)

    def __getitem__(self, changeid):

        if changeid == None:

            return context.workingctx(self)

        return context.changectx(self, changeid)

    def __nonzero__(self):

        return True

    def __len__(self):

        return len(self.changelog)

    def __iter__(self):

        for i in xrange(len(self)):

            yield i

    def url(self):

        return 'file:' + self.root

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

        return hook.hook(self.ui, self, name, throw, **args)

    tag_disallowed = ':\r\n'

    def _tag(self, names, node, message, local, user, date, parent=None,

             extra={}):

        use_dirstate = parent is None

        if isinstance(names, str):

            allchars = names

            names = (names,)

        else:

            allchars = ''.join(names)

        for c in self.tag_disallowed:

            if c in allchars:

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

        for name in names:

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

                      local=local)

        def writetags(fp, names, munge, prevtags):

            fp.seek(0, 2)

            if prevtags and prevtags[-1] != '\n':

                fp.write('\n')

            for name in names:

                m = munge and munge(name) or name

                if self._tagstypecache and name in self._tagstypecache:

                    old = self.tagscache.get(name, nullid)

                    fp.write('%s %s\n' % (hex(old), m))

                fp.write('%s %s\n' % (hex(node), m))

            fp.close()

        prevtags = ''

        if local:

            try:

                fp = self.opener('localtags', 'r+')

            except IOError, err:

                fp = self.opener('localtags', 'a')

            else:

                prevtags = fp.read()

            # local tags are stored in the current charset

            writetags(fp, names, None, prevtags)

            for name in names:

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

            return

        if use_dirstate:

            try:

                fp = self.wfile('.hgtags', 'rb+')

            except IOError, err:

                fp = self.wfile('.hgtags', 'ab')

            else:

                prevtags = fp.read()

        else:

            try:

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

            except revlog.LookupError:

                pass

            fp = self.wfile('.hgtags', 'wb')

            if prevtags:

                fp.write(prevtags)

        # committed tags are stored in UTF-8

        writetags(fp, names, util.fromlocal, prevtags)

        if use_dirstate and '.hgtags' not in self.dirstate:

            self.add(['.hgtags'])

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

                              extra=extra)

        for name in names:

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

        return tagnode

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

        '''tag a revision with one or more symbolic names.

        names is a list of strings or, when adding a single tag, names may be a

        string.

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

        otherwise, they are stored in the .hgtags file, and a new

        changeset is committed with the change.

        keyword arguments:

        local: whether to store tags 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(names, node, message, local, user, date)

    def tags(self):

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

        if self.tagscache:

            return self.tagscache

        globaltags = {}

        tagtypes = {}

        def readtags(lines, fn, tagtype):

            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

                    tagtypes[k] = tagtype

                    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.extend([n for n in bh if n not in ah])

                globaltags[k] = an, ah

                tagtypes[k] = tagtype

        # 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, "global")

        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", "local")

        except IOError:

            pass

        self.tagscache = {}

        self._tagstypecache = {}

        for k,nh in globaltags.items():

            n = nh[0]

            if n != nullid:

                self.tagscache[k] = n

            self._tagstypecache[k] = tagtypes[k]

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

        return self.tagscache

    def tagtype(self, tagname):

        '''

        return the type of the given tag. result can be:

        'local'  : a local tag

        'global' : a global tag

        None     : tag does not exist

        '''

        self.tags()

        return self._tagstypecache.get(tagname)

    def _hgtagsnodes(self):

        heads = self.heads()

        heads.reverse()

        last = {}

        ret = []

        for node in heads:

            c = self[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))

        return [(t, n) for r, t, n in util.sort(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, lrev):

        tiprev = len(self) - 1

        if lrev != tiprev:

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

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

        return partial

    def branchtags(self):

        tip = self.changelog.tip()

        if self.branchcache is not None and self._branchcachetip == tip:

            return self.branchcache

        oldtip = self._branchcachetip

        self._branchcachetip = tip

        if self.branchcache is None:

            self.branchcache = {} # avoid recursion in changectx

        else:

            self.branchcache.clear() # keep using the same dict

        if oldtip is None or oldtip not in self.changelog.nodemap:

            partial, last, lrev = self._readbranchcache()

        else:

            lrev = self.changelog.rev(oldtip)

            partial = self._ubranchcache

        self._branchtags(partial, lrev)

        # 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

        self._ubranchcache = partial

        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 lrev >= len(self) or self[lrev].node() != last:

                # invalidate the cache

                raise ValueError('invalidating branch cache (tip differs)')

            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[r]

            b = c.branch()

            partial[b] = c.node()

    def lookup(self, key):

        if key == '.':

            return self.dirstate.parents()[0]

        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

        try:

            if len(key) == 20:

                key = hex(key)

        except:

            pass

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

    def local(self):

        return True

    def join(self, f):

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

    def wjoin(self, f):

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

    def rjoin(self, f):

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

    def file(self, f):

        if f[0] == '/':

            f = f[1:]

        return filelog.filelog(self.sopener, f)

    def changectx(self, changeid):

        return self[changeid]

    def parents(self, changeid=None):

        '''get list of changectxs for parents of changeid'''