# 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, subrepo

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', 'branchmap'))

    supported = set('revlogv1 store fncache shared'.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)

        self.baseui = baseui

        self.ui = baseui.copy()

        try:

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

            extensions.loadall(self.ui)

        except IOError:

            pass

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

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

                    requirements.append("store")

                    if self.ui.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.sharedpath = self.path

        try:

            s = os.path.realpath(self.opener("sharedpath").read())

            if not os.path.exists(s):

                raise error.RepoError(

                    _('.hg/sharedpath points to nonexistent directory %s') % s)

            self.sharedpath = s

        except IOError, inst:

            if inst.errno != errno.ENOENT:

                raise

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

        self.spath = self.store.path

        self.sopener = self.store.opener

        self.sjoin = self.store.join

        self.opener.createmode = self.store.createmode

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

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

        m = match_.exact(self.root, '', ['.hgtags'])

        tagnode = self.commit(message, user, date, extra=extra, match=m)

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

    def _findtags(self):

        '''Do the hard work of finding tags.  Return a pair of dicts

        (tags, tagtypes) where tags maps tag name to node, and tagtypes

        maps tag name to a string like \'global\' or \'local\'.

        Subclasses or extensions are free to add their own tags, but

        should be aware that the returned dicts will be retained for the

        duration of the localrepo object.'''

        # XXX what tagtype should subclasses/extensions use?  Currently

        # mq and bookmarks add tags, but do not set the tagtype at all.

        # Should each extension invent its own tag type?  Should there

        # be one tagtype for all such "virtual" tags?  Or is the status

        # quo fine?

        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:

                    # silently ignore as pull -r might cause this

                    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

        seen = set()

        f = None

        ctxs = []

        for node in self.heads():

            try:

                fnode = self[node].filenode('.hgtags')

            except error.LookupError:

                continue

            if fnode not in seen:

                seen.add(fnode)

                if not f:

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

                else:

                    f = f.filectx(fnode)

                ctxs.append(f)

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

        for f in reversed(ctxs):

            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

        tags = {}

        for k, nh in globaltags.iteritems():

            n = nh[0]

            if n != nullid:

                tags[k] = n

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

        return (tags, tagtypes)

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

    def tagslist(self):

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

        l = []