# 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

import lock, transaction, store, encoding

import util, extensions, hook, error

import match as matchmod

import merge as mergemod

import tags as tagsmod

import url as urlmod

from lock import release

import weakref, errno, os, time, inspect

propertycache = util.propertycache

class localrepository(repo.repository):

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

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

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

                                        'dotencode'))

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

        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 = util.path_auditor(self.root, self._checknested)

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

                    util.makedirs(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")

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

                            requirements.append('dotencode')

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

                    )

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

                    requirements.append("parentdelta")

            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._applyrequirements(requirements)

        if create:

            self._writerequirements()

        # 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 = None

        self._tagtypes = None

        self._branchcache = None  # in UTF-8

        self._branchcachetip = None

        self.nodetagscache = None

        self.filterpats = {}

        self._datafilters = {}

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

    def _applyrequirements(self, requirements):

        self.requirements = requirements

        self.sopener.options = {}

        if 'parentdelta' in requirements:

            self.sopener.options['parentdelta'] = 1

    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

    @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.options['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 __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 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._tagtypes and name in self._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:

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

    def tags(self):

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

        if self._tags is None:

            (self._tags, self._tagtypes) = self._findtags()

        return self._tags

    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?

        alltags = {}                    # map tag name to (node, hist)

        tagtypes = {}

        tagsmod.findglobaltags(self.ui, self, alltags, tagtypes)

        tagsmod.readlocaltags(self.ui, self, alltags, tagtypes)

        # Build the return dicts.  Have to re-encode tag names because

        # the tags module always uses UTF-8 (in order not to lose info

        # writing to the cache), but the rest of Mercurial wants them in

        # local encoding.

        tags = {}

        for (name, (node, hist)) in alltags.iteritems():

            if node != nullid:

                tags[encoding.tolocal(name)] = node

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

        tagtypes = dict([(encoding.tolocal(name), value)

                         for (name, value) in tagtypes.iteritems()])

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

        return self._tagtypes.get(tagname)

    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)

            for tags in self.nodetagscache.itervalues():

                tags.sort()

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

    def _branchtags(self, partial, lrev):

        # TODO: rename this function?

        tiprev = len(self) - 1

        if lrev != tiprev:

            ctxgen = (self[r] for r in xrange(lrev + 1, tiprev + 1))

            self._updatebranchcache(partial, ctxgen)

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

        return partial

    def updatebranchcache(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 oldtip is None or oldtip not in self.changelog.nodemap:

            partial, last, lrev = self._readbranchcache()

        else:

            lrev = self.changelog.rev(oldtip)

            partial = self._branchcache

        self._branchtags(partial, lrev)

        # this private cache holds all heads (not just tips)

        self._branchcache = partial

    def branchmap(self):

        '''returns a dictionary {branch: [branchheads]}'''

        self.updatebranchcache()

        return self._branchcache

    def branchtags(self):

        '''return a dict where branch names map to the tipmost head of

        the branch, open heads come before closed'''

        bt = {}

        for bn, heads in self.branchmap().iteritems():

            tip = heads[-1]

            for h in reversed(heads):

                if 'close' not in self.changelog.read(h)[5]:

                    tip = h

                    break

            bt[bn] = tip

        return bt

    def _readbranchcache(self):

        partial = {}

        try:

            f = self.opener("branchheads.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.setdefault(label.strip(), []).append(bin(node))

        except KeyboardInterrupt:

            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("branchheads.cache", "w", atomictemp=True)

            f.write("%s %s\n" % (hex(tip), tiprev))

            for label, nodes in branches.iteritems():

                for node in nodes:

                    f.write("%s %s\n" % (hex(node), label))

            f.rename()

        except (IOError, OSError):

            pass

    def _updatebranchcache(self, partial, ctxgen):

        # collect new branch entries

        newbranches = {}

        for c in ctxgen:

            newbranches.setdefault(c.branch(), []).append(c.node())

        # if older branchheads are reachable from new ones, they aren't

        # really branchheads. Note checking parents is insufficient:

        # 1 (branch a) -> 2 (branch b) -> 3 (branch a)

        for branch, newnodes in newbranches.iteritems():

            bheads = partial.setdefault(branch, [])

            bheads.extend(newnodes)

            if len(bheads) <= 1:

                continue

            # starting from tip means fewer passes over reachable

            while newnodes:

                latest = newnodes.pop()

                if latest not in bheads:

                    continue

                minbhrev = self[min([self[bh].rev() for bh in bheads])].node()

                reachable = self.changelog.reachable(latest, minbhrev)

                reachable.remove(latest)

                bheads = [b for b in bheads if b not in reachable]

            partial[branch] = bheads

    def lookup(self, key):

        if isinstance(key, int):

            return self.changelog.node(key)

        elif key == '.':

            return self.dirstate.parents()[0]

        elif key == 'null':

            return nullid

        elif key == 'tip':

            return self.changelog.tip()

        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

        # can't find key, check if it might have come from damaged dirstate

        if key in self.dirstate.parents():

            raise error.Abort(_("working directory has unknown parent '%s'!")

                              % short(key))

        try:

            if len(key) == 20:

                key = hex(key)

        except:

            pass

        raise error.RepoLookupError(_("unknown revision '%s'") % key)

    def lookupbranch(self, key, remote=None):

        repo = remote or self

        if key in repo.branchmap():

            return key

        repo = (remote and remote.local()) and remote or self

        return repo[key].branch()