hgweb: return content iterator instead of using write() callable

mercurial/hgweb/hgweb_mod.py

@@ -1,376 +1,376 b''
 # hgweb/hgweb_mod.py - Web interface for a repository.
 #
 # Copyright 21 May 2005 - (c) 2005 Jake Edge <[e-mail]>
 # Copyright 2005-2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 import os, mimetypes
 from mercurial.node import hex, nullid
 from mercurial.repo import RepoError
 from mercurial import mdiff, ui, hg, util, patch, hook
 from mercurial import revlog, templater, templatefilters
 from common import get_mtime, style_map, paritygen, countgen, ErrorResponse
 from common import HTTP_OK, HTTP_BAD_REQUEST, HTTP_NOT_FOUND, HTTP_SERVER_ERROR
 from request import wsgirequest
 import webcommands, protocol, webutil
 
 perms = {
     'changegroup': 'pull',
     'changegroupsubset': 'pull',
     'unbundle': 'push',
     'stream_out': 'pull',
 }
 
 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)
         return self.run_wsgi(req)
 
     def run_wsgi(self, req):
 
         self.refresh()
 
         # process this if it's a protocol request
         # protocol bits don't need to create any URLs
         # and the clients always use the old URL structure
 
         cmd = req.form.get('cmd', [''])[0]
         if cmd and cmd in protocol.__all__:
             if cmd in perms and not self.check_perm(req, perms[cmd]):
                 return []
             method = getattr(protocol, cmd)
             return method(self.repo, req)
 
         # 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 'REPO_NAME' in req.env:
             req.url += req.env['REPO_NAME'] + '/'
 
         if 'PATH_INFO' in req.env:
             parts = req.env['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):
                 req.form['cmd'] = [cmd]
             else:
                 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_]
 
         # process the web interface request
 
         try:
 
             tmpl = self.templater(req)
             ctype = tmpl('mimetype', encoding=self.encoding)
             ctype = templater.stringify(ctype)
 
             if cmd == '':
                 req.form['cmd'] = [tmpl.cache['default']]
                 cmd = req.form['cmd'][0]
 
             if cmd not in webcommands.__all__:
                 msg = 'no such method: %s' % cmd
                 raise ErrorResponse(HTTP_BAD_REQUEST, msg)
             elif cmd == 'file' and 'raw' in req.form.get('style', []):
                 self.ctype = ctype
                 content = webcommands.rawfile(self, req, tmpl)
             else:
                 content = getattr(webcommands, cmd)(self, req, tmpl)
                 req.respond(HTTP_OK, ctype)
 
             req.write(content)
             del tmpl
-            return req
+            return ''.join(content),
 
         except revlog.LookupError, err:
             req.respond(HTTP_NOT_FOUND, ctype)
             msg = str(err)
             if 'manifest' not in msg:
                 msg = 'revision not found: %s' % err.name
-            req.write(tmpl('error', error=msg))
+            return ''.join(tmpl('error', error=msg)),
         except (RepoError, revlog.RevlogError), inst:
             req.respond(HTTP_SERVER_ERROR, ctype)
-            req.write(tmpl('error', error=str(inst)))
+            return ''.join(tmpl('error', error=str(inst))),
         except ErrorResponse, inst:
             req.respond(inst.code, ctype)
-            req.write(tmpl('error', error=inst.message))
+            return ''.join(tmpl('error', error=inst.message)),
 
     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):
             yield tmpl('header', encoding=self.encoding, **map)
 
         def footer(**map):
             yield tmpl("footer", **map)
 
         def motd(**map):
             yield self.config("web", "motd", "")
 
         def sessionvars(**map):
             fields = []
             if 'style' in req.form:
                 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 'style' in req.form:
             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, templatefilters.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 diff(self, tmpl, 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 = paritygen(self.stripecount)
         def diffblock(diff, f, fn):
             yield tmpl("diffblock",
                        lines=prettyprintlines(diff),
                        parity=parity.next(),
                        file=f,
                        filenode=hex(fn or nullid))
 
         blockcount = countgen()
         def prettyprintlines(diff):
             blockno = blockcount.next()
             for lineno, l in enumerate(diff.splitlines(1)):
                 if blockno == 0:
                     lineno = lineno + 1
                 else:
                     lineno = "%d.%d" % (blockno, lineno + 1)
                 if l.startswith('+'):
                     ltype = "difflineplus"
                 elif l.startswith('-'):
                     ltype = "difflineminus"
                 elif l.startswith('@'):
                     ltype = "difflineat"
                 else:
                     ltype = "diffline"
                 yield tmpl(ltype,
                            line=l,
                            lineid="l%s" % lineno,
                            linenumber="% 8s" % lineno)
 
         r = self.repo
         c1 = r[node1]
         c2 = r[node2]
         date1 = util.datestr(c1.date())
         date2 = util.datestr(c2.date())
 
         modified, added, removed, deleted, unknown = r.status(node1, node2)[:5]
         if files:
             modified, added, removed = map(lambda x: filterfiles(files, x),
                                            (modified, added, removed))
 
         diffopts = patch.diffopts(self.repo.ui, untrusted=True)
         for f in modified:
             to = c1.filectx(f).data()
             tn = c2.filectx(f).data()
             yield diffblock(mdiff.unidiff(to, date1, tn, date2, f, f,
                                           opts=diffopts), f, tn)
         for f in added:
             to = None
             tn = c2.filectx(f).data()
             yield diffblock(mdiff.unidiff(to, date1, tn, date2, f, f,
                                           opts=diffopts), f, tn)
         for f in removed:
             to = c1.filectx(f).data()
             tn = None
             yield diffblock(mdiff.unidiff(to, date1, tn, date2, f, f,
                                           opts=diffopts), f, tn)
 
     archive_specs = {
         'bz2': ('application/x-tar', 'tbz2', '.tar.bz2', None),
         'gz': ('application/x-tar', 'tgz', '.tar.gz', None),
         'zip': ('application/zip', 'zip', '.zip', None),
         }
 
     def check_perm(self, req, op):
         '''Check permission for operation based on request data (including
         authentication info. Return true if op allowed, else false.'''
 
         def error(status, message):
             req.respond(status, protocol.HGTYPE)
             req.write('0\n%s\n' % message)
 
         if op == 'pull':
             return self.allowpull
 
         # enforce that you can only push using POST requests
         if req.env['REQUEST_METHOD'] != 'POST':
             error('405 Method Not Allowed', 'push requires POST request')
             return False
 
         # require ssl by default for pushing, auth info cannot be sniffed
         # and replayed
         scheme = req.env.get('wsgi.url_scheme')
         if self.configbool('web', 'push_ssl', True) and scheme != 'https':
             error(HTTP_OK, 'ssl required')
             return False
 
         user = req.env.get('REMOTE_USER')
 
         deny = self.configlist('web', 'deny_push')
         if deny and (not user or deny == ['*'] or user in deny):
             error('401 Unauthorized', 'push not authorized')
             return False
 
         allow = self.configlist('web', 'allow_push')
         result = allow and (allow == ['*'] or user in allow)
         if not result:
             error('401 Unauthorized', 'push not authorized')
 
         return result

mercurial/hgweb/hgwebdir_mod.py

@@ -1,289 +1,284 b''
 # hgweb/hgwebdir_mod.py - Web interface for a directory of repositories.
 #
 # Copyright 21 May 2005 - (c) 2005 Jake Edge <[e-mail]>
 # Copyright 2005, 2006 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 import os
 from mercurial.i18n import gettext as _
 from mercurial.repo import RepoError
 from mercurial import ui, hg, util, templater, templatefilters
 from common import ErrorResponse, get_mtime, staticfile, style_map, paritygen,\
                    get_contact, HTTP_OK, HTTP_NOT_FOUND, HTTP_SERVER_ERROR
 from hgweb_mod import hgweb
 from request import wsgirequest
 
 # This is a stopgap
 class hgwebdir(object):
     def __init__(self, config, parentui=None):
         def cleannames(items):
             return util.sort([(util.pconvert(name).strip('/'), path)
                               for name, path in items])
 
         self.parentui = parentui or ui.ui(report_untrusted=False,
                                           interactive = False)
         self.motd = None
         self.style = None
         self.stripecount = None
         self.repos_sorted = ('name', False)
         self._baseurl = None
         if isinstance(config, (list, tuple)):
             self.repos = cleannames(config)
             self.repos_sorted = ('', False)
         elif isinstance(config, dict):
             self.repos = cleannames(config.items())
         else:
             if isinstance(config, util.configparser):
                 cp = config
             else:
                 cp = util.configparser()
                 cp.read(config)
             self.repos = []
             if cp.has_section('web'):
                 if cp.has_option('web', 'motd'):
                     self.motd = cp.get('web', 'motd')
                 if cp.has_option('web', 'style'):
                     self.style = cp.get('web', 'style')
                 if cp.has_option('web', 'stripes'):
                     self.stripecount = int(cp.get('web', 'stripes'))
                 if cp.has_option('web', 'baseurl'):
                     self._baseurl = cp.get('web', 'baseurl')
             if cp.has_section('paths'):
                 self.repos.extend(cleannames(cp.items('paths')))
             if cp.has_section('collections'):
                 for prefix, root in cp.items('collections'):
                     for path in util.walkrepos(root, followsym=True):
                         repo = os.path.normpath(path)
                         name = repo
                         if name.startswith(prefix):
                             name = name[len(prefix):]
                         self.repos.append((name.lstrip(os.sep), repo))
             self.repos.sort()
 
     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
+        return self.run_wsgi(req)
 
     def run_wsgi(self, req):
 
         try:
             try:
 
                 virtual = req.env.get("PATH_INFO", "").strip('/')
                 tmpl = self.templater(req)
                 ctype = tmpl('mimetype', encoding=util._encoding)
                 ctype = templater.stringify(ctype)
 
                 # a static file
                 if virtual.startswith('static/') or 'static' in req.form:
                     static = os.path.join(templater.templatepath(), 'static')
                     if virtual.startswith('static/'):
                         fname = virtual[7:]
                     else:
                         fname = req.form['static'][0]
-                    req.write(staticfile(static, fname, req))
-                    return
+                    return staticfile(static, fname, req),
 
                 # top-level index
                 elif not virtual:
                     req.respond(HTTP_OK, ctype)
-                    req.write(self.makeindex(req, tmpl))
-                    return
+                    return ''.join(self.makeindex(req, tmpl)),
 
                 # nested indexes and hgwebs
 
                 repos = dict(self.repos)
                 while virtual:
                     real = repos.get(virtual)
                     if real:
                         req.env['REPO_NAME'] = virtual
                         try:
                             repo = hg.repository(self.parentui, real)
-                            hgweb(repo).run_wsgi(req)
-                            return
+                            return hgweb(repo).run_wsgi(req)
                         except IOError, inst:
                             msg = inst.strerror
                             raise ErrorResponse(HTTP_SERVER_ERROR, msg)
                         except RepoError, inst:
                             raise ErrorResponse(HTTP_SERVER_ERROR, str(inst))
 
                     # browse subdirectories
                     subdir = virtual + '/'
                     if [r for r in repos if r.startswith(subdir)]:
                         req.respond(HTTP_OK, ctype)
-                        req.write(self.makeindex(req, tmpl, subdir))
-                        return
+                        return ''.join(self.makeindex(req, tmpl, subdir)),
 
                     up = virtual.rfind('/')
                     if up < 0:
                         break
                     virtual = virtual[:up]
 
                 # prefixes not found
                 req.respond(HTTP_NOT_FOUND, ctype)
-                req.write(tmpl("notfound", repo=virtual))
+                return ''.join(tmpl("notfound", repo=virtual)),
 
             except ErrorResponse, err:
                 req.respond(err.code, ctype)
-                req.write(tmpl('error', error=err.message or ''))
+                return ''.join(tmpl('error', error=err.message or '')),
         finally:
             tmpl = None
 
     def makeindex(self, req, tmpl, subdir=""):
 
         def archivelist(ui, nodeid, url):
             allowed = ui.configlist("web", "allow_archive", untrusted=True)
             for i in [('zip', '.zip'), ('gz', '.tar.gz'), ('bz2', '.tar.bz2')]:
                 if i[0] in allowed or ui.configbool("web", "allow" + i[0],
                                                     untrusted=True):
                     yield {"type" : i[0], "extension": i[1],
                            "node": nodeid, "url": url}
 
         def entries(sortcolumn="", descending=False, subdir="", **map):
             def sessionvars(**map):
                 fields = []
                 if 'style' in req.form:
                     style = req.form['style'][0]
                     if style != get('web', 'style', ''):
                         fields.append(('style', style))
 
                 separator = url[-1] == '?' and ';' or '?'
                 for name, value in fields:
                     yield dict(name=name, value=value, separator=separator)
                     separator = ';'
 
             rows = []
             parity = paritygen(self.stripecount)
             for name, path in self.repos:
                 if not name.startswith(subdir):
                     continue
                 name = name[len(subdir):]
 
                 u = ui.ui(parentui=self.parentui)
                 try:
                     u.readconfig(os.path.join(path, '.hg', 'hgrc'))
                 except Exception, e:
                     u.warn(_('error reading %s/.hg/hgrc: %s\n' % (path, e)))
                     continue
                 def get(section, name, default=None):
                     return u.config(section, name, default, untrusted=True)
 
                 if u.configbool("web", "hidden", untrusted=True):
                     continue
 
                 parts = [name]
                 if 'PATH_INFO' in req.env:
                     parts.insert(0, req.env['PATH_INFO'].rstrip('/'))
                 if req.env['SCRIPT_NAME']:
                     parts.insert(0, req.env['SCRIPT_NAME'])
                 url = ('/'.join(parts).replace("//", "/")) + '/'
 
                 # update time with local timezone
                 try:
                     d = (get_mtime(path), util.makedate()[1])
                 except OSError:
                     continue
 
                 contact = get_contact(get)
                 description = get("web", "description", "")
                 name = get("web", "name", name)
                 row = dict(contact=contact or "unknown",
                            contact_sort=contact.upper() or "unknown",
                            name=name,
                            name_sort=name,
                            url=url,
                            description=description or "unknown",
                            description_sort=description.upper() or "unknown",
                            lastchange=d,
                            lastchange_sort=d[1]-d[0],
                            sessionvars=sessionvars,
                            archives=archivelist(u, "tip", url))
                 if (not sortcolumn
                     or (sortcolumn, descending) == self.repos_sorted):
                     # fast path for unsorted output
                     row['parity'] = parity.next()
                     yield row
                 else:
                     rows.append((row["%s_sort" % sortcolumn], row))
             if rows:
                 rows.sort()
                 if descending:
                     rows.reverse()
                 for key, row in rows:
                     row['parity'] = parity.next()
                     yield row
 
         sortable = ["name", "description", "contact", "lastchange"]
         sortcolumn, descending = self.repos_sorted
         if 'sort' in req.form:
             sortcolumn = req.form['sort'][0]
             descending = sortcolumn.startswith('-')
             if descending:
                 sortcolumn = sortcolumn[1:]
             if sortcolumn not in sortable:
                 sortcolumn = ""
 
         sort = [("sort_%s" % column,
                  "%s%s" % ((not descending and column == sortcolumn)
                             and "-" or "", column))
                 for column in sortable]
 
         if self._baseurl is not None:
             req.env['SCRIPT_NAME'] = self._baseurl
 
         return tmpl("index", entries=entries, subdir=subdir,
                     sortcolumn=sortcolumn, descending=descending,
                     **dict(sort))
 
     def templater(self, req):
 
         def header(**map):
             yield tmpl('header', encoding=util._encoding, **map)
 
         def footer(**map):
             yield tmpl("footer", **map)
 
         def motd(**map):
             if self.motd is not None:
                 yield self.motd
             else:
                 yield config('web', 'motd', '')
 
         def config(section, name, default=None, untrusted=True):
             return self.parentui.config(section, name, default, untrusted)
 
         if self._baseurl is not None:
             req.env['SCRIPT_NAME'] = self._baseurl
 
         url = req.env.get('SCRIPT_NAME', '')
         if not url.endswith('/'):
             url += '/'
 
         staticurl = config('web', 'staticurl') or url + 'static/'
         if not staticurl.endswith('/'):
             staticurl += '/'
 
         style = self.style
         if style is None:
             style = config('web', 'style', '')
         if 'style' in req.form:
             style = req.form['style'][0]
         if self.stripecount is None:
             self.stripecount = int(config('web', 'stripes', 1))
         mapfile = style_map(templater.templatepath(), style)
         tmpl = templater.templater(mapfile, templatefilters.filters,
                                    defaults={"header": header,
                                              "footer": footer,
                                              "motd": motd,
                                              "url": url,
                                              "staticurl": staticurl})
         return tmpl

tests/test-hgweb-no-path-info

@@ -1,59 +1,61 b''
 #!/bin/sh
 # This tests if hgweb and hgwebdir still work if the REQUEST_URI variable is
 # no longer passed with the request. Instead, SCRIPT_NAME and PATH_INFO
 # should be used from d74fc8dec2b4 onward to route the request.
 
 mkdir repo
 cd repo
 hg init
 echo foo > bar
 hg add bar
 hg commit -m "test" -d "0 0" -u "Testing"
 hg tip
 
 cat > request.py <<EOF
 from mercurial.hgweb import hgweb, hgwebdir
 from StringIO import StringIO
 import os, sys
 
 errors = StringIO()
 input = StringIO()
 
 def startrsp(headers, data):
 	print '---- HEADERS'
 	print headers
 	print '---- DATA'
 	print data
 	return output.write
 
 env = {
 	'wsgi.version': (1, 0),
 	'wsgi.url_scheme': 'http',
 	'wsgi.errors': errors,
 	'wsgi.input': input,
 	'wsgi.multithread': False,
 	'wsgi.multiprocess': False,
 	'wsgi.run_once': False,
 	'REQUEST_METHOD': 'GET',
 	'SCRIPT_NAME': '',
 	'SERVER_NAME': '127.0.0.1',
 	'SERVER_PORT': os.environ['HGPORT'],
 	'SERVER_PROTOCOL': 'HTTP/1.0'
 }
 
 output = StringIO()
 env['QUERY_STRING'] = 'style=atom'
-hgweb('.', name = 'repo')(env, startrsp)
-print output.getvalue()
+content = hgweb('.', name = 'repo')(env, startrsp)
+sys.stdout.write(output.getvalue())
+sys.stdout.write(''.join(content))
 print '---- ERRORS'
 print errors.getvalue()
 
 output = StringIO()
 env['QUERY_STRING'] = 'style=raw'
-hgwebdir({'repo': '.'})(env, startrsp)
-print output.getvalue()
+content = hgwebdir({'repo': '.'})(env, startrsp)
+sys.stdout.write(output.getvalue())
+sys.stdout.write(''.join(content))
 print '---- ERRORS'
 print errors.getvalue()
 EOF
 
 python request.py | sed "s/http:\/\/127\.0\.0\.1:[0-9]*\//http:\/\/127.0.0.1\//"

tests/test-hgweb-no-path-info.out

@@ -1,50 +1,48 b''
 changeset:   0:4cbec7e6f8c4
 tag:         tip
 user:        Testing
 date:        Thu Jan 01 00:00:00 1970 +0000
 summary:     test
 
 ---- HEADERS
 200 Script output follows
 ---- DATA
 [('Content-Type', 'application/atom+xml; charset=ascii')]
 <?xml version="1.0" encoding="ascii"?>
 <feed xmlns="http://www.w3.org/2005/Atom">
  <!-- Changelog -->
  <id>http://127.0.0.1/</id>
  <link rel="self" href="http://127.0.0.1/atom-log"/>
  <link rel="alternate" href="http://127.0.0.1/"/>
  <title>repo Changelog</title>
  <updated>1970-01-01T00:00:00+00:00</updated>
 
  <entry>
   <title>test</title>
   <id>http://www.selenic.com/mercurial/#changeset-4cbec7e6f8c42eb52b6b52670e1f7560ae9a101e</id>
   <link href="http://127.0.0.1/rev/4cbec7e6f8c42eb52b6b52670e1f7560ae9a101e"/>
   <author>
    <name>Testing</name>
    <email>&#84;&#101;&#115;&#116;&#105;&#110;&#103;</email>
   </author>
   <updated>1970-01-01T00:00:00+00:00</updated>
   <published>1970-01-01T00:00:00+00:00</published>
   <content type="xhtml">
    <div xmlns="http://www.w3.org/1999/xhtml">
     <pre xml:space="preserve">test</pre>
    </div>
   </content>
  </entry>
 
 </feed>
-
 ---- ERRORS
 
 ---- HEADERS
 200 Script output follows
 ---- DATA
 [('Content-Type', 'text/plain; charset=ascii')]
 
 repo/
 
-
 ---- ERRORS
 

tests/test-hgweb-no-request-uri

@@ -1,77 +1,81 b''
 #!/bin/sh
 # This tests if hgweb and hgwebdir still work if the REQUEST_URI variable is
 # no longer passed with the request. Instead, SCRIPT_NAME and PATH_INFO
 # should be used from d74fc8dec2b4 onward to route the request.
 
 mkdir repo
 cd repo
 hg init
 echo foo > bar
 hg add bar
 hg commit -m "test" -d "0 0" -u "Testing"
 hg tip
 
 cat > request.py <<EOF
 from mercurial.hgweb import hgweb, hgwebdir
 from StringIO import StringIO
 import os, sys
 
 errors = StringIO()
 input = StringIO()
 
 def startrsp(headers, data):
 	print '---- HEADERS'
 	print headers
 	print '---- DATA'
 	print data
 	return output.write
 
 env = {
 	'wsgi.version': (1, 0),
 	'wsgi.url_scheme': 'http',
 	'wsgi.errors': errors,
 	'wsgi.input': input,
 	'wsgi.multithread': False,
 	'wsgi.multiprocess': False,
 	'wsgi.run_once': False,
 	'REQUEST_METHOD': 'GET',
 	'SCRIPT_NAME': '',
 	'SERVER_NAME': '127.0.0.1',
 	'SERVER_PORT': os.environ['HGPORT'],
 	'SERVER_PROTOCOL': 'HTTP/1.0'
 }
 
 output = StringIO()
 env['PATH_INFO'] = '/'
 env['QUERY_STRING'] = 'style=atom'
-hgweb('.', name = 'repo')(env, startrsp)
-print output.getvalue()
+content = hgweb('.', name = 'repo')(env, startrsp)
+sys.stdout.write(output.getvalue())
+sys.stdout.write(''.join(content))
 print '---- ERRORS'
 print errors.getvalue()
 
 output = StringIO()
 env['PATH_INFO'] = '/file/tip/'
 env['QUERY_STRING'] = 'style=raw'
-hgweb('.', name = 'repo')(env, startrsp)
-print output.getvalue()
+content = hgweb('.', name = 'repo')(env, startrsp)
+sys.stdout.write(output.getvalue())
+sys.stdout.write(''.join(content))
 print '---- ERRORS'
 print errors.getvalue()
 
 output = StringIO()
 env['PATH_INFO'] = '/'
 env['QUERY_STRING'] = 'style=raw'
-hgwebdir({'repo': '.'})(env, startrsp)
-print output.getvalue()
+content = hgwebdir({'repo': '.'})(env, startrsp)
+sys.stdout.write(output.getvalue())
+sys.stdout.write(''.join(content))
 print '---- ERRORS'
 print errors.getvalue()
 
 output = StringIO()
 env['PATH_INFO'] = '/repo/file/tip/'
 env['QUERY_STRING'] = 'style=raw'
-hgwebdir({'repo': '.'})(env, startrsp)
-print output.getvalue()
+content = hgwebdir({'repo': '.'})(env, startrsp)
+sys.stdout.write(output.getvalue())
+sys.stdout.write(''.join(content))
 print '---- ERRORS'
 print errors.getvalue()
 EOF
 
 python request.py | sed "s/http:\/\/127\.0\.0\.1:[0-9]*\//http:\/\/127.0.0.1\//"

tests/test-hgweb-no-request-uri.out

@@ -1,72 +1,68 b''
 changeset:   0:4cbec7e6f8c4
 tag:         tip
 user:        Testing
 date:        Thu Jan 01 00:00:00 1970 +0000
 summary:     test
 
 ---- HEADERS
 200 Script output follows
 ---- DATA
 [('Content-Type', 'application/atom+xml; charset=ascii')]
 <?xml version="1.0" encoding="ascii"?>
 <feed xmlns="http://www.w3.org/2005/Atom">
  <!-- Changelog -->
  <id>http://127.0.0.1/</id>
  <link rel="self" href="http://127.0.0.1/atom-log"/>
  <link rel="alternate" href="http://127.0.0.1/"/>
  <title>repo Changelog</title>
  <updated>1970-01-01T00:00:00+00:00</updated>
 
  <entry>
   <title>test</title>
   <id>http://www.selenic.com/mercurial/#changeset-4cbec7e6f8c42eb52b6b52670e1f7560ae9a101e</id>
   <link href="http://127.0.0.1/rev/4cbec7e6f8c42eb52b6b52670e1f7560ae9a101e"/>
   <author>
    <name>Testing</name>
    <email>&#84;&#101;&#115;&#116;&#105;&#110;&#103;</email>
   </author>
   <updated>1970-01-01T00:00:00+00:00</updated>
   <published>1970-01-01T00:00:00+00:00</published>
   <content type="xhtml">
    <div xmlns="http://www.w3.org/1999/xhtml">
     <pre xml:space="preserve">test</pre>
    </div>
   </content>
  </entry>
 
 </feed>
+---- ERRORS
+
+---- HEADERS
+200 Script output follows
+---- DATA
+[('Content-Type', 'text/plain; charset=ascii')]
+
+-rw-r--r-- 4 bar
+
+
+---- ERRORS
+
+---- HEADERS
+200 Script output follows
+---- DATA
+[('Content-Type', 'text/plain; charset=ascii')]
+
+/repo/
 
 ---- ERRORS
 
 ---- HEADERS
 200 Script output follows
 ---- DATA
 [('Content-Type', 'text/plain; charset=ascii')]
 
 -rw-r--r-- 4 bar
 
 
-
 ---- ERRORS
 
----- HEADERS
-200 Script output follows
----- DATA
-[('Content-Type', 'text/plain; charset=ascii')]
-
-/repo/
-
-
----- ERRORS
-
----- HEADERS
-200 Script output follows
----- DATA
-[('Content-Type', 'text/plain; charset=ascii')]
-
--rw-r--r-- 4 bar
-
-
-
----- ERRORS
-