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

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

Index: chrome/common/extensions/docs/server2/template_utility.py
diff --git a/chrome/common/extensions/docs/server2/template_utility.py b/chrome/common/extensions/docs/server2/template_utility.py
new file mode 100644
index 0000000000000000000000000000000000000000..f1eeb30334aca34468198a6f4051266d632e029d
--- /dev/null
+++ b/chrome/common/extensions/docs/server2/template_utility.py
@@ -0,0 +1,14 @@
+# 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 json
+
+from third_party.handlebar import Handlebar
+
+class TemplateUtility(object):
+  def RenderTemplate(self, template_source, json_str):
+    template = Handlebar(template_source)
+    rendered_template = template.render(json.loads(json_str),
+        {'templates': []}).text
+    return rendered_template

[not at google - send to devlin, 2012/06/04 04:37:08]

nit: we'll probably want to do something with the errors at some point (e.g. log
them) so assign the result of .render to something (e.g. "result") then return
result.text.

and a TODO for dealing with the errors.

actually: I think this file is a bit dangerous, since compiling templates is
expensive and this is encouraging laziness.  We should be caching the compiled
templates.  So instead, could we make a wrapper around resource fetching like
HandelbarFetcher / TemplateFetcher/ whatever which fetches paths then caches the
*compiled* result?

I guess there will be issues with knowing when to refresh the cache, hopefully,
ones that are surmountable.

[Aaron Boodman, 2012/06/04 06:29:09]

This makes sense because we're going to end up with some sub-templates that are
reused over and over.

Note that memcached can only cache serializable objects, so I don't think that's
going to work here. The templates can only be cached within a process.

[not at google - send to devlin, 2012/06/04 06:36:29]

Within each process is certainly a lot better than nothing.

Note that, for future record, in the subtemplate case we'll need to expose a
dictionary interface to the TemplateFetcher class, because is what the templates
will be expecting to see.  Something like

--- bar.html ---
Hello from bar!

--- foo.html ---
This is going to include some other template: {{+partials.bar}}

--- server_code.py ---
template = template_fetcher['foo'];  # whatever the method is called
result = template.render({
  templates: template_fetcher
});
print(result.text)
This is going to include some other template: Hello from bar!