# 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(), "re lock transaction tempfile stat mdiff errno ui")

demandload(globals(), "appendfile changegroup")

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)

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

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

        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)

        try:

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

        except IOError:

            pass

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

        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

                (entry, fp1, fp2) = self.checkfilemerge(f, t, r, m1, m2)

                if entry:

                    mm[f] = entry

                    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, lock=None, wlock=None):

        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:

            modified, added, removed, deleted, unknown = self.changes(match=match)

            commit = modified + added

            remove = removed

        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

        xp1 = hex(p1)

        if p2 == nullid: xp2 = ''

        else: xp2 = hex(p2)

        self.hook("precommit", throw=True, parent1=xp1, parent2=xp2)

        if not wlock:

            wlock = self.wlock()

        if not lock:

            lock = self.lock()

        tr = self.transaction()

        # check in files

        new = {}

        linkrev = self.changelog.count()

        commit.sort()

        for f in commit:

            self.ui.note(f + "\n")

            try:

                mf1[f] = util.is_exec(self.wjoin(f), mf1.get(f, False))

                t = self.wread(f)

            except IOError:

                self.ui.warn(_("trouble committing %s!\n") % f)

                raise

            r = self.file(f)

            meta = {}

            cp = self.dirstate.copied(f)

            if cp:

                meta["copy"] = cp

                meta["copyrev"] = hex(m1.get(cp, m2.get(cp, nullid)))

                self.ui.debug(_(" %s: copy %s:%s\n") % (f, cp, meta["copyrev"]))

                fp1, fp2 = nullid, nullid

            else:

                entry, fp1, fp2 = self.checkfilemerge(f, t, r, m1, m2)

                if entry:

                    new[f] = entry

                    continue

            new[f] = r.add(t, meta, tr, linkrev, fp1, fp2)

            # remember what we've added so that we can later calculate

            # the files to pull from a set of changesets

            changed.append(f)

        # update manifest

        m1 = m1.copy()

        m1.update(new)

        for f in remove:

            if f in m1:

                del m1[f]

        mn = self.manifest.add(m1, mf1, tr, linkrev, c1[0], c2[0],

                               (new, remove))

        # add changeset

        new = new.keys()

        new.sort()

        user = user or self.ui.username()

        if not text:

            edittext = [""]

            if p2 != nullid:

                edittext.append("HG: branch merge")

            edittext.extend(["HG: changed %s" % f for f in changed])

            edittext.extend(["HG: removed %s" % f for f in remove])

            if not changed and not remove:

                edittext.append("HG: no files changed")

            edittext.append("")

            # run editor in the repository root

            olddir = os.getcwd()

            os.chdir(self.root)

            edittext = self.ui.edit("\n".join(edittext), user)

            os.chdir(olddir)

            if not edittext.rstrip():

                return None

            text = edittext

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

        self.hook('pretxncommit', throw=True, node=hex(n), parent1=xp1,

                  parent2=xp2)

        tr.close()

        self.dirstate.setparents(n)

        self.dirstate.update(new, "n")

        self.dirstate.forget(remove)