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

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

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

        if create:

            os.mkdir(self.path)

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

            f = self.opener("hgrc", "w")

            f.write("[web]\n")

            f.write("contact = %s\n" % ui.shortuser(ui.username()))

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

        try:

            self.ui.readconfig(self.opener("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

            r = os.system(s)

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

        return self.wopener(filename, 'r').read()

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

        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

        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:

                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 not meta and t == r.read(fp1):

                    # record the proper existing parent in manifest

                    # no need to add a revision

                    new[f] = fp1

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

        if not text:

            edittext = ""

            if p2 != nullid:

                edittext += "HG: branch merge\n"

            edittext += "\n" + "HG: manifest hash %s\n" % hex(mn)

            edittext += "".join(["HG: changed %s\n" % f for f in changed])

            edittext += "".join(["HG: removed %s\n" % f for f in remove])

            if not changed and not remove:

                edittext += "HG: no files changed\n"

            edittext = self.ui.edit(edittext)

            if not edittext.rstrip():

                return None

            text = edittext

        user = user or self.ui.username()

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

        tr.close()

        self.dirstate.setparents(n)

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

        self.dirstate.forget(remove)

        if not self.hook("commit", node=hex(n)):

            return None

        return n

    def walk(self, node=None, files=[], match=util.always):

        if node:

            for fn in self.manifest.read(self.changelog.read(node)[0]):

                if match(fn): yield 'm', fn

        else:

            for src, fn in self.dirstate.walk(files, match):

                yield src, fn

    def changes(self, node1 = None, node2 = None, files = [],

                match = util.always):

        mf2, u = None, []

        def fcmp(fn, mf):

            t1 = self.wread(fn)

            t2 = self.file(fn).read(mf.get(fn, nullid))

            return cmp(t1, t2)

        def mfmatches(node):

            mf = dict(self.manifest.read(node))

            for fn in mf.keys():

                if not match(fn):

                    del mf[fn]

            return mf

        # are we comparing the working directory?

        if not node2:

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

            # are we comparing working dir against its parent?

            if not node1:

                if l:

                    # do a full compare of any files that might have changed

                    change = self.changelog.read(self.dirstate.parents()[0])

                    mf2 = mfmatches(change[0])

                    for f in l:

                        if fcmp(f, mf2):

                            c.append(f)

                for l in c, a, d, u:

                    l.sort()

                return (c, a, d, u)

        # are we comparing working dir against non-tip?

        # generate a pseudo-manifest for the working dir

        if not node2:

            if not mf2:

                change = self.changelog.read(self.dirstate.parents()[0])

                mf2 = mfmatches(change[0])

            for f in a + c + l:

                mf2[f] = ""

            for f in d:

                if f in mf2: del mf2[f]

        else:

            change = self.changelog.read(node2)

            mf2 = mfmatches(change[0])

        # flush lists from dirstate before comparing manifests

        c, a = [], []

        change = self.changelog.read(node1)

        mf1 = mfmatches(change[0])

        for fn in mf2:

            if mf1.has_key(fn):

                if mf1[fn] != mf2[fn]:

                    if mf2[fn] != "" or fcmp(fn, mf1):

                        c.append(fn)

                del mf1[fn]

            else:

                a.append(fn)

        d = mf1.keys()

        for l in c, a, d, u: