mirror of
https://github.com/sphinx-doc/sphinx.git
synced 2025-02-25 18:55:22 -06:00
114 lines
3.8 KiB
Python
114 lines
3.8 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""
|
|
sphinx._jinja
|
|
~~~~~~~~~~~~~
|
|
|
|
Jinja glue.
|
|
|
|
:copyright: 2007-2008 by Georg Brandl, Horst Gutmann.
|
|
:license: BSD.
|
|
"""
|
|
|
|
import codecs
|
|
from os import path
|
|
|
|
from sphinx.util import mtimes_of_files
|
|
from sphinx.application import TemplateBridge
|
|
|
|
from jinja import Environment
|
|
from jinja.loaders import BaseLoader
|
|
from jinja.exceptions import TemplateNotFound
|
|
|
|
|
|
def babel_extract(fileobj, keywords, comment_tags, options):
|
|
"""
|
|
Simple extractor to get some basic Babel support.
|
|
"""
|
|
env = Environment()
|
|
for lineno, sg, pl in env.get_translations_for_string(fileobj.read()):
|
|
yield lineno, None, (sg, pl), ''
|
|
|
|
|
|
class SphinxFileSystemLoader(BaseLoader):
|
|
"""
|
|
A loader that loads templates either relative to one of a list of given
|
|
paths, or from an absolute path.
|
|
"""
|
|
|
|
def __init__(self, basepath, extpaths):
|
|
self.basepath = path.abspath(basepath)
|
|
self.extpaths = map(path.abspath, extpaths)
|
|
self.searchpaths = self.extpaths + [self.basepath]
|
|
|
|
def get_source(self, environment, name, parent):
|
|
name = name.replace('/', path.sep)
|
|
if name.startswith('!'):
|
|
name = name[1:]
|
|
if not path.exists(path.join(self.basepath, name)):
|
|
raise TemplateNotFound(name)
|
|
filename = path.join(self.basepath, name)
|
|
elif path.isabs(name):
|
|
if not path.exists(name):
|
|
raise TemplateNotFound(name)
|
|
filename = name
|
|
else:
|
|
for searchpath in self.searchpaths:
|
|
if path.exists(path.join(searchpath, name)):
|
|
filename = path.join(searchpath, name)
|
|
break
|
|
else:
|
|
raise TemplateNotFound(name)
|
|
f = codecs.open(filename, 'r', environment.template_charset)
|
|
try:
|
|
return f.read()
|
|
finally:
|
|
f.close()
|
|
|
|
|
|
class TranslatorEnvironment(Environment):
|
|
class _Translator(object):
|
|
def __init__(self, translator):
|
|
self.trans = translator
|
|
|
|
def gettext(self, string):
|
|
return self.trans.ugettext(string)
|
|
|
|
def ngettext(self, singular, plural, n):
|
|
return self.trans.ungettext(singular, plural, n)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
self.translator = kwargs['translator']
|
|
del kwargs['translator']
|
|
super(TranslatorEnvironment, self).__init__(*args, **kwargs)
|
|
|
|
def get_translator(self, context):
|
|
return TranslatorEnvironment._Translator(self.translator)
|
|
|
|
|
|
class BuiltinTemplates(TemplateBridge):
|
|
def init(self, builder):
|
|
self.templates = {}
|
|
base_templates_path = path.join(path.dirname(__file__), 'templates')
|
|
ext_templates_path = [path.join(builder.confdir, dir)
|
|
for dir in builder.config.templates_path]
|
|
self.templates_path = [base_templates_path] + ext_templates_path
|
|
loader = SphinxFileSystemLoader(base_templates_path, ext_templates_path)
|
|
if builder.translator is not None:
|
|
self.jinja_env = TranslatorEnvironment(loader=loader,
|
|
friendly_traceback=False, translator=builder.translator)
|
|
else:
|
|
self.jinja_env = Environment(loader=loader,
|
|
# disable traceback, more likely that something
|
|
# in the application is broken than in the templates
|
|
friendly_traceback=False)
|
|
|
|
def newest_template_mtime(self):
|
|
return max(mtimes_of_files(self.templates_path, '.html'))
|
|
|
|
def render(self, template, context):
|
|
if template in self.templates:
|
|
return self.templates[template].render(context)
|
|
templateobj = self.templates[template] = \
|
|
self.jinja_env.get_template(template)
|
|
return templateobj.render(context)
|