# 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 peer, changegroup, subrepo, discovery, pushkey, obsolete

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

import lock, transaction, store, encoding, base85

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 storecache(filecache):

    """filecache for files in the store"""

    def join(self, obj, fname):

        return obj.sjoin(fname)

def unfilteredmeth(orig):

    """decorate method that always need to be run on unfiltered version"""

    def wrapper(repo, *args, **kwargs):

        return orig(repo.unfiltered(), *args, **kwargs)

    return wrapper

MODERNCAPS = set(('lookup', 'branchmap', 'pushkey', 'known', 'getbundle'))

LEGACYCAPS = MODERNCAPS.union(set(['changegroupsubset']))

class localpeer(peer.peerrepository):

    '''peer for a local repo; reflects only the most recent API'''

    def __init__(self, repo, caps=MODERNCAPS):

        peer.peerrepository.__init__(self)

        self._repo = repo

        self.ui = repo.ui

        self._caps = repo._restrictcapabilities(caps)

        self.requirements = repo.requirements

        self.supportedformats = repo.supportedformats

    def close(self):

        self._repo.close()

    def _capabilities(self):

        return self._caps

    def local(self):

        return self._repo

    def canpush(self):

        return True

    def url(self):

        return self._repo.url()

    def lookup(self, key):

        return self._repo.lookup(key)

    def branchmap(self):

        return discovery.visiblebranchmap(self._repo)

    def heads(self):

        return discovery.visibleheads(self._repo)

    def known(self, nodes):

        return self._repo.known(nodes)

    def getbundle(self, source, heads=None, common=None):

        return self._repo.getbundle(source, heads=heads, common=common)

    # TODO We might want to move the next two calls into legacypeer and add

    # unbundle instead.

    def lock(self):

        return self._repo.lock()

    def addchangegroup(self, cg, source, url):

        return self._repo.addchangegroup(cg, source, url)

    def pushkey(self, namespace, key, old, new):

        return self._repo.pushkey(namespace, key, old, new)

    def listkeys(self, namespace):

        return self._repo.listkeys(namespace)

    def debugwireargs(self, one, two, three=None, four=None, five=None):

        '''used to test argument passing over the wire'''

        return "%s %s %s %s %s" % (one, two, three, four, five)

class locallegacypeer(localpeer):

    '''peer extension which implements legacy methods too; used for tests with

    restricted capabilities'''

    def __init__(self, repo):

        localpeer.__init__(self, repo, caps=LEGACYCAPS)

    def branches(self, nodes):

        return self._repo.branches(nodes)

    def between(self, pairs):

        return self._repo.between(pairs)

    def changegroup(self, basenodes, source):

        return self._repo.changegroup(basenodes, source)

    def changegroupsubset(self, bases, heads, source):

        return self._repo.changegroupsubset(bases, heads, source)

class localrepository(object):

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

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

                                        'dotencode'))

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

    requirements = ['revlogv1']

    def _baserequirements(self, create):

        return self.requirements[:]

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

        self.wvfs = scmutil.vfs(path, expand=True)

        self.wopener = self.wvfs

        self.root = self.wvfs.base

        self.path = self.wvfs.join(".hg")

        self.origroot = path

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

        self.vfs = scmutil.vfs(self.path)

        self.opener = self.vfs

        self.baseui = baseui

        self.ui = baseui.copy()

        # A list of callback to shape the phase if no data were found.

        # Callback are in the form: func(repo, roots) --> processed root.

        # This list it to be filled by extension during repo setup

        self._phasedefaults = []

        try:

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

            extensions.loadall(self.ui)

        except IOError:

            pass

        if not self.vfs.isdir():

            if create:

                if not self.wvfs.exists():

                    self.wvfs.makedirs()

                self.vfs.makedir(notindexed=True)

                requirements = self._baserequirements(create)

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

                    self.vfs.mkdir("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.vfs.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.vfs, 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.vfs)

        self.spath = self.store.path

        self.svfs = self.store.vfs

        self.sopener = self.svfs

        self.sjoin = self.store.join

        self.vfs.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 close(self):

        pass

    def _restrictcapabilities(self, caps):

        return caps

    def _applyrequirements(self, requirements):

        self.requirements = requirements

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

                                           if r in self.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:]

        normsubpath = util.pconvert(subpath)

        # 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 = '/'.join(parts)

            if prefix in ctx.substate:

                if prefix == normsubpath:

                    return True

                else:

                    sub = ctx.sub(prefix)

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

            else:

                parts.pop()

        return False

    def peer(self):

        return localpeer(self) # not cached to avoid reference cycle

    def unfiltered(self):

        """Return unfiltered version of the repository

        Intended to be ovewritten by filtered repo."""

        return self

    @filecache('bookmarks')

    def _bookmarks(self):

        return bookmarks.bmstore(self)

    @filecache('bookmarks.current')

    def _bookmarkcurrent(self):

        return bookmarks.readcurrent(self)

    def bookmarkheads(self, bookmark):

        name = bookmark.split('@', 1)[0]

        heads = []

        for mark, n in self._bookmarks.iteritems():

            if mark.split('@', 1)[0] == name:

                heads.append(n)

        return heads

    @storecache('phaseroots')

    def _phasecache(self):

        return phases.phasecache(self, self._phasedefaults)

    @storecache('obsstore')

    def obsstore(self):

        store = obsolete.obsstore(self.sopener)

        if store and not obsolete._enabled:

            # message is rare enough to not be translated

            msg = 'obsolete feature not enabled but %i markers found!\n'

            self.ui.warn(msg % len(list(store)))

        return store

    def hiddenrevs(self):

        """hiddenrevs: revs that should be hidden by command and tools

        This set is carried on the repo to ease initialization and lazy

        loading; it'll probably move back to changelog for efficiency and

        consistency reasons.

        Note that the hiddenrevs will needs invalidations when

        - a new changesets is added (possible unstable above extinct)

        - a new obsolete marker is added (possible new extinct changeset)

        hidden changesets cannot have non-hidden descendants

        """

        hidden = set()

        if self.obsstore:

            ### hide extinct changeset that are not accessible by any mean

            hiddenquery = 'extinct() - ::(. + bookmark())'

            hidden.update(self.revs(hiddenquery))

        return hidden

    @storecache('00changelog.i')

    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

    @storecache('00manifest.i')

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

        return iter(self.changelog)

    def revs(self, expr, *args):

        '''Return a list of revisions matching the given revset'''

        expr = revset.formatspec(expr, *args)

        m = revset.match(None, expr)

        return [r for r in m(self, list(self))]

    def set(self, expr, *args):

        '''

        Yield a context for each matching revision, after doing arg

        replacement via revset.formatspec

        '''

        for r in self.revs(expr, *args):

            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)

    @unfilteredmeth

    def _tag(self, names, node, message, local, user, date, extra={}):

        if isinstance(names, str):

            names = (names,)

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

        self.invalidatecaches()

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