# 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 struct, os, util

import filelog, manifest, changelog, dirstate, repo

from node import *

from i18n import gettext as _

from demandload import *

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

class localrepository:

    def __init__(self, ui, 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") % self.path)

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

        self.ui = ui

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

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

        self.manifest = manifest.manifest(self.opener)

        self.changelog = changelog.changelog(self.opener)

        self.tagscache = None

        self.nodetagscache = None

        self.encodepats = None

        self.decodepats = None

        if create:

            os.mkdir(self.path)

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

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

        try:

            self.ui.readconfig(os.path.join(self.path, "hgrc"))

        except IOError: pass

    def hook(self, name, **args):

        s = self.ui.config("hooks", name)

        if s:

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

            old = {}

            for k, v in args.items():

                k = k.upper()

                old[k] = os.environ.get(k, None)

                os.environ[k] = v

            # Hooks run in the repository root

            olddir = os.getcwd()

            os.chdir(self.root)

            r = os.system(s)

            os.chdir(olddir)

            for k, v in old.items():

                if v != None:

                    os.environ[k] = v

                else:

                    del os.environ[k]

            if r:

                self.ui.warn(_("abort: %s hook failed with status %d!\n") %

                             (name, r))

                return False

        return True

    def tags(self):

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

        if not self.tagscache:

            self.tagscache = {}

            def addtag(self, k, n):

                try:

                    bin_n = bin(n)

                except TypeError:

                    bin_n = ''

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

            try:

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

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

                        if l:

                            n, k = l.split(" ", 1)

                            addtag(self, k, n)

            except KeyError:

                pass

            try:

                f = self.opener("localtags")

                for l in f:

                    n, k = l.split(" ", 1)

                    addtag(self, k, n)

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

    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("", "/", [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("", "/", [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):

        # save dirstate for undo

        try:

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

        except IOError:

            ds = ""

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

        def after():

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

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

                        self.join("undo.dirstate"))

        return transaction.transaction(self.ui.warn, self.opener,

                                       self.join("journal"), after)

    def recover(self):

        lock = self.lock()

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

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

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

        else:

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

    def undo(self):

        lock = self.lock()

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

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

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

            self.dirstate = None

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

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

        else:

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

    def lock(self, wait=1):

        try:

            return lock.lock(self.join("lock"), 0)

        except lock.LockHeld, inst:

            if wait:

                self.ui.warn(_("waiting for lock held by %s\n") % inst.args[0])

                return lock.lock(self.join("lock"), wait)

            raise inst

    def rawcommit(self, files, text, user, date, p1=None, p2=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

        tr = self.transaction()

        mm = m1.copy()

        mfm = mf1.copy()

        linkrev = self.changelog.count()

        for f in files:

            try:

                t = self.wread(f)

                tm = util.is_exec(self.wjoin(f), mfm.get(f, False))

                r = self.file(f)

                mfm[f] = tm

                fp1 = m1.get(f, nullid)

                fp2 = m2.get(f, nullid)

                # is the same revision on two branches of a merge?

                if fp2 == fp1:

                    fp2 = nullid

                if fp2 != nullid:

                    # is one parent an ancestor of the other?

                    fpa = r.ancestor(fp1, fp2)

                    if fpa == fp1:

                        fp1, fp2 = fp2, nullid

                    elif fpa == fp2:

                        fp2 = nullid

                    # is the file unmodified from the parent?

                    if t == r.read(fp1):

                        # record the proper existing parent in manifest

                        # no need to add a revision

                        mm[f] = fp1

                        continue

                mm[f] = r.add(t, {}, tr, linkrev, fp1, fp2)

                changed.append(f)

                if update_dirstate:

                    self.dirstate.update([f], "n")

            except IOError:

                try:

                    del mm[f]

                    del mfm[f]

                    if update_dirstate:

                        self.dirstate.forget([f])

                except:

                    # deleted from p2?

                    pass

        mnode = self.manifest.add(mm, mfm, tr, linkrev, c1[0], c2[0])

        user = user or self.ui.username()

        n = self.changelog.add(mnode, changed, text, tr, p1, p2, user, date)

        tr.close()

        if update_dirstate:

            self.dirstate.setparents(n, nullid)

    def commit(self, files = None, text = "", user = None, date = None,

               match = util.always, force=False):

        commit = []

        remove = []

        changed = []

        if files:

            for f in files:

                s = self.dirstate.state(f)

                if s in 'nmai':

                    commit.append(f)

                elif s == 'r':

                    remove.append(f)

                else:

                    self.ui.warn(_("%s not tracked!\n") % f)

        else:

            (c, a, d, u) = self.changes(match=match)

            commit = c + a

            remove = d

        p1, p2 = self.dirstate.parents()

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

        if not commit and not remove and not force and p2 == nullid:

            self.ui.status(_("nothing changed\n"))

            return None

        if not self.hook("precommit"):

            return None