# localrepo.py - read/write repository class for mercurial

#

# Copyright 2005 Matt Mackall <mpm@selenic.com>

#

# This software may be used and distributed according to the terms

# of the GNU General Public License, incorporated herein by reference.

from node import *

from i18n import gettext as _

from demandload import *

import repo

demandload(globals(), "appendfile changegroup")

demandload(globals(), "changelog dirstate filelog manifest context")

demandload(globals(), "re lock transaction tempfile stat mdiff errno ui")

demandload(globals(), "os revlog time util")

class localrepository(repo.repository):

    capabilities = ()

    def __del__(self):

        self.transhandle = None

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

        repo.repository.__init__(self)

        if not path:

            p = os.getcwd()

            while not os.path.isdir(os.path.join(p, ".hg")):

                oldp = p

                p = os.path.dirname(p)

                if p == oldp:

                    raise repo.RepoError(_("no repo found"))

            path = p

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

        if not create and not os.path.isdir(self.path):

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

        self.root = os.path.abspath(path)

        self.origroot = path

        self.ui = ui.ui(parentui=parentui)

        self.opener = util.opener(self.path)

        self.wopener = util.opener(self.root)

        try:

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

        except IOError:

            pass

        v = self.ui.revlogopts

        self.revlogversion = int(v.get('format', revlog.REVLOG_DEFAULT_FORMAT))

        self.revlogv1 = self.revlogversion != revlog.REVLOGV0

        fl = v.get('flags', None)

        flags = 0

        if fl != None:

            for x in fl.split():

                flags |= revlog.flagstr(x)

        elif self.revlogv1:

            flags = revlog.REVLOG_DEFAULT_FLAGS

        v = self.revlogversion | flags

        self.manifest = manifest.manifest(self.opener, v)

        self.changelog = changelog.changelog(self.opener, v)

        # the changelog might not have the inline index flag

        # on.  If the format of the changelog is the same as found in

        # .hgrc, apply any flags found in the .hgrc as well.

        # Otherwise, just version from the changelog

        v = self.changelog.version

        if v == self.revlogversion:

            v |= flags

        self.revlogversion = v

        self.tagscache = None

        self.nodetagscache = None

        self.encodepats = None

        self.decodepats = None

        self.transhandle = None

        if create:

            if not os.path.exists(path):

                os.mkdir(path)

            os.mkdir(self.path)

            os.mkdir(self.join("data"))

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

    def url(self):

        return 'file:' + self.root

    def hook(self, name, throw=False, **args):

        def callhook(hname, funcname):

            '''call python hook. hook is callable object, looked up as

            name in python module. if callable returns "true", hook

            fails, else passes. if hook raises exception, treated as

            hook failure. exception propagates if throw is "true".

            reason for "true" meaning "hook failed" is so that

            unmodified commands (e.g. mercurial.commands.update) can

            be run as hooks without wrappers to convert return values.'''

            self.ui.note(_("calling hook %s: %s\n") % (hname, funcname))

            d = funcname.rfind('.')

            if d == -1:

                raise util.Abort(_('%s hook is invalid ("%s" not in a module)')

                                 % (hname, funcname))

            modname = funcname[:d]

            try:

                obj = __import__(modname)

            except ImportError:

                try:

                    # extensions are loaded with hgext_ prefix

                    obj = __import__("hgext_%s" % modname)

                except ImportError:

                    raise util.Abort(_('%s hook is invalid '

                                       '(import of "%s" failed)') %

                                     (hname, modname))

            try:

                for p in funcname.split('.')[1:]:

                    obj = getattr(obj, p)

            except AttributeError, err:

                raise util.Abort(_('%s hook is invalid '

                                   '("%s" is not defined)') %

                                 (hname, funcname))

            if not callable(obj):

                raise util.Abort(_('%s hook is invalid '

                                   '("%s" is not callable)') %

                                 (hname, funcname))

            try:

                r = obj(ui=self.ui, repo=self, hooktype=name, **args)

            except (KeyboardInterrupt, util.SignalInterrupt):

                raise

            except Exception, exc:

                if isinstance(exc, util.Abort):

                    self.ui.warn(_('error: %s hook failed: %s\n') %

                                 (hname, exc.args[0] % exc.args[1:]))

                else:

                    self.ui.warn(_('error: %s hook raised an exception: '

                                   '%s\n') % (hname, exc))

                if throw:

                    raise

                self.ui.print_exc()

                return True

            if r:

                if throw:

                    raise util.Abort(_('%s hook failed') % hname)

                self.ui.warn(_('warning: %s hook failed\n') % hname)

            return r

        def runhook(name, cmd):

            self.ui.note(_("running hook %s: %s\n") % (name, cmd))

            env = dict([('HG_' + k.upper(), v) for k, v in args.iteritems()])

            r = util.system(cmd, environ=env, cwd=self.root)

            if r:

                desc, r = util.explain_exit(r)

                if throw:

                    raise util.Abort(_('%s hook %s') % (name, desc))

                self.ui.warn(_('warning: %s hook %s\n') % (name, desc))

            return r

        r = False

        hooks = [(hname, cmd) for hname, cmd in self.ui.configitems("hooks")

                 if hname.split(".", 1)[0] == name and cmd]

        hooks.sort()

        for hname, cmd in hooks:

            if cmd.startswith('python:'):

                r = callhook(hname, cmd[7:].strip()) or r

            else:

                r = runhook(hname, cmd) or r

        return r

    tag_disallowed = ':\r\n'

    def tag(self, name, node, local=False, message=None, user=None, date=None):

        '''tag a revision with a symbolic name.

        if local is True, the tag is stored in a per-repository file.

        otherwise, it is stored in the .hgtags file, and a new

        changeset is committed with the change.

        keyword arguments:

        local: whether to store tag 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 c in self.tag_disallowed:

            if c in name:

                raise util.Abort(_('%r cannot be used in a tag name') % c)

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

        if local:

            self.opener('localtags', 'a').write('%s %s\n' % (node, name))

            self.hook('tag', node=node, tag=name, local=local)

            return

        for x in self.changes():

            if '.hgtags' in x:

                raise util.Abort(_('working copy of .hgtags is changed '

                                   '(please commit .hgtags manually)'))

        self.wfile('.hgtags', 'ab').write('%s %s\n' % (node, name))

        if self.dirstate.state('.hgtags') == '?':

            self.add(['.hgtags'])

        if not message:

            message = _('Added tag %s for changeset %s') % (name, node)

        self.commit(['.hgtags'], message, user, date)

        self.hook('tag', node=node, tag=name, local=local)

    def tags(self):

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

        if not self.tagscache:

            self.tagscache = {}

            def parsetag(line, context):

                if not line:

                    return

                s = l.split(" ", 1)

                if len(s) != 2:

                    self.ui.warn(_("%s: cannot parse entry\n") % context)

                    return

                node, key = s

                key = key.strip()

                try:

                    bin_n = bin(node)

                except TypeError:

                    self.ui.warn(_("%s: node '%s' is not well formed\n") %

                                 (context, node))

                    return

                if bin_n not in self.changelog.nodemap:

                    self.ui.warn(_("%s: tag '%s' refers to unknown node\n") %

                                 (context, key))

                    return

                self.tagscache[key] = bin_n

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

            # and add each tag found to the map, with "newer" ones

            # taking precedence

            heads = self.heads()

            heads.reverse()

            fl = self.file(".hgtags")

            for node in heads:

                change = self.changelog.read(node)

                rev = self.changelog.rev(node)

                fn, ff = self.manifest.find(change[0], '.hgtags')

                if fn is None: continue

                count = 0

                for l in fl.read(fn).splitlines():

                    count += 1

                    parsetag(l, _(".hgtags (rev %d:%s), line %d") %

                             (rev, short(node), count))

            try:

                f = self.opener("localtags")

                count = 0

                for l in f:

                    count += 1

                    parsetag(l, _("localtags, line %d") % count)

            except IOError:

                pass

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

        return self.tagscache

    def tagslist(self):

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

        l = []

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

            try:

                r = self.changelog.rev(n)

            except:

                r = -2 # sort to the beginning of the list if unknown

            l.append((r, t, n))

        l.sort()

        return [(t, n) for r, t, n in l]

    def nodetags(self, node):

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

        if not self.nodetagscache:

            self.nodetagscache = {}

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

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

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

    def lookup(self, key):

        try:

            return self.tags()[key]

        except KeyError:

            try:

                return self.changelog.lookup(key)

            except:

                raise repo.RepoError(_("unknown revision '%s'") % key)

    def dev(self):

        return os.lstat(self.path).st_dev

    def local(self):

        return True

    def join(self, f):

        return os.path.join(self.path, f)

    def wjoin(self, f):

        return os.path.join(self.root, f)

    def file(self, f):

        if f[0] == '/':

            f = f[1:]

        return filelog.filelog(self.opener, f, self.revlogversion)

    def changectx(self, changeid):

        return context.changectx(self, changeid)

    def filectx(self, path, changeid=None, fileid=None):

        """changeid can be a changeset revision, node, or tag.

           fileid can be a file revision or node."""

        return context.filectx(self, path, changeid, fileid)

    def getcwd(self):

        return self.dirstate.getcwd()

    def wfile(self, f, mode='r'):

        return self.wopener(f, mode)

    def wread(self, filename):

        if self.encodepats == None:

            l = []

            for pat, cmd in self.ui.configitems("encode"):

                mf = util.matcher(self.root, "", [pat], [], [])[1]

                l.append((mf, cmd))

            self.encodepats = l

        data = self.wopener(filename, 'r').read()

        for mf, cmd in self.encodepats:

            if mf(filename):

                self.ui.debug(_("filtering %s through %s\n") % (filename, cmd))

                data = util.filter(data, cmd)

                break

        return data

    def wwrite(self, filename, data, fd=None):

        if self.decodepats == None:

            l = []

            for pat, cmd in self.ui.configitems("decode"):

                mf = util.matcher(self.root, "", [pat], [], [])[1]

                l.append((mf, cmd))

            self.decodepats = l

        for mf, cmd in self.decodepats:

            if mf(filename):

                self.ui.debug(_("filtering %s through %s\n") % (filename, cmd))

                data = util.filter(data, cmd)

                break

        if fd:

            return fd.write(data)

        return self.wopener(filename, 'w').write(data)

    def transaction(self):

        tr = self.transhandle

        if tr != None and tr.running():

            return tr.nest()

        # save dirstate for rollback

        try:

            ds = self.opener("dirstate").read()

        except IOError:

            ds = ""

        self.opener("journal.dirstate", "w").write(ds)

        tr = transaction.transaction(self.ui.warn, self.opener,

                                       self.join("journal"),

                                       aftertrans(self.path))

        self.transhandle = tr

        return tr

    def recover(self):

        l = self.lock()

        if os.path.exists(self.join("journal")):

            self.ui.status(_("rolling back interrupted transaction\n"))

            transaction.rollback(self.opener, self.join("journal"))

            self.reload()

            return True

        else:

            self.ui.warn(_("no interrupted transaction available\n"))

            return False

    def rollback(self, wlock=None):

        if not wlock:

            wlock = self.wlock()

        l = self.lock()

        if os.path.exists(self.join("undo")):

            self.ui.status(_("rolling back last transaction\n"))

            transaction.rollback(self.opener, self.join("undo"))

            util.rename(self.join("undo.dirstate"), self.join("dirstate"))

            self.reload()

            self.wreload()

        else:

            self.ui.warn(_("no rollback information available\n"))

    def wreload(self):

        self.dirstate.read()

    def reload(self):

        self.changelog.load()

        self.manifest.load()

        self.tagscache = None

        self.nodetagscache = None

    def do_lock(self, lockname, wait, releasefn=None, acquirefn=None,

                desc=None):

        try:

            l = lock.lock(self.join(lockname), 0, releasefn, desc=desc)

        except lock.LockHeld, inst:

            if not wait:

                raise

            self.ui.warn(_("waiting for lock on %s held by %s\n") %

                         (desc, inst.args[0]))

            # default to 600 seconds timeout

            l = lock.lock(self.join(lockname),

                          int(self.ui.config("ui", "timeout") or 600),

                          releasefn, desc=desc)

        if acquirefn:

            acquirefn()

        return l

    def lock(self, wait=1):

        return self.do_lock("lock", wait, acquirefn=self.reload,

                            desc=_('repository %s') % self.origroot)

    def wlock(self, wait=1):

        return self.do_lock("wlock", wait, self.dirstate.write,

                            self.wreload,

                            desc=_('working directory of %s') % self.origroot)

    def checkfilemerge(self, filename, text, filelog, manifest1, manifest2):

        "determine whether a new filenode is needed"

        fp1 = manifest1.get(filename, nullid)

        fp2 = manifest2.get(filename, nullid)

        if fp2 != nullid:

            # is one parent an ancestor of the other?

            fpa = filelog.ancestor(fp1, fp2)

            if fpa == fp1:

                fp1, fp2 = fp2, nullid

            elif fpa == fp2:

                fp2 = nullid

            # is the file unmodified from the parent? report existing entry

            if fp2 == nullid and text == filelog.read(fp1):

                return (fp1, None, None)

        return (None, fp1, fp2)

    def rawcommit(self, files, text, user, date, p1=None, p2=None, wlock=None):

        orig_parent = self.dirstate.parents()[0] or nullid

        p1 = p1 or self.dirstate.parents()[0] or nullid

        p2 = p2 or self.dirstate.parents()[1] or nullid

        c1 = self.changelog.read(p1)

        c2 = self.changelog.read(p2)

        m1 = self.manifest.read(c1[0])

        mf1 = self.manifest.readflags(c1[0])

        m2 = self.manifest.read(c2[0])

        changed = []

        if orig_parent == p1:

            update_dirstate = 1

        else:

            update_dirstate = 0

        if not wlock:

            wlock = self.wlock()

        l = self.lock()

        tr = self.transaction()

        mm = m1.copy()