Extensions docs server: Design changes, partial template support.

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 time
+
+from third_party.handlebar import Handlebar
+
+class TemplateDataSource(object):

[not at google - send to devlin, 2012/06/07 04:43:57]

I was thinking, should be build all the template rendering into here? All we do
when we render something is
1. grab a template from here
2. render it using TemplateUtility

does it make sense to expose a method like Render() on this which sets up that
"templates" path correctly?  Namely... pointing at itself?  Like

class TemplateDataSource(object):
  ...

  def Render(self, template_name, context):
    template = get(template_name)
    if not template:
      return ''
    # TODO: error handling.
    return template.render(context, { "templates": self }).text

Then we can delete TemplateUtility, which is good, cos I hate util classes.

[cduvall, 2012/06/08 00:39:23]

Done.

+  def __init__(self, fetcher, base_paths, cache_timeout):

[not at google - send to devlin, 2012/06/07 04:43:57]

cache_timeout_seconds

[cduvall, 2012/06/08 00:39:23]

Done.

+    logging.info('Template data source created.')

[not at google - send to devlin, 2012/06/07 04:43:57]

It's ok if you want to leave logging in for now (though when the server hits
production we'll need to sanitise it a bit), but you might want to log
base_paths and cache_timeout too.

[cduvall, 2012/06/08 00:39:23]

Done.

+    self._fetcher = fetcher
+    self._template_cache = {}
+    self._base_paths = base_paths
+    self._cache_timeout = cache_timeout
+
+  def __getitem__(self, key):
+    return self.get(key)
+
+  def get(self, key):
+    index = key.rfind('.html')
+    if index > 0:
+      key = key[:index]
+    path = key + '.html'
+    if key in self._template_cache:
+      compiled_template, compile_time = self._template_cache[key]
+      if (time.time() - compile_time) > self._cache_timeout:
+        self._template_cache.pop(key)
+    if key not in self._template_cache:
+      logging.info('Template cache miss for: ' + path)
+      compiled_template = None
+      for base_path in self._base_paths:
+        try:
+          template = self._fetcher.FetchResource(base_path + path).content
+          compiled_template = Handlebar(template)
+          self._template_cache[key] = (compiled_template, time.time())

[not at google - send to devlin, 2012/06/07 04:43:57]

Consider making the cache entries actual objects that know when they timeout,
and store those in _template_cache instead.  Who knows, you might want to put
more metadata in there; it's also a bit easier to read then using tuples IMO.

class _CachedTemplate(object):
  def __init__(self, template, expiry):
    self.template = template
    self._expiry = expiry

  def HasExpired(self):
    return time.time() > self._expiry

[cduvall, 2012/06/08 00:39:23]

Done.

+          break
+        except:
+          pass
+
+    return compiled_template