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

import os, util

import filelog, manifest, changelog, dirstate, repo

from node import *

from i18n import gettext as _

from demandload import *

demandload(globals(), "appendfile changegroup")

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

class localrepository(object):

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

        flags = 0

        for x in v.get('flags', "").split():

            flags |= revlog.flagstr(x)

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

                       [(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(_('error: %s hook %s\n') % (name, desc))

                return False

            return True

        r = True

        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:

            r = runhook(hname, cmd) and 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: ignoring invalid tag\n") % context)

                    return

                node, key = s

                try:

                    bin_n = bin(node)

                except TypeError:

                    self.ui.warn(_("%s: ignoring invalid tag\n") % context)

                    return

                if bin_n not in self.changelog.nodemap:

                    self.ui.warn(_("%s: ignoring invalid tag\n") % context)

                    return

                self.tagscache[key.strip()] = bin_n

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

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

            # taking precedence

            fl = self.file(".hgtags")

            h = fl.heads()

            h.reverse()

            for r in h:

                count = 0

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

                    count += 1

                    parsetag(l, ".hgtags:%d" % count)

            try:

                f = self.opener("localtags")

                count = 0

                for l in f:

                    count += 1

                    parsetag(l, "localtags:%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

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

    def dev(self):

        return os.stat(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 undo

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