gminick / sphinx-gsoc2009 / changeset / ae72a8b254e8

Up to file-list sphinx/builders/webapp/webapp.py:

@@ -101,10 +101,12 @@ class WebAppBuilder(SerializingHTMLBuild
             except Exception, err:
                 raise SphinxError(err)
         src_dir = path.join(path.dirname(__file__), '../../themes/basic/static')
         dst_dir = path.join(self.outdir, 'public/_static')
         shutil.copytree(src_dir, dst_dir)
         sphinx_dirs = (('../../themes/basic/static', 'public/_static'),
                        ('../../themes', 'themes'))
         for sdir in sphinx_dirs:
             src_dir = path.join(path.dirname(__file__), sdir[0])
             dst_dir = path.join(self.outdir, sdir[1])
             shutil.copytree(src_dir, dst_dir)
     ###
     ### Xapian search engine

Up to file-list sphinx/web/middleware/appserver.py:

     :license: BSD, see LICENSE for details.
 """
 import json
 try:
     import json
 except ImportError:
     try:
         import simplejson as json
     except ImportError:
         raise ImportError('json module not found')
 import os
 import time
 import locale
 import cPickle
 from os import path
 from hashlib import md5
 from difflib import Differ
 from jinja2 import Environment, FileSystemLoader, Template
 from webob import Request, Response
-from sphinx.application import TemplateBridge
+from sphinx.application import TemplateBridge, Sphinx
 from sphinx.environment import BuildEnvironment
 from sphinx.errors import SphinxError
 from sphinx.highlighting import PygmentsBridge
 from sphinx.jinja2glue import BuiltinTemplateLoader
 from sphinx.theming import Theme
 from sphinx.builders.html import StandaloneHTMLBuilder
 from sphinx.util import relative_uri
 from sphinx.writers.html import HTMLTranslator
 # it's here only temporarily, until I get all the theming problems resolved
 tmp_template = """
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 <link rel="stylesheet" href="_static/basic.css" type="text/css" />
 <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
 <script type="text/javascript">
     var DOCUMENTATION_OPTIONS = {
        URL_ROOT:    '',
        VERSION:     '0.5.2',
        COLLAPSE_MODINDEX: false,
        FILE_SUFFIX: '.html',
        HAS_SOURCE:  true
     };
 </script>
 <script type="text/javascript" src="_static/jquery.js"></script>
 <script type="text/javascript" src="_static/jquery.form.js"></script>
 <script type="text/javascript" src="_static/comments.js"></script>
 <script type="text/javascript" src="_static/doctools.js"></script>
 </head>
 <body>
 {{ body }}
 </body>
 </html>
 {%% extends "basic/layout.html" %%}
 {%% block body %%} %(body)s {%% endblock %%}
 """
 def load_comments(db_path):
     """Open a 'db_path' file, dejsonify the loaded data and return it.
     On error return empty list."""
@@ -154,6 +147,63 @@ def get_sorted_by_thread(data):
     return comments_sorted
 class SinglefileHTMLBuilder(StandaloneHTMLBuilder, Sphinx):
     """Render a file when requested using data from a pickled archive.
     Handle theming."""
     def __init__(self, www_dir):
         self.outdir = www_dir
         try:
             w = open(path.join(self.outdir, 'globalcontext.pickle'))
             self.globalcontext = cPickle.load(w)
             w.close()
         except Exception, err:
             raise SphinxError(err)
         self.cwd = os.getcwd()
         self.srcdir = self.cwd
         self.confdir = self.cwd
         self.doctreedir = path.join(self.cwd, www_dir)
         self.env = None
         self.freshenv = None
 #        self.config = {}
 #        self.env = BuildEnvironment.frompickle(self.config, self.envdir)
 #        self.config = self.env.config
         confdir = path.join(self.cwd, '../../')
         self.app = Sphinx(self.srcdir, confdir, '.', 'public', 'html', {}, None)
         self.info = self.app.info
         self.warn = self.app.warn
         self.config = self.app.config
         self.config.html_theme_path = 'themes/' + self.config.html_theme
         self.load_i18n()
         self.load_env()
         StandaloneHTMLBuilder.init(self)
         self.style = self.theme.get_confstr('theme', 'stylesheet')
     def render_file(self, filename, ctx):
         ctx.update(self.globalcontext.copy())
         # current_page_name is backwards compatibility
         ctx['pagename'] = ctx['current_page_name'] = filename
         def pathto(otheruri, resource=False,
                    baseuri=self.get_target_uri(filename)):
             if not resource:
                 otheruri = self.get_target_uri(otheruri)
             return relative_uri(baseuri, otheruri)
         ctx['pathto'] = pathto
         ctx['hasdoc'] = lambda name: name in self.env.all_docs
         pgname = path.basename(filename).split('.')[0]
         ctx['customsidebar'] = self.config.html_sidebars.get(pgname)
         ctx['encoding'] = encoding = self.config.html_output_encoding
         ctx['toctree'] = lambda **kw: self._get_local_toctree(filename, **kw)
         ctx['style'] = self.style
         return self.templates.render_string(tmp_template % (ctx), ctx)
 class AppServer(object):
     """This middleware is responsible for serving the docs (the docs are
     pickled files, so it has to load a file from a pickle) and for handling
@@ -165,6 +215,7 @@ class AppServer(object):
         self.www_dir = www_dir
         self.template_vals = {}
         self.htmlbuilder = SinglefileHTMLBuilder(self.www_dir)
         self.init_templates()
         # an argument for 'reverse' option of sorted function:
@@ -197,21 +248,7 @@ class AppServer(object):
         elif SW('/fixes/'):
             resp = self.doReadFixes(req, resp)
         elif req.path.endswith('.html'):
             file_path = self.constructPath(req)
             try:
                 if file_path.endswith('.pkl'):
                     file_contents = cPickle.loads(open(file_path).read())['body']
                 else:
                     file_contents = open(file_path, 'rb').read()
             except:
                 file_contents = '<html><body>doHTMLFile(): 404!</body></html>'
             resp.status = 200
             resp.body = file_contents.encode('utf8')
             # Regular HTML file
             if req.path.endswith('.html'):
-                resp = self.doHTMLFile(req, resp)
+            resp = self.doHTMLFile(req, resp)
         else:
             return self.app(environ, start_response)
@@ -380,7 +417,21 @@ class AppServer(object):
         resp.content_type = 'text/html'
         resp.charset = 'utf8'
-        rendered = Template(tmp_template).render({'body': resp.body.decode('utf8')})
+        file_path = self.constructPath(req)
         try:
             if file_path.endswith('.pkl'):
                 file_contents = cPickle.loads(open(file_path).read())
             else:
                 file_contents = open(file_path, 'rb').read()
                 resp.body = file_contents.encode('utf8')
                 resp.status = 200
                 return resp
         except:
             file_contents = '<html><body>doHTMLFile(): 404!</body></html>'
             return resp
         resp.body = self.htmlbuilder.render_file(file_path,
                                                  file_contents).encode('utf8')
 #        html_code = unicode(file_contents,
 #                            locale.getpreferredencoding(), 'replace')
@@ -388,7 +439,8 @@ class AppServer(object):
 #        self.render_openid(environ)
 #        rendered = self.env.from_string(html_code).render(self.template_vals)
-        resp.body = rendered.encode('utf8')
+        #resp.body = rendered.encode('utf8')
         resp.status = 200
         return resp

commit 1569:	ae72a8b254e8
parent 1568:	413f8c6b53f2
branch:	default