Die build.py, Die: Part 2 (LocalFetcher, Handlebar support, build script)

chrome/common/extensions/docs/server2/template_fetcher.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
+
+# Cache templates for 5 minutes.
+CACHE_TIMEOUT = 300
+
+# Cached templates stored as (branch, path) -> (template, cache time)
+# The template cache is global so it will not be erased each time a new
+# TemplateFetcher is created.
+TEMPLATE_CACHE = {}

[not at google - send to devlin, 2012/06/04 23:09:51]

See comment below as to what this could be.

+
+class TemplateFetcher(object):
+  def __init__(self, fetcher):
+    self.fetcher = fetcher

[not at google - send to devlin, 2012/06/04 23:09:51]

should be _fetcher

+
+  def __getitem__(self, key):
+    if key not in TEMPLATE_CACHE:
+      self.FetchTemplate(key[0], key[1])
+    return TEMPLATE_CACHE[key][0]
+
+  def AsDict(self, branch):

[not at google - send to devlin, 2012/06/04 23:09:51]

Yeah, this won't play so well with plugging stuff into templates as a dict.

Rather than this could we have this structured more like...

_FETCHERS = {}

TemplateFetcher(object):
  def __init__(self, fetcher, branch):
    self._fetcher = fetcher
    self._branch = branch

  def __getitem__(self, key):
    return self.FetchTemplate(key)

  def FetchTemplate(self, name):
    path = name + '.html'
    template = self._fetcher.FetchResource(self._branch, path)
    ... etc (what you had)

If necessary have some kind of factory class like

TemplateFetcherFactory(object):
  __init__(self, fetcher):
    self._fetcher = fetcher
    self._cache = {}

  def ForBranch(self, branch):
    if branch in self._cache:
      return self._cache[branch]
    self._cache[branch] = TemplateFetcher(self._fetcher, branch)
    return self._cache[branch]

+    template_dict = {}
+    for k, v in TEMPLATE_CACHE.iteritems():
+      # For each template in the branch, add the template to the dictionary with
+      # its name as the key. This can be used with Handlebar for partials.
+      if k[0] == branch:
+        template_dict[os.path.basename(k[1])] = v[0]
+
+    return template_dict
+
+  def FetchTemplate(self, branch, path):
+    key = (branch, path)
+    # Check the template cache and whether the cache has expired.
+    if key in TEMPLATE_CACHE:
+      if TEMPLATE_CACHE[key][1] < CACHE_TIMEOUT:
+        return TEMPLATE_CACHE[key][0]
+    logging.info('Template cache miss for: ' + path)
+    template = self.fetcher.FetchResource(branch, path).content

[not at google - send to devlin, 2012/06/04 23:09:51]

Something to think about: this 5 minute thing is a bit sucky if somebody is
iterating very quickly on the templates.

Instead of this, could we store a hash of the template source along with each
template. Then, always fetch the source, compare its hash to what we already
have, and if it's different then recompile the template. I'm not even sure we'd
buy much from caching it, but, yeah.

Come to think of it, we could even optimise this a bit by giving it a 5-second
timeout or something, so that rendering partials doesn't cause a whole bunch of
fetching. But that's something to worry about later if we find things are slow
and this is a major cause of it etc etc.

+    compiled_template = Handlebar(template)
+    TEMPLATE_CACHE[key] = (compiled_template, time.clock())
+    return compiled_template