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

#

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

# Copyright 2005-2007 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, mimetypes, re, mimetools, cStringIO

from mercurial.node import *

from mercurial import mdiff, ui, hg, util, archival, patch, hook

from mercurial import revlog, templater

from common import ErrorResponse, get_mtime, style_map, paritygen, get_contact

from request import wsgirequest

import webcommands, protocol

shortcuts = {

    'cl': [('cmd', ['changelog']), ('rev', None)],

    'sl': [('cmd', ['shortlog']), ('rev', None)],

    'cs': [('cmd', ['changeset']), ('node', None)],

    'f': [('cmd', ['file']), ('filenode', None)],

    'fl': [('cmd', ['filelog']), ('filenode', None)],

    'fd': [('cmd', ['filediff']), ('node', None)],

    'fa': [('cmd', ['annotate']), ('filenode', None)],

    'mf': [('cmd', ['manifest']), ('manifest', None)],

    'ca': [('cmd', ['archive']), ('node', None)],

    'tags': [('cmd', ['tags'])],

    'tip': [('cmd', ['changeset']), ('node', ['tip'])],

    'static': [('cmd', ['static']), ('file', None)]

}

def _up(p):

    if p[0] != "/":

        p = "/" + p

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

        p = p[:-1]

    up = os.path.dirname(p)

    if up == "/":

        return "/"

    return up + "/"

def revnavgen(pos, pagelen, limit, nodefunc):

    def seq(factor, limit=None):

        if limit:

            yield limit

            if limit >= 20 and limit <= 40:

                yield 50

        else:

            yield 1 * factor

            yield 3 * factor

        for f in seq(factor * 10):

            yield f

    def nav(**map):

        l = []

        last = 0

        for f in seq(1, pagelen):

            if f < pagelen or f <= last:

                continue

            if f > limit:

                break

            last = f

            if pos + f < limit:

                l.append(("+%d" % f, hex(nodefunc(pos + f).node())))

            if pos - f >= 0:

                l.insert(0, ("-%d" % f, hex(nodefunc(pos - f).node())))

        try:

            yield {"label": "(0)", "node": hex(nodefunc('0').node())}

            for label, node in l:

                yield {"label": label, "node": node}

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

        except hg.RepoError:

            pass

    return nav

class hgweb(object):

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

        if isinstance(repo, str):

            parentui = ui.ui(report_untrusted=False, interactive=False)

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

        else:

            self.repo = repo

        hook.redirect(True)

        self.mtime = -1

        self.reponame = name

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

        self.stripecount = 1

        # a repo owner may set web.templates in .hg/hgrc to get any file

        # readable by the user running the CGI script

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

                                        templater.templatepath(),

                                        untrusted=False)

    # The CGI scripts are often run by a user different from the repo owner.

    # Trust the settings from the .hg/hgrc files by default.

    def config(self, section, name, default=None, untrusted=True):

        return self.repo.ui.config(section, name, default,

                                   untrusted=untrusted)

    def configbool(self, section, name, default=False, untrusted=True):

        return self.repo.ui.configbool(section, name, default,

                                       untrusted=untrusted)

    def configlist(self, section, name, default=None, untrusted=True):

        return self.repo.ui.configlist(section, name, default,

                                       untrusted=untrusted)

    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.config("web", "maxchanges", 10))

            self.stripecount = int(self.config("web", "stripes", 1))

            self.maxshortchanges = int(self.config("web", "maxshortchanges", 60))

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

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

            self.encoding = self.config("web", "encoding", util._encoding)

    def run(self):

        if not os.environ.get('GATEWAY_INTERFACE', '').startswith("CGI/1."):

            raise RuntimeError("This function is only intended to be called while running as a CGI script.")

        import mercurial.hgweb.wsgicgi as wsgicgi

        wsgicgi.launch(self)

    def __call__(self, env, respond):

        req = wsgirequest(env, respond)

        self.run_wsgi(req)

        return req

    def run_wsgi(self, req):

        self.refresh()

        # expand form shortcuts

        for k in shortcuts.iterkeys():

            if k in req.form:

                for name, value in shortcuts[k]:

                    if value is None:

                        value = req.form[k]

                    req.form[name] = value

                del req.form[k]

        # work with CGI variables to create coherent structure

        # use SCRIPT_NAME, PATH_INFO and QUERY_STRING as well as our REPO_NAME

        req.url = req.env['SCRIPT_NAME']

        if not req.url.endswith('/'):

            req.url += '/'

        if req.env.has_key('REPO_NAME'):

            req.url += req.env['REPO_NAME'] + '/'

        if req.env.get('PATH_INFO'):

            parts = req.env.get('PATH_INFO').strip('/').split('/')

            repo_parts = req.env.get('REPO_NAME', '').split('/')

            if parts[:len(repo_parts)] == repo_parts:

                parts = parts[len(repo_parts):]

            query = '/'.join(parts)

        else:

            query = req.env['QUERY_STRING'].split('&', 1)[0]

            query = query.split(';', 1)[0]

        # translate user-visible url structure to internal structure

        args = query.split('/', 2)

        if 'cmd' not in req.form and args and args[0]:

            cmd = args.pop(0)

            style = cmd.rfind('-')

            if style != -1:

                req.form['style'] = [cmd[:style]]

                cmd = cmd[style+1:]

            # avoid accepting e.g. style parameter as command

            if hasattr(webcommands, cmd) or hasattr(protocol, cmd):

                req.form['cmd'] = [cmd]

            if args and args[0]:

                node = args.pop(0)

                req.form['node'] = [node]

            if args:

                req.form['file'] = args

            if cmd == 'static':

                req.form['file'] = req.form['node']

            elif cmd == 'archive':

                fn = req.form['node'][0]

                for type_, spec in self.archive_specs.iteritems():

                    ext = spec[2]

                    if fn.endswith(ext):

                        req.form['node'] = [fn[:-len(ext)]]

                        req.form['type'] = [type_]

        # actually process the request

        try:

            cmd = req.form.get('cmd', [''])[0]

            if hasattr(protocol, cmd):

                method = getattr(protocol, cmd)

                method(self, req)

            else:

                tmpl = self.templater(req)

                if cmd == '':

                    req.form['cmd'] = [tmpl.cache['default']]

                    cmd = req.form['cmd'][0]

                del tmpl

        except revlog.LookupError, err:

            req.respond(404, tmpl(

                        'error', error='revision not found: %s' % err.name))

        except (hg.RepoError, revlog.RevlogError), inst:

            req.respond('500 Internal Server Error',

                        tmpl('error', error=str(inst)))

        except ErrorResponse, inst:

            req.respond(inst.code, tmpl('error', error=inst.message))

        except AttributeError:

            req.respond(400, tmpl('error', error='No such method: ' + cmd))

    def templater(self, req):

        # determine scheme, port and server name

        # this is needed to create absolute urls

        proto = req.env.get('wsgi.url_scheme')

        if proto == 'https':

            proto = 'https'

            default_port = "443"

        else:

            proto = 'http'

            default_port = "80"

        port = req.env["SERVER_PORT"]

        port = port != default_port and (":" + port) or ""

        urlbase = '%s://%s%s' % (proto, req.env['SERVER_NAME'], port)

        staticurl = self.config("web", "staticurl") or req.url + 'static/'

        if not staticurl.endswith('/'):

            staticurl += '/'

        # some functions for the templater

        def header(**map):

            header_file = cStringIO.StringIO(

                ''.join(tmpl("header", encoding=self.encoding, **map)))

            msg = mimetools.Message(header_file, 0)

            req.header(msg.items())

            yield header_file.read()

        def footer(**map):

            yield tmpl("footer", **map)

        def motd(**map):

            yield self.config("web", "motd", "")

        def sessionvars(**map):

            fields = []

            if req.form.has_key('style'):

                style = req.form['style'][0]

                if style != self.config('web', 'style', ''):

                    fields.append(('style', style))

            separator = req.url[-1] == '?' and ';' or '?'

            for name, value in fields:

                yield dict(name=name, value=value, separator=separator)

                separator = ';'

        # figure out which style to use

        style = self.config("web", "style", "")

        if req.form.has_key('style'):

            style = req.form['style'][0]

        mapfile = style_map(self.templatepath, style)

        if not self.reponame:

            self.reponame = (self.config("web", "name")

                             or req.env.get('REPO_NAME')

                             or req.url.strip('/') or self.repo.root)

        # create the templater

        tmpl = templater.templater(mapfile, templater.common_filters,

                                   defaults={"url": req.url,

                                             "staticurl": staticurl,

                                             "urlbase": urlbase,

                                             "repo": self.reponame,

                                             "header": header,

                                             "footer": footer,

                                             "motd": motd,

                                             "sessionvars": sessionvars

                                            })

        return tmpl

    def archivelist(self, nodeid):

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

        for i, spec in self.archive_specs.iteritems():

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

                yield {"type" : i, "extension" : spec[2], "node" : nodeid}

    def listfilediffs(self, tmpl, files, changeset):

        for f in files[:self.maxfiles]:

            yield tmpl("filedifflink", node=hex(changeset), file=f)

        if len(files) > self.maxfiles:

            yield tmpl("fileellipses")

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

        siblings = [s for s in siblings if s.node() != nullid]

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

            return

        for s in siblings:

            d = {'node': hex(s.node()), 'rev': s.rev()}

            if hasattr(s, 'path'):

                d['file'] = s.path()

            d.update(args)

            yield d

    def renamelink(self, fl, node):

        r = fl.renamed(node)

        if r:

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

        return []

    def nodetagsdict(self, node):

        return [{"name": i} for i in self.repo.nodetags(node)]

    def nodebranchdict(self, ctx):

        branches = []

        branch = ctx.branch()

        # If this is an empty repo, ctx.node() == nullid,

        # ctx.branch() == 'default', but branchtags() is

        # an empty dict. Using dict.get avoids a traceback.

        if self.repo.branchtags().get(branch) == ctx.node():

            branches.append({"name": branch})

        return branches