# 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 version 2, incorporated herein by reference.

from node import bin, hex, nullid, nullrev, short

from i18n import _

import repo, changegroup

import changelog, dirstate, filelog, manifest, context

import lock, transaction, store, encoding

import util, extensions, hook, error

import match as match_

import merge as merge_

from lock import release

import weakref, stat, errno, os, time, inspect

propertycache = util.propertycache

class localrepository(repo.repository):

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

    supported = set('revlogv1 store fncache'.split())

    def __init__(self, baseui, 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 baseui.configbool('format', 'usestore', True):

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

                    requirements.append("store")

                    if baseui.configbool('format', 'usefncache', True):

                        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 error.RepoError(_("repository %s not found") % path)

        elif create:

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

        else:

            # find requirements

            requirements = set()

            try:

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

            except IOError, inst:

                if inst.errno != errno.ENOENT:

                    raise

            for r in requirements - self.supported:

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

        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.baseui = baseui

        self.ui = baseui.copy()

        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

    @propertycache

    def changelog(self):

        c = changelog.changelog(self.sopener)

        if 'HG_PENDING' in os.environ:

            p = os.environ['HG_PENDING']

            if p.startswith(self.root):

                c.readpending('00changelog.i.a')

        self.sopener.defversion = c.version

        return c

    @propertycache

    def manifest(self):

        return manifest.manifest(self.sopener)

    @propertycache

    def dirstate(self):

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

    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, extra={}):

        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:

                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

        try:

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

        except IOError:

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

        else:

            prevtags = fp.read()

        # committed tags are stored in UTF-8

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

        if '.hgtags' not in self.dirstate:

            self.add(['.hgtags'])

        tagnode = self.commit(['.hgtags'], message, user, date, 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.tags() # instantiate the cache

        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 = encoding.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.iteritems():

                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 = encoding.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.iteritems():

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

        last = {}

        ret = []

        for node in reversed(self.heads()):

            c = self[node]

            rev = c.rev()

            try:

                fnode = c.filenode('.hgtags')

            except error.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().iteritems():

            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 sorted(l)]

    def nodetags(self, node):

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

        if not self.nodetagscache:

            self.nodetagscache = {}

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

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

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

    def _branchtags(self, partial, lrev):

        # TODO: rename this function?

        tiprev = len(self) - 1

        if lrev != tiprev:

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

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