jinja2: support file references in templates.

build/android/gyp/jinja_template.py

 #!/usr/bin/env python
 #
 # Copyright 2014 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.
 
 """Renders one or more template files using the Jinja template engine."""
 
 import codecs
 import optparse
 import os
 import sys
 
 from util import build_utils
 
 # Import jinja2 from third_party/jinja2
 sys.path.append(os.path.join(os.path.dirname(__file__), '../../../third_party'))
 import jinja2  # pylint: disable=F0401
 
 
-def ProcessFile(input_filename, output_filename, variables):
-  with codecs.open(input_filename, 'r', 'utf-8') as input_file:
-    input_ = input_file.read()
-  env = jinja2.Environment(undefined=jinja2.StrictUndefined)
-  template = env.from_string(input_)
-  template.filename = os.path.abspath(input_filename)
+class RecordingFileSystemLoader(jinja2.FileSystemLoader):
+  '''A FileSystemLoader that stores a list of loaded templates.'''
+  def __init__(self, searchpath):
+    jinja2.FileSystemLoader.__init__(self, searchpath)
+    self.loaded_templates = []

[cjhopman, 2015/03/17 18:03:33]

Should this be a set? Idk if ninja cares about duplicate entries in depfiles (it
probably doesn't).

[newt (away), 2015/03/17 18:58:28]

Changed to set.

+
+  def get_source(self, environment, template):
+    contents, filename, uptodate = jinja2.FileSystemLoader.get_source(

[cjhopman, 2015/03/17 18:03:33]

is filename relative or absolute? We should make sure that it is relative to the
current directory.

[newt (away), 2015/03/17 18:44:47]

They're absolute paths currently. Curious: why do they need to be relative?

[newt (away), 2015/03/17 18:58:28]

Changed to relative.

[cjhopman, 2015/03/17 19:01:53]

I believe that ninja will treat a relative path and an absolute path to the same
file as different files. Then, if you have an output of one thing as the input
of another, and one specifies it as relative, the other as absolute, you will
have a bad time. And so, we make everything relative.

thakis@ really doesn't like absolute paths, but I think he usually says it's
because he tends to rename output directories and wants things to still work. I
don't know how common that is among other people and I care much more about the
first point.

+        self, environment, template)
+    self.loaded_templates.append(filename)
+    return contents, filename, uptodate
+
+  def get_loaded_templates(self):
+    return self.loaded_templates
+
+
+def ProcessFile(env, input_filename, output_filename, variables):
+  input_rel_path = os.path.relpath(input_filename, build_utils.CHROMIUM_SRC)
+  template = env.get_template(input_rel_path)
   output = template.render(variables)
   with codecs.open(output_filename, 'w', 'utf-8') as output_file:
     output_file.write(output)
 
 
-def ProcessFiles(input_filenames, inputs_base_dir, outputs_zip, variables):
+def ProcessFiles(env, input_filenames, inputs_base_dir, outputs_zip, variables):
   with build_utils.TempDir() as temp_dir:
     for input_filename in input_filenames:
       relpath = os.path.relpath(os.path.abspath(input_filename),
                                 os.path.abspath(inputs_base_dir))
       if relpath.startswith(os.pardir):
         raise Exception('input file %s is not contained in inputs base dir %s'
                         % input_filename, inputs_base_dir)
 
       output_filename = os.path.join(temp_dir, relpath)
       parent_dir = os.path.dirname(output_filename)
       build_utils.MakeDirectory(parent_dir)
-      ProcessFile(input_filename, output_filename, variables)
+      ProcessFile(env, input_filename, output_filename, variables)
 
     build_utils.ZipDir(outputs_zip, temp_dir)
 
 
 def main():
   parser = optparse.OptionParser()
   build_utils.AddDepfileOption(parser)
   parser.add_option('--inputs', help='The template files to process.')
   parser.add_option('--output', help='The output file to generate. Valid '
                     'only if there is a single input.')
@@ skipping 20 matching lines @@
   if args:
     parser.error('No positional arguments should be given.')
 
   variables = {}
   for v in build_utils.ParseGypList(options.variables):
     if '=' not in v:
       parser.error('--variables argument must contain "=": ' + v)
     name, _, value = v.partition('=')
     variables[name] = value
 
+  loader = RecordingFileSystemLoader(build_utils.CHROMIUM_SRC)
+  env = jinja2.Environment(loader=loader, undefined=jinja2.StrictUndefined,
+                           line_comment_prefix='##')
   if options.output:
-    ProcessFile(inputs[0], options.output, variables)
+    ProcessFile(env, inputs[0], options.output, variables)
   else:
-    ProcessFiles(inputs, options.inputs_base_dir, options.outputs_zip,
+    ProcessFiles(env, inputs, options.inputs_base_dir, options.outputs_zip,
                  variables)
 
   if options.depfile:
-    deps = inputs + build_utils.GetPythonDependencies()
+    deps = loader.get_loaded_templates() + build_utils.GetPythonDependencies()
     build_utils.WriteDepfile(options.depfile, deps)
 
 
 if __name__ == '__main__':
   main()