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

demandload(globals(), "appendfile changegroup")

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

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

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

class localrepository(object):

    capabilities = ()

    def __del__(self):

        self.transhandle = None

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

        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:

            os.mkdir(self.path)

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

        self.dirstate = dirstate.dirstate(self.opener, self.ui, 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:

                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

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