# 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 or any later version.

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

from i18n import _

import repo, changegroup, subrepo, discovery, pushkey

import changelog, dirstate, filelog, manifest, context, bookmarks

import lock, transaction, store, encoding

import scmutil, util, extensions, hook, error, revset

import match as matchmod

import merge as mergemod

import tags as tagsmod

from lock import release

import weakref, errno, os, time, inspect

propertycache = util.propertycache

filecache = scmutil.filecache

class localrepository(repo.repository):

    capabilities = set(('lookup', 'changegroupsubset', 'branchmap', 'pushkey',

                        'known', 'getbundle'))

    supportedformats = set(('revlogv1', 'generaldelta'))

    supported = supportedformats | set(('store', 'fncache', 'shared',

                                        'dotencode'))

    def __init__(self, baseui, path=None, create=False):

        repo.repository.__init__(self)

        self.root = os.path.realpath(util.expandpath(path))

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

        self.origroot = path

        self.auditor = scmutil.pathauditor(self.root, self._checknested)

        self.opener = scmutil.opener(self.path)

        self.wopener = scmutil.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):

                    util.makedirs(path)

                util.makedir(self.path, notindexed=True)

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

                        if self.ui.configbool('format', 'dotencode', True):

                            requirements.append('dotencode')

                    # create an invalid changelog

                    self.opener.append(

                        "00changelog.i",

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

                        ' dummy changelog to prevent using the old repo layout'

                    )

                if self.ui.configbool('format', 'generaldelta', False):

                    requirements.append("generaldelta")

                requirements = set(requirements)

            else:

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

        elif create:

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

        else:

            try:

                requirements = scmutil.readrequires(self.opener, self.supported)

            except IOError, inst:

                if inst.errno != errno.ENOENT:

                    raise

                requirements = set()

        self.sharedpath = self.path

        try:

            s = os.path.realpath(self.opener.read("sharedpath").rstrip('\n'))

            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, scmutil.opener)

        self.spath = self.store.path

        self.sopener = self.store.opener

        self.sjoin = self.store.join

        self.opener.createmode = self.store.createmode

        self._applyrequirements(requirements)

        if create:

            self._writerequirements()

        self._branchcache = None

        self._branchcachetip = None

        self.filterpats = {}

        self._datafilters = {}

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

        # A cache for various files under .hg/ that tracks file changes,

        # (used by the filecache decorator)

        #

        # Maps a property name to its util.filecacheentry

        self._filecache = {}

    def _applyrequirements(self, requirements):

        self.requirements = requirements

        openerreqs = set(('revlogv1', 'generaldelta'))

        self.sopener.options = dict((r, 1) for r in requirements

                                           if r in openerreqs)

    def _writerequirements(self):

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

        for r in self.requirements:

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

        reqfile.close()

    def _checknested(self, path):

        """Determine if path is a legal nested repository."""

        if not path.startswith(self.root):

            return False

        subpath = path[len(self.root) + 1:]

        # XXX: Checking against the current working copy is wrong in

        # the sense that it can reject things like

        #

        #   $ hg cat -r 10 sub/x.txt

        #

        # if sub/ is no longer a subrepository in the working copy

        # parent revision.

        #

        # However, it can of course also allow things that would have

        # been rejected before, such as the above cat command if sub/

        # is a subrepository now, but was a normal directory before.

        # The old path auditor would have rejected by mistake since it

        # panics when it sees sub/.hg/.

        #

        # All in all, checking against the working copy seems sensible

        # since we want to prevent access to nested repositories on

        # the filesystem *now*.

        ctx = self[None]

        parts = util.splitpath(subpath)

        while parts:

            prefix = os.sep.join(parts)

            if prefix in ctx.substate:

                if prefix == subpath:

                    return True

                else:

                    sub = ctx.sub(prefix)

                    return sub.checknested(subpath[len(prefix) + 1:])

            else:

                parts.pop()

        return False

    @filecache('bookmarks')

    def _bookmarks(self):

        return bookmarks.read(self)

    @filecache('bookmarks.current')

    def _bookmarkcurrent(self):

        return bookmarks.readcurrent(self)

    @filecache('00changelog.i', True)

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

        return c

    @filecache('00manifest.i', True)

    def manifest(self):

        return manifest.manifest(self.sopener)

    @filecache('dirstate')

    def dirstate(self):

        warned = [0]

        def validate(node):

            try:

                self.changelog.rev(node)

                return node

            except error.LookupError:

                if not warned[0]:

                    warned[0] = True

                    self.ui.warn(_("warning: ignoring unknown"

                                   " working parent %s!\n") % short(node))

                return nullid

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

    def __getitem__(self, changeid):

        if changeid is None:

            return context.workingctx(self)

        return context.changectx(self, changeid)

    def __contains__(self, changeid):

        try:

            return bool(self.lookup(changeid))

        except error.RepoLookupError:

            return False

    def __nonzero__(self):

        return True

    def __len__(self):

        return len(self.changelog)

    def __iter__(self):

        for i in xrange(len(self)):

            yield i

    def set(self, expr, *args):

        '''

        Yield a context for each matching revision, after doing arg

        replacement via revset.formatspec

        '''

        expr = revset.formatspec(expr, *args)

        m = revset.match(None, expr)

        for r in m(self, range(len(self))):

            yield self[r]

    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)

        branches = self.branchmap()

        for name in names:

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

                      local=local)

            if name in branches:

                self.ui.warn(_("warning: tag %s conflicts with existing"

                " branch name\n") % name)

        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._tagscache.tagtypes and name in self._tagscache.tagtypes:

                    old = self.tags().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, e:

            if e.errno != errno.ENOENT:

                raise

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

        else:

            prevtags = fp.read()

        # committed tags are stored in UTF-8

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

        fp.close()

        if '.hgtags' not in self.dirstate:

            self[None].add(['.hgtags'])

        m = matchmod.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'''

        if not local:

            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)

    @propertycache

    def _tagscache(self):

        '''Returns a tagscache object that contains various tags related caches.'''

        # This simplifies its cache management by having one decorated

        # function (this one) and the rest simply fetch things from it.

        class tagscache(object):

            def __init__(self):

                # These two define the set of tags for this repository. tags

                # maps tag name to node; tagtypes maps tag name to 'global' or

                # 'local'. (Global tags are defined by .hgtags across all

                # heads, and local tags are defined in .hg/localtags.)

                # They constitute the in-memory cache of tags.

                self.tags = self.tagtypes = None

                self.nodetagscache = self.tagslist = None

        cache = tagscache()

        cache.tags, cache.tagtypes = self._findtags()

        return cache

    def tags(self):

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

        return self._tagscache.tags

    def _findtags(self):