Docserver: Attach intro metadata to the template itself, not to an object which

chrome/common/extensions/docs/server2/intro_data_source.py

 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 from HTMLParser import HTMLParser
 import logging
 import os
 import re
 
 from extensions_paths import INTROS_TEMPLATES, ARTICLES_TEMPLATES
 from data_source import DataSource
 from docs_server_utils import FormatKey
 from file_system import FileNotFoundError
 from future import Future
 from third_party.handlebar import Handlebar
 
 
 _H1_REGEX = re.compile('<h1[^>.]*?>.*?</h1>', flags=re.DOTALL)
 
 
+class _HandlebarWithContext(Handlebar):
+  '''Extends Handlebar with a get() method so that templates can not only
+  render intros with {{+intro}} but also access properties on them, like
+  {{intro.title}}, {{intro.toc}}, etc.
+  '''
+
+  def __init__(self, text, name, context):
+    Handlebar.__init__(self, text, name=name)
+    self._context = context
+
+  def get(self, key):
+    return self._context.get(key)
+
+
 # TODO(kalman): rename this HTMLDataSource or other, then have separate intro
 # article data sources created as instances of it.
 class _IntroParser(HTMLParser):
   ''' An HTML parser which will parse table of contents and page title info out
   of an intro.
   '''
   def __init__(self):
     HTMLParser.__init__(self)
     self.toc = []
     self.page_title = None
@@ skipping 24 matching lines @@
     if self._recent_tag is None:
       return
     if self._recent_tag == 'h1':
       if self.page_title is None:
         self.page_title = data
       else:
         self.page_title += data
     elif self._recent_tag in ['h2', 'h3']:
       self._current_heading['title'] += data
 
+
 class IntroDataSource(DataSource):
   '''This class fetches the intros for a given API. From this intro, a table
   of contents dictionary is created, which contains the headings in the intro.
   '''
 
-  def __init__(self, server_instance, _):
+  def __init__(self, server_instance, request):
+    self._template_renderer = server_instance.template_renderer
+    self._request = request
     self._cache = server_instance.compiled_fs_factory.Create(
         server_instance.host_file_system_provider.GetTrunk(),
-        self._MakeIntroDict,
+        self._MakeIntro,
         IntroDataSource)
     self._ref_resolver = server_instance.ref_resolver_factory.Create()
 
-  def _MakeIntroDict(self, intro_path, intro):
+  def _MakeIntro(self, intro_path, intro):
     # Guess the name of the API from the path to the intro.
     api_name = os.path.splitext(intro_path.split('/')[-1])[0]
-    intro_with_links = self._ref_resolver.ResolveAllLinks(intro,
-                                                          namespace=api_name)
-    # TODO(kalman): Do $ref replacement after rendering the template, not
-    # before, so that (a) $ref links can contain template annotations, and (b)
-    # we can use CompiledFileSystem.ForTemplates to create the templates and
-    # save ourselves some effort.
-    apps_parser = _IntroParser()
-    apps_parser.feed(Handlebar(intro_with_links).render(
-        { 'is_apps': True }).text)
-    extensions_parser = _IntroParser()
-    extensions_parser.feed(Handlebar(intro_with_links).render(
-        { 'is_apps': False }).text)
-    # TODO(cduvall): Use the normal template rendering system, so we can check
-    # errors.
-    if extensions_parser.page_title != apps_parser.page_title:
-      logging.error(
-          'Title differs for apps and extensions: Apps: %s, Extensions: %s.' %
-              (extensions_parser.page_title, apps_parser.page_title))
+    intro_with_links = self._ref_resolver.ResolveAllLinks(
+            intro, namespace=api_name)
+
+    # TODO(kalman): In order to pick up every header tag, and therefore make a
+    # complete TOC, the render context of the Handlebar needs to be passed
+    # through to here. Even if there were a mechanism to do this it would
+    # break caching; we'd need to do the TOC parsing *after* rendering the full
+    # template, and that would probably be expensive.
+    intro_parser = _IntroParser()
+    intro_parser.feed(
+        self._template_renderer.Render(Handlebar(intro_with_links),
+                                       self._request,
+                                       # Avoid nasty surprises.
+                                       data_sources=('partials', 'strings'),
+                                       warn=False))
+
     # The templates will render the heading themselves, so remove it from the
     # HTML content.
     intro_with_links = re.sub(_H1_REGEX, '', intro_with_links, count=1)
-    return {
-      'intro': Handlebar(intro_with_links),
-      'title': apps_parser.page_title,
-      'apps_toc': apps_parser.toc,
-      'extensions_toc': extensions_parser.toc,
+
+    context = {
+      'title': intro_parser.page_title,
+      'toc': intro_parser.toc,

[not at google - send to devlin, 2013/11/16 21:54:41]

I needed to lose the extension/app differentiation here. It shouldn't matter
unless the title or TOC of a file is affected by the presence of {{is_apps}}...
and if it did matter, the comment I left on lines 100-104 is very relevant.

     }
+    return _HandlebarWithContext(intro_with_links, intro_path, context)
 
   def get(self, key):
     path = FormatKey(key)
     def get_from_base_path(base_path):
       return self._cache.GetFromFile('%s/%s' % (base_path, path)).Get()
     base_paths = (INTROS_TEMPLATES, ARTICLES_TEMPLATES)
     for base_path in base_paths:
       try:
         return get_from_base_path(base_path)
       except FileNotFoundError:
         continue
     # Not found. Do the first operation again so that we get a stack trace - we
     # know that it'll fail.
     get_from_base_path(base_paths[0])
     raise AssertionError()
 
   def Cron(self):
     # TODO(kalman): Walk through the intros and articles directory.
     return Future(value=())