# hgweb/hgweb_mod.py - Web interface for a repository.

#

# Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net>

# 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

import os.path

import mimetypes

from mercurial.demandload import demandload

demandload(globals(), "re zlib ConfigParser mimetools cStringIO sys tempfile")

demandload(globals(), "mercurial.hgweb.common:get_mtime,staticfile")

from mercurial.node import *

from mercurial.i18n import gettext as _

def _up(p):

    if p[0] != "/":

        p = "/" + p

    if p[-1] == "/":

        p = p[:-1]

    up = os.path.dirname(p)

    if up == "/":

        return "/"

    return up + "/"

class hgweb(object):

    def __init__(self, repo, name=None):

        if type(repo) == type(""):

            self.repo = hg.repository(ui.ui(), repo)

        else:

            self.repo = repo

        self.mtime = -1

        self.reponame = name

        self.archives = 'zip', 'gz', 'bz2'

        self.templatepath = self.repo.ui.config("web", "templates",

                                                templater.templatepath())

    def refresh(self):

        mtime = get_mtime(self.repo.root)

        if mtime != self.mtime:

            self.mtime = mtime

            self.repo = hg.repository(self.repo.ui, self.repo.root)

            self.maxchanges = int(self.repo.ui.config("web", "maxchanges", 10))

            self.maxfiles = int(self.repo.ui.config("web", "maxfiles", 10))

            self.allowpull = self.repo.ui.configbool("web", "allowpull", True)

    def archivelist(self, nodeid):

        allowed = self.repo.ui.configlist("web", "allow_archive")

        for i in self.archives:

            if i in allowed or self.repo.ui.configbool("web", "allow" + i):

                yield {"type" : i, "node" : nodeid, "url": ""}

    def listfiles(self, files, mf):

        for f in files[:self.maxfiles]:

            yield self.t("filenodelink", node=hex(mf[f]), file=f)

        if len(files) > self.maxfiles:

            yield self.t("fileellipses")

    def listfilediffs(self, files, changeset):

        for f in files[:self.maxfiles]:

            yield self.t("filedifflink", node=hex(changeset), file=f)

        if len(files) > self.maxfiles:

            yield self.t("fileellipses")

    def siblings(self, siblings=[], rev=None, hiderev=None, **args):

        if not rev:

            rev = lambda x: ""

        siblings = [s for s in siblings if s != nullid]

        if len(siblings) == 1 and rev(siblings[0]) == hiderev:

            return

        for s in siblings:

            yield dict(node=hex(s), rev=rev(s), **args)

    def renamelink(self, fl, node):

        r = fl.renamed(node)

        if r:

            return [dict(file=r[0], node=hex(r[1]))]

        return []

    def showtag(self, t1, node=nullid, **args):

        for t in self.repo.nodetags(node):

             yield self.t(t1, tag=t, **args)

    def diff(self, node1, node2, files):

        def filterfiles(filters, files):

            l = [x for x in files if x in filters]

            for t in filters:

                if t and t[-1] != os.sep:

                    t += os.sep

                l += [x for x in files if x.startswith(t)]

            return l

        parity = [0]

        def diffblock(diff, f, fn):

            yield self.t("diffblock",

                         lines=prettyprintlines(diff),

                         parity=parity[0],

                         file=f,

                         filenode=hex(fn or nullid))

            parity[0] = 1 - parity[0]

        def prettyprintlines(diff):

            for l in diff.splitlines(1):

                if l.startswith('+'):

                    yield self.t("difflineplus", line=l)

                elif l.startswith('-'):

                    yield self.t("difflineminus", line=l)

                elif l.startswith('@'):

                    yield self.t("difflineat", line=l)

                else:

                    yield self.t("diffline", line=l)

        r = self.repo

        cl = r.changelog

        mf = r.manifest

        change1 = cl.read(node1)

        change2 = cl.read(node2)

        mmap1 = mf.read(change1[0])

        mmap2 = mf.read(change2[0])

        date1 = util.datestr(change1[2])

        date2 = util.datestr(change2[2])

        modified, added, removed, deleted, unknown = r.changes(node1, node2)

        if files:

            modified, added, removed = map(lambda x: filterfiles(files, x),

                                           (modified, added, removed))

        diffopts = self.repo.ui.diffopts()

        showfunc = diffopts['showfunc']

        ignorews = diffopts['ignorews']

        ignorewsamount = diffopts['ignorewsamount']

        ignoreblanklines = diffopts['ignoreblanklines']

        for f in modified:

            to = r.file(f).read(mmap1[f])

            tn = r.file(f).read(mmap2[f])

            yield diffblock(mdiff.unidiff(to, date1, tn, date2, f,

                            showfunc=showfunc, ignorews=ignorews,

                            ignorewsamount=ignorewsamount,

                            ignoreblanklines=ignoreblanklines), f, tn)

        for f in added:

            to = None

            tn = r.file(f).read(mmap2[f])

            yield diffblock(mdiff.unidiff(to, date1, tn, date2, f,

                            showfunc=showfunc, ignorews=ignorews,

                            ignorewsamount=ignorewsamount,

                            ignoreblanklines=ignoreblanklines), f, tn)

        for f in removed:

            to = r.file(f).read(mmap1[f])

            tn = None

            yield diffblock(mdiff.unidiff(to, date1, tn, date2, f,

                            showfunc=showfunc, ignorews=ignorews,

                            ignorewsamount=ignorewsamount,

                            ignoreblanklines=ignoreblanklines), f, tn)

    def changelog(self, pos):

        def changenav(**map):

            def seq(factor, maxchanges=None):

                if maxchanges:

                    yield maxchanges

                    if maxchanges >= 20 and maxchanges <= 40:

                        yield 50

                else:

                    yield 1 * factor

                    yield 3 * factor

                for f in seq(factor * 10):

                    yield f

            l = []

            last = 0

            for f in seq(1, self.maxchanges):

                if f < self.maxchanges or f <= last:

                    continue

                if f > count:

                    break

                last = f

                r = "%d" % f

                if pos + f < count:

                    l.append(("+" + r, pos + f))

                if pos - f >= 0:

                    l.insert(0, ("-" + r, pos - f))

            yield {"rev": 0, "label": "(0)"}

            for label, rev in l:

                yield {"label": label, "rev": rev}

            yield {"label": "tip", "rev": "tip"}

        def changelist(**map):

            parity = (start - end) & 1

            cl = self.repo.changelog

            l = [] # build a list in forward order for efficiency

            for i in range(start, end):

                n = cl.node(i)

                changes = cl.read(n)

                hn = hex(n)

                l.insert(0, {"parity": parity,

                             "author": changes[1],

                             "parent": self.siblings(cl.parents(n), cl.rev,

                                                     cl.rev(n) - 1),

                             "child": self.siblings(cl.children(n), cl.rev,

                                                    cl.rev(n) + 1),

                             "changelogtag": self.showtag("changelogtag",n),

                             "manifest": hex(changes[0]),

                             "desc": changes[4],

                             "date": changes[2],

                             "files": self.listfilediffs(changes[3], n),

                             "rev": i,

                             "node": hn})

                parity = 1 - parity

            for e in l:

                yield e

        cl = self.repo.changelog

        mf = cl.read(cl.tip())[0]

        count = cl.count()

        start = max(0, pos - self.maxchanges + 1)

        end = min(count, start + self.maxchanges)

        pos = end - 1

        yield self.t('changelog',

                     changenav=changenav,

                     manifest=hex(mf),

                     rev=pos, changesets=count, entries=changelist,

                     archives=self.archivelist("tip"))

    def search(self, query):

        def changelist(**map):

            cl = self.repo.changelog

            count = 0

            qw = query.lower().split()

            def revgen():

                for i in range(cl.count() - 1, 0, -100):

                    l = []

                    for j in range(max(0, i - 100), i):

                        n = cl.node(j)

                        changes = cl.read(n)

                        l.append((n, j, changes))

                    l.reverse()

                    for e in l:

                        yield e

            for n, i, changes in revgen():

                miss = 0

                for q in qw:

                    if not (q in changes[1].lower() or

                            q in changes[4].lower() or

                            q in " ".join(changes[3][:20]).lower()):

                        miss = 1

                        break

                if miss:

                    continue

                count += 1

                hn = hex(n)

                yield self.t('searchentry',

                             parity=count & 1,

                             author=changes[1],

                             parent=self.siblings(cl.parents(n), cl.rev),

                             child=self.siblings(cl.children(n), cl.rev),

                             changelogtag=self.showtag("changelogtag",n),

                             manifest=hex(changes[0]),

                             desc=changes[4],

                             date=changes[2],

                             files=self.listfilediffs(changes[3], n),

                             rev=i,

                             node=hn)

                if count >= self.maxchanges:

                    break

        cl = self.repo.changelog

        mf = cl.read(cl.tip())[0]

        yield self.t('search',

                     query=query,

                     manifest=hex(mf),

                     entries=changelist)

    def changeset(self, nodeid):

        cl = self.repo.changelog

        n = self.repo.lookup(nodeid)

        nodeid = hex(n)

        changes = cl.read(n)

        p1 = cl.parents(n)[0]

        files = []

        mf = self.repo.manifest.read(changes[0])

        for f in changes[3]:

            files.append(self.t("filenodelink",

                                filenode=hex(mf.get(f, nullid)), file=f))

        def diff(**map):

            yield self.diff(p1, n, None)

        yield self.t('changeset',

                     diff=diff,

                     rev=cl.rev(n),

                     node=nodeid,

                     parent=self.siblings(cl.parents(n), cl.rev),

                     child=self.siblings(cl.children(n), cl.rev),

                     changesettag=self.showtag("changesettag",n),

                     manifest=hex(changes[0]),

                     author=changes[1],

                     desc=changes[4],

                     date=changes[2],

                     files=files,

                     archives=self.archivelist(nodeid))

    def filelog(self, f, filenode):

        cl = self.repo.changelog

        fl = self.repo.file(f)

        filenode = hex(fl.lookup(filenode))

        count = fl.count()

        def entries(**map):

            l = []

            parity = (count - 1) & 1

            for i in range(count):

                n = fl.node(i)

                lr = fl.linkrev(n)

                cn = cl.node(lr)

                cs = cl.read(cl.node(lr))

                l.insert(0, {"parity": parity,

                             "filenode": hex(n),

                             "filerev": i,

                             "file": f,

                             "node": hex(cn),

                             "author": cs[1],

                             "date": cs[2],

                             "rename": self.renamelink(fl, n),

                             "parent": self.siblings(fl.parents(n),

                                                     fl.rev, file=f),

                             "child": self.siblings(fl.children(n),

                                                    fl.rev, file=f),

                             "desc": cs[4]})

                parity = 1 - parity

            for e in l:

                yield e

        yield self.t("filelog", file=f, filenode=filenode, entries=entries)

    def filerevision(self, f, node):

        fl = self.repo.file(f)

        n = fl.lookup(node)

        node = hex(n)

        text = fl.read(n)

        changerev = fl.linkrev(n)

        cl = self.repo.changelog

        cn = cl.node(changerev)

        cs = cl.read(cn)

        mfn = cs[0]

        mt = mimetypes.guess_type(f)[0]

        rawtext = text

        if util.binary(text):

            mt = mt or 'application/octet-stream'

            text = "(binary:%s)" % mt

        mt = mt or 'text/plain'

        def lines():

            for l, t in enumerate(text.splitlines(1)):

                yield {"line": t,

                       "linenumber": "% 6d" % (l + 1),

                       "parity": l & 1}

        yield self.t("filerevision",

                     file=f,

                     filenode=node,

                     path=_up(f),

                     text=lines(),

                     raw=rawtext,

                     mimetype=mt,

                     rev=changerev,

                     node=hex(cn),

                     manifest=hex(mfn),

                     author=cs[1],

                     date=cs[2],

                     parent=self.siblings(fl.parents(n), fl.rev, file=f),

                     child=self.siblings(fl.children(n), fl.rev, file=f),

                     rename=self.renamelink(fl, n),

                     permissions=self.repo.manifest.readflags(mfn)[f])

    def fileannotate(self, f, node):

        bcache = {}

        ncache = {}

        fl = self.repo.file(f)

        n = fl.lookup(node)

        node = hex(n)

        changerev = fl.linkrev(n)

        cl = self.repo.changelog

        cn = cl.node(changerev)

        cs = cl.read(cn)

        mfn = cs[0]

        def annotate(**map):

            parity = 1

            last = None

            for r, l in fl.annotate(n):

                try:

                    cnode = ncache[r]

                except KeyError:

                    cnode = ncache[r] = self.repo.changelog.node(r)

                try:

                    name = bcache[r]

                except KeyError:

                    cl = self.repo.changelog.read(cnode)

                    bcache[r] = name = self.repo.ui.shortuser(cl[1])

                if last != cnode:

                    parity = 1 - parity

                    last = cnode

                yield {"parity": parity,

                       "node": hex(cnode),

                       "rev": r,

                       "author": name,

                       "file": f,

                       "line": l}

        yield self.t("fileannotate",

                     file=f,

                     filenode=node,

                     annotate=annotate,

                     path=_up(f),

                     rev=changerev,

                     node=hex(cn),

                     manifest=hex(mfn),

                     author=cs[1],

                     date=cs[2],

                     rename=self.renamelink(fl, n),

                     parent=self.siblings(fl.parents(n), fl.rev, file=f),

                     child=self.siblings(fl.children(n), fl.rev, file=f),

                     permissions=self.repo.manifest.readflags(mfn)[f])

    def manifest(self, mnode, path):

        man = self.repo.manifest

        mn = man.lookup(mnode)

        mnode = hex(mn)

        mf = man.read(mn)

        rev = man.rev(mn)

        changerev = man.linkrev(mn)

        node = self.repo.changelog.node(changerev)

        mff = man.readflags(mn)

        files = {}

        p = path[1:]

        if p and p[-1] != "/":

            p += "/"

        l = len(p)

        for f,n in mf.items():

            if f[:l] != p:

                continue

            remain = f[l:]

            if "/" in remain:

                short = remain[:remain.index("/") + 1] # bleah

                files[short] = (f, None)

            else:

                short = os.path.basename(remain)

                files[short] = (f, n)

        def filelist(**map):