def load(self, source_dir):
"""Load the pod content from file system."""
timer = self.pod.profile.timer(
'RenderSitemapController.load',
label='{}'.format(self.serving_path),
meta=self.route_info.meta,
).start_timer()
source_dir = self.clean_source_dir(source_dir)
# Validate the path with the config filters.
self.validate_path()
try:
rendered_path = '{}{}'.format(source_dir, self.serving_path)
rendered_content = self.pod.read_file(rendered_path)
rendered_doc = rendered_document.RenderedDocument(
self.serving_path, rendered_content)
timer.stop_timer()
return rendered_doc
except Exception as err:
text = 'Error building {}: {}'
if self.pod:
self.pod.logger.exception(text.format(self, err))
exception = errors.BuildError(text.format(self, err))
exception.traceback = sys.exc_info()[2]
exception.controller = self
exception.exception = err
raise exception
def load(self, source_dir):
"""Load the pod content from file system."""
timer = self.pod.profile.timer(
'RenderDocumentController.load',
label='{} ({})'.format(self.doc.pod_path, self.doc.locale),
meta={
'path': self.doc.pod_path,
'locale': str(self.doc.locale)}
).start_timer()
source_dir = self.clean_source_dir(source_dir)
# Validate the path with the config filters.
self.validate_path()
try:
doc = self.doc
serving_path = doc.get_serving_path()
if serving_path.endswith('/'):
serving_path = '{}{}'.format(serving_path, self.suffix)
rendered_path = '{}{}'.format(source_dir, serving_path)
rendered_content = self.pod.read_file(rendered_path)
rendered_doc = rendered_document.RenderedDocument(
serving_path, rendered_content)
timer.stop_timer()
return rendered_doc
except Exception as err:
exception = errors.BuildError(str(err))
exception.traceback = sys.exc_info()[2]
exception.controller = self
exception.exception = err
raise exception
def render(self, params, inject=True):
preprocessor = None
translator = None
if inject:
preprocessor = self.pod.inject_preprocessors(doc=self.doc)
translator = self.pod.inject_translators(doc=self.doc)
env = self.pod.get_jinja_env(self.locale)
template = env.get_template(self.view.lstrip('/'))
try:
kwargs = {
'doc': self.doc,
'env': self.pod.env,
'podspec': self.pod.get_podspec(),
}
content = template.render(kwargs).lstrip()
content = self._inject_ui(content, preprocessor, translator,
self.pod.ui)
return content
except Exception as e:
text = 'Error building {}: {}'
exception = errors.BuildError(text.format(self, e))
exception.traceback = sys.exc_info()[2]
exception.controller = self
exception.exception = e
raise exception
def render(self, jinja_env=None):
"""Render the document using the render pool."""
timer = self.pod.profile.timer('RenderDocumentController.render',
label='{} ({})'.format(
self.doc.pod_path, self.doc.locale),
meta={
'path': self.doc.pod_path,
'locale': str(self.doc.locale)
}).start_timer()
# Validate the path with the config filters.
self.validate_path()
doc = self.doc
template = jinja_env['env'].get_template(doc.view.lstrip('/'))
track_dependency = doc_dependency.DocDependency(doc)
local_tags = tags.create_builtin_tags(
self.pod, doc, track_dependency=track_dependency)
# NOTE: This should be done using get_template(... globals=...)
# or passed as an argument into render but
# it is not available included inside macros???
# See: https://github.com/pallets/jinja/issues/688
template.globals['g'] = local_tags
# Track the message stats, including untranslated strings.
if self.pod.is_enabled(self.pod.FEATURE_TRANSLATION_STATS):
template.globals['_'] = tags.make_doc_gettext(doc)
try:
serving_path = doc.get_serving_path()
if serving_path.endswith('/'):
serving_path = '{}{}'.format(serving_path, self.suffix)
rendered_content = template.render({
'doc':
doc,
'env':
self.pod.env,
'podspec':
self.pod.podspec,
'_track_dependency':
track_dependency,
}).lstrip()
rendered_content = self.pod.extensions_controller.trigger(
'post_render', doc, rendered_content)
rendered_doc = rendered_document.RenderedDocument(
serving_path, rendered_content)
timer.stop_timer()
return rendered_doc
except Exception as err:
text = 'Error building {}: {}'
if self.pod:
self.pod.logger.exception(text.format(self, err))
exception = errors.BuildError(text.format(self, err))
exception.traceback = sys.exc_info()[2]
exception.controller = self
exception.exception = err
raise exception
def render(self):
# TODO(jeremydw): This is a bit hacky. Be more explicit about translations.
ll = self.locale
self._install_translations(ll)
if self.locale is None: # Use the system's default locale.
locale.setlocale(locale.LC_ALL, '')
else:
try:
# TODO(jeremydw): Convert from Babel locale to system locale.
locale.setlocale(locale.LC_TIME, str(self.locale))
except locale.Error:
pass
template = self._template_env.get_template(self.view.lstrip('/'))
g = {
'breadcrumb':
lambda *args, **kwargs: tags.breadcrumb(
*args, _pod=self.pod, **kwargs),
'categories':
lambda *args, **kwargs: tags.categories(
*args, _pod=self.pod, **kwargs),
'cc':
self.cc,
'csv':
lambda *args, **kwargs: tags.csv(*args, _pod=self.pod, **kwargs),
'date':
lambda *args, **kwargs: tags.date(*args, _pod=self.pod, **kwargs),
'doc':
lambda *args, **kwargs: tags.get_doc(
*args, _pod=self.pod, **kwargs),
'docs':
lambda *args, **kwargs: tags.docs(*args, _pod=self.pod, **kwargs),
'll':
self.ll,
'locales':
lambda *args, **kwargs: tags.locales(
*args, _pod=self.pod, **kwargs),
'nav':
lambda *args, **kwargs: tags.nav(*args, _pod=self.pod, **kwargs),
'params':
self.route_params,
'static':
lambda path: tags.static(path, _pod=self.pod),
'url':
lambda *args, **kwargs: tags.url(*args, _pod=self.pod, **kwargs),
}
try:
return template.render({
'g': g,
'doc': self.document,
'env': self.pod.env,
'podspec': self.pod.get_podspec(),
}).lstrip()
except Exception as e:
text = 'Error building {}: {}'
logging.exception(e)
raise errors.BuildError(text.format(self, e))
def render(self, jinja_env=None):
"""Render the document using the render pool."""
timer = self.pod.profile.timer(
'RenderSitemapController.render',
label='{}'.format(self.serving_path),
meta=self.route_info.meta,
).start_timer()
# Validate the path with the config filters.
self.validate_path()
# Need a custom root for rendering sitemap.
root = os.path.join(utils.get_grow_dir(), 'pods', 'templates')
jinja_env = self.pod.render_pool.custom_jinja_env(root=root)
with jinja_env['lock']:
if self.route_info.meta.get('template'):
content = self.pod.read_file(self.route_info.meta['template'])
template = jinja_env['env'].from_string(content)
else:
template = jinja_env['env'].get_template('sitemap.xml')
try:
docs = []
locales = self.route_info.meta.get('locales')
collections = self.route_info.meta.get('collections')
for col in list(self.pod.list_collections(collections)):
docs += col.list_servable_documents(locales=locales)
rendered_doc = rendered_document.RenderedDocument(
self.serving_path,
template.render({
'pod': self.pod,
'docs': docs,
}).lstrip())
timer.stop_timer()
return rendered_doc
except Exception as err:
text = 'Error building {}: {}'
if self.pod:
self.pod.logger.exception(text.format(self, err))
exception = errors.BuildError(text.format(self, err))
exception.traceback = sys.exc_info()[2]
exception.controller = self
exception.exception = err
raise exception
def render(self, jinja_env=None):
"""Render the document using the render pool."""
timer = self.pod.profile.timer('RenderErrorController.render',
label='{} ({})'.format(
self.route_info.meta['key'],
self.route_info.meta['view']),
meta={
'key': self.route_info.meta['key'],
'view':
self.route_info.meta['view'],
}).start_timer()
# Validate the path with the config filters.
self.validate_path()
with jinja_env['lock']:
template = jinja_env['env'].get_template(
self.route_info.meta['view'].lstrip('/'))
local_tags = tags.create_builtin_tags(self.pod, doc=None)
# NOTE: This should be done using get_template(... globals=...)
# or passed as an argument into render but
# it is not available included inside macros???
# See: https://github.com/pallets/jinja/issues/688
template.globals['g'] = local_tags
try:
serving_path = '/{}.html'.format(self.route_info.meta['key'])
rendered_doc = rendered_document.RenderedDocument(
serving_path,
template.render({
'doc': None,
'env': self.pod.env,
'podspec': self.pod.podspec,
}).lstrip())
timer.stop_timer()
return rendered_doc
except Exception as err:
text = 'Error building {}: {}'
if self.pod:
self.pod.logger.exception(text.format(self, err))
exception = errors.BuildError(text.format(self, err))
exception.traceback = sys.exc_info()[2]
exception.controller = self
exception.exception = err
raise exception
def render(self, jinja_env=None, request=None):
"""Render the document using the render pool."""
timer = self.pod.profile.timer(
'RenderSitemapController.render',
label='{}'.format(self.serving_path),
meta=self.route_info.meta,
).start_timer()
# Validate the path with the config filters.
self.validate_path()
# Duplicate the routes to use the filters without messing up routing.
temp_router = self.pod.router.__class__(self.pod)
temp_router.add_all()
# Sitemaps only show documents...?
temp_router.filter('whitelist', kinds=['doc'])
for sitemap_filter in self.route_info.meta.get('filters') or []:
temp_router.filter(
sitemap_filter['type'],
collection_paths=sitemap_filter.get('collections'),
paths=sitemap_filter.get('paths'),
locales=sitemap_filter.get('locales'))
# Need a custom root for rendering sitemap.
root = os.path.join(utils.get_grow_dir(), 'pods', 'templates')
jinja_env = self.pod.render_pool.custom_jinja_env(root=root)
with jinja_env['lock']:
if self.route_info.meta.get('template'):
content = self.pod.read_file(self.route_info.meta['template'])
template = jinja_env['env'].from_string(content)
else:
template = jinja_env['env'].get_template('sitemap.xml')
try:
docs = []
for _, value, _ in temp_router.routes.nodes:
docs.append(
self.pod.get_doc(value.meta['pod_path'],
locale=value.meta['locale']))
rendered_doc = rendered_document.RenderedDocument(
self.serving_path,
template.render({
'pod': self.pod,
'env': self.pod.env,
'docs': docs,
'podspec': self.pod.podspec,
}).lstrip())
timer.stop_timer()
return rendered_doc
except Exception as err:
text = 'Error building {}: {}'
if self.pod:
self.pod.logger.exception(text.format(self, err))
exception = errors.BuildError(text.format(self, err))
exception.traceback = sys.exc_info()[2]
exception.controller = self
exception.exception = err
raise exception
