Doc server manifest page generation

chrome/common/extensions/docs/server2/template_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.
 
 import logging
-import os
 import traceback
 
 from branch_utility import BranchUtility
-import compiled_file_system as compiled_fs
 from docs_server_utils import FormatKey
 from file_system import FileNotFoundError
 from third_party.handlebar import Handlebar
 import url_constants
 
 EXTENSIONS_URL = '/chrome/extensions'
 
-def _MakeChannelDict(channel_name):
+def _MakeChannelDict(channel_name, path):
+  splitpath = path.split('/')
   channel_dict = {
     'channels': [{'name': name} for name in BranchUtility.GetAllChannelNames()],
     'current': channel_name
   }
+
   for channel in channel_dict['channels']:
     if channel['name'] == channel_name:
       channel['isCurrent'] = True
+  if splitpath[0] in ['extensions', 'apps']:
+    channel_dict['base_url'] = '/%s/%s/' % (channel_name, splitpath[0])
+  # else:

[not at google - send to devlin, 2013/05/10 04:14:14]

what is this? getting late, running out of brainpower.

[jshumway, 2013/05/11 02:37:08]

This makes an absolute base URL available to all the templates. I needed a base
URL to make all of the sidenav links, and the sample link at the top of the
page, absolute. Being at /extensions/manifest/something.html would break all the
links on the page. This fixes that. It all adds the channel name to apps or
extensions, which might not be needed anymore. The commented out else is
something I meant to remove.

+  #   channel_dict['base_url'] = '/%s/' % channel_name
   return channel_dict
 
 class TemplateDataSource(object):
   """Renders Handlebar templates, providing them with the context in which to
   render.
 
   Also acts as a data source itself, providing partial Handlebar templates to
   those it renders.
 
   Each instance of TemplateDataSource is bound to a Request so that it can
   render templates with request-specific data (such as Accept-Language); use
   a Factory to cheaply construct these.
   """
 
   class Factory(object):
     """A factory to create lightweight TemplateDataSource instances bound to
     individual Requests.
     """
     def __init__(self,
                  channel_name,
                  api_data_source_factory,
                  api_list_data_source_factory,
                  intro_data_source_factory,
                  samples_data_source_factory,
                  sidenav_data_source_factory,
                  compiled_fs_factory,
                  ref_resolver_factory,
+                 manifest_data_source,
                  public_template_path,
                  private_template_path):
-      self._branch_info = _MakeChannelDict(channel_name)
+      self.channel_name = channel_name
       self._api_data_source_factory = api_data_source_factory
       self._api_list_data_source_factory = api_list_data_source_factory
       self._intro_data_source_factory = intro_data_source_factory
       self._samples_data_source_factory = samples_data_source_factory
       self._sidenav_data_source_factory = sidenav_data_source_factory
       self._cache = compiled_fs_factory.Create(self._CreateTemplate,
                                                TemplateDataSource)
       self._ref_resolver = ref_resolver_factory.Create()
       self._public_template_path = public_template_path
       self._private_template_path = private_template_path
       self._static_resources = '/%s/static' % channel_name
+      self._manifest_data_source = manifest_data_source
 
     def _CreateTemplate(self, template_name, text):
       return Handlebar(self._ref_resolver.ResolveAllLinks(text))
 
     def Create(self, request, path):
       """Returns a new TemplateDataSource bound to |request|.
       """
       return TemplateDataSource(
-          self._branch_info,
+          _MakeChannelDict(self.channel_name, path),
           self._api_data_source_factory.Create(request),
           self._api_list_data_source_factory.Create(),
           self._intro_data_source_factory.Create(),
           self._samples_data_source_factory.Create(request),
           self._sidenav_data_source_factory.Create(path),
           self._cache,
+          self._manifest_data_source,
           self._public_template_path,
           self._private_template_path,
           self._static_resources)
 
   def __init__(self,
                branch_info,
                api_data_source,
                api_list_data_source,
                intro_data_source,
                samples_data_source,
                sidenav_data_source,
                cache,
+               manifest_data_source,
                public_template_path,
                private_template_path,
                static_resources):
     self._branch_info = branch_info
     self._api_list_data_source = api_list_data_source
     self._intro_data_source = intro_data_source
     self._samples_data_source = samples_data_source
     self._api_data_source = api_data_source
     self._sidenav_data_source = sidenav_data_source
     self._cache = cache
     self._public_template_path = public_template_path
     self._private_template_path = private_template_path
     self._static_resources = static_resources
+    self._manifest_data_source = manifest_data_source
 
   def Render(self, template_name):
     """This method will render a template named |template_name|, fetching all
     the partial templates needed from |self._cache|. Partials are retrieved
     from the TemplateDataSource with the |get| method.
     """
     template = self.GetTemplate(self._public_template_path, template_name)
     if not template:
       return None
       # TODO error handling
     render_data = template.render({
       'api_list': self._api_list_data_source,
       'apis': self._api_data_source,
       'branchInfo': self._branch_info,
       'intros': self._intro_data_source,
       'sidenavs': self._sidenav_data_source,
       'partials': self,
+      'manifest_source': self._manifest_data_source,
       'samples': self._samples_data_source,
       'static': self._static_resources,
       'app': 'app',
       'extension': 'extension',
       'apps_title': 'Apps',
       'extensions_title': 'Extensions',
       'apps_samples_url': url_constants.GITHUB_BASE,
       # TODO(kalman): this is wrong, it's always getting from trunk, but meh
       # it hardly ever shows up (only in the "cannot fetch samples" message).
       # In fact I don't even know if it can show up anymore due the samples data
       # being persisent. In any case, when the channel distinctions are gone
       # this can go away, so, double meh.
       'extensions_samples_url': url_constants.EXTENSIONS_SAMPLES,
       'true': True,
       'false': False
     })
     if render_data.errors:
       logging.error('Handlebar error(s) rendering %s:\n%s' %
           (template_name, '  \n'.join(render_data.errors)))
     return render_data.text
 
   def get(self, key):
     return self.GetTemplate(self._private_template_path, key)
 
   def GetTemplate(self, base_path, template_name):
     try:
       return self._cache.GetFromFile(
           '/'.join((base_path, FormatKey(template_name))))
-    except FileNotFoundError as e:
+    except FileNotFoundError:
       logging.warning(traceback.format_exc())
       return None