Move templates to their own directory structure.

client/dom/scripts/dartgenerator.py

 #!/usr/bin/python
 # Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE file.
 
 """This module generates Dart APIs from the IDL database."""
 
 import emitter
 import idlnode
 import logging
@@ skipping 406 matching lines @@
       lib_template -- template file in this directory for generated lib file.
     """
 
     self._emitters = multiemitter.MultiEmitter()
     self._database = database
     self._output_dir = output_dir
 
     self._ComputeInheritanceClosure()
 
     interface_system = WrappingInterfacesSystem(
+        TemplateLoader('../templates', ['dom/interface', 'dom', '']),
         self._database, self._emitters, self._output_dir)
 
     wrapping_system = WrappingImplementationSystem(
+        TemplateLoader('../templates', ['dom/wrapping', 'dom', '']),
         self._database, self._emitters, self._output_dir)
 
     # Makes wrapper implementations available for listing in interface lib.
     interface_system._implementation_system = wrapping_system
 
     frog_system = FrogSystem(
+        TemplateLoader('../templates', ['dom/frog', 'dom', '']),
         self._database, self._emitters, self._output_dir)
 
     self._systems = [interface_system,
                      wrapping_system,
                      frog_system]
 
     # Render all interfaces into Dart and save them in files.
     for interface in database.GetInterfaces():
 
       super_interface = None
@@ skipping 232 matching lines @@
     info.declared_name = operations[0].id
     info.name = operations[0].ext_attrs.get('DartName', info.declared_name)
     info.js_name = info.declared_name
     info.type_name = operations[0].type.id   # TODO: widen.
     info.arg_interface_declaration = FormatArgs(args, True)
     info.arg_implementation_declaration = FormatArgs(args, False)
     info.arg_infos = args
     return info
 
 
-  def GenerateOldLibFile(self, lib_template, lib_file_path, file_paths):
-    """Generates a lib file from a template and a list of files."""
-    # Generate the .lib file.
-    if lib_file_path:
-      # Load template.
-      template = ''.join(open(lib_template).readlines())
-      lib_file_contents = self._emitters.FileEmitter(lib_file_path)
-
-      # Emit the list of path names.
-      list_emitter = lib_file_contents.Emit(template)
-      lib_file_dir = os.path.dirname(lib_file_path)
-      for path in sorted(file_paths):
-        relpath = os.path.relpath(path, lib_file_dir)
-        list_emitter.Emit("\n    '$PATH',", PATH=relpath)
-
-  def GenerateLibFile(self, lib_template, lib_file_path, file_paths):
-    """Generates a lib file from a template and a list of files."""
-    # Load template.
-    template = ''.join(open(lib_template).readlines())
-    # Generate the .lib file.
-    lib_file_contents = self._emitters.FileEmitter(lib_file_path)
-
-    # Emit the list of #source directives.
-    list_emitter = lib_file_contents.Emit(template)
-    lib_file_dir = os.path.dirname(lib_file_path)
-    for path in sorted(file_paths):
-      relpath = os.path.relpath(path, lib_file_dir)
-      list_emitter.Emit("#source('$PATH');\n", PATH=relpath)
-
-
   def Flush(self):
     """Write out all pending files."""
     _logger.info('Flush...')
     self._emitters.Flush()
 
 
   def FilePathForDartInterface(self, interface_name):
     """Returns the file path of the Dart interface definition."""
     return os.path.join(self._output_dir, 'src', 'interface',
                         '%s.dart' % interface_name)
@@ skipping 153 matching lines @@
   """Format lines of text with indent."""
   def FormatLine(line):
     if line.strip():
       return '%s%s\n' % (indent, line)
     else:
       return '\n'
   return ''.join(FormatLine(line) for line in text.split('\n'))
 
 # ------------------------------------------------------------------------------
 
+class TemplateLoader(object):
+  """Loads template files from a path."""
+
+  def __init__(self, root, subpaths):
+    """Initializes loader.
+
+    Args:
+      root - a string, the directory under which the templates are stored.
+      subpaths - a list of strings, subpaths of root in search order.
+    """
+    self._root = root
+    self._subpaths = subpaths
+    self._cache = {}
+
+  def TryLoad(self, name):
+    """Returns content of template file as a string, or None of not found."""
+    if name in self._cache:
+      return self._cache[name]
+
+    for subpath in self._subpaths:
+      template_file = os.path.join(self._root, subpath, name)
+      if os.path.exists(template_file):
+        template = ''.join(open(template_file).readlines())
+        self._cache[name] = template
+        return template
+
+    return None
+
+  def Load(self, name):
+    """Returns contents of template file as a string, or raises an exception."""
+    template = self.TryLoad(name)
+    if template is not None:  # Can be empty string
+      return template
+    raise Exception("Could not find template '%s' on %s / %s" % (
+        name, self._root, self._subpaths))
+
+
+# ------------------------------------------------------------------------------
+
 class System(object):
   """Generates all the files for one implementation."""
 
-  def __init__(self, database, emitters, output_dir):
+  def __init__(self, templates, database, emitters, output_dir):
+    self._templates = templates
     self._database = database
     self._emitters = emitters
     self._output_dir = output_dir
     self._dart_callback_file_paths = []
 
   def InterfaceGenerator(self,
                          interface,
                          common_prefix,
                          super_interface_name,
                          source_filter):
     """Returns an interface generator for |interface|."""
     return None
 
   def ProcessCallback(self, interface, info):
     pass
 
   def GenerateLibraries(self, lib_dir):
     pass
 
   def Finish(self):
     pass
 
 
   def _ProcessCallback(self, interface, info, file_path):
     """Generates a typedef for the callback interface."""
     self._dart_callback_file_paths.append(file_path)
     code = self._emitters.FileEmitter(file_path)
 
-    template_file = 'template_callback.darttemplate'
-    code.Emit(''.join(open(template_file).readlines()))
+    code.Emit(self._templates.Load('callback.darttemplate'))
     code.Emit('typedef $TYPE $NAME($ARGS);\n',
               NAME=interface.id,
               TYPE=info.type_name,
               ARGS=info.arg_implementation_declaration)
 
   def _GenerateLibFile(self, lib_template, lib_file_path, file_paths):
     """Generates a lib file from a template and a list of files."""
     # Load template.
-    template = ''.join(open(lib_template).readlines())
+    template = self._templates.Load(lib_template)
     # Generate the .lib file.
     lib_file_contents = self._emitters.FileEmitter(lib_file_path)
 
     # Emit the list of #source directives.
     list_emitter = lib_file_contents.Emit(template)
     lib_file_dir = os.path.dirname(lib_file_path)
     for path in sorted(file_paths):
       relpath = os.path.relpath(path, lib_file_dir)
       list_emitter.Emit("#source('$PATH');\n", PATH=relpath)
 
@@ skipping 18 matching lines @@
 
     result = set()
     WalkParentChain(interface)
     return result;
 
 
 # ------------------------------------------------------------------------------
 
 class WrappingInterfacesSystem(System):
 
-  def __init__(self, database, emitters, output_dir):
+  def __init__(self, templates, database, emitters, output_dir):
     super(WrappingInterfacesSystem, self).__init__(
-        database, emitters, output_dir)
+        templates, database, emitters, output_dir)
     self._dart_interface_file_paths = []
 
 
   def InterfaceGenerator(self,
                          interface,
                          common_prefix,
                          super_interface_name,
                          source_filter):
     """."""
     interface_name = interface.id
     dart_interface_file_path = self._FilePathForDartInterface(interface_name)
 
     self._dart_interface_file_paths.append(dart_interface_file_path)
 
     dart_interface_code = self._emitters.FileEmitter(dart_interface_file_path)
 
-    template_file = 'template_interface_%s.darttemplate' % interface_name
-    if not os.path.exists(template_file):
-      template_file = 'template_interface.darttemplate'
-    template = ''.join(open(template_file).readlines())
+    template_file = 'interface_%s.darttemplate' % interface_name
+    template = self._templates.TryLoad(template_file)
+    if not template:
+      template = self._templates.Load('interface.darttemplate')
 
     return DartInterfaceGenerator(
         interface, dart_interface_code,
         template,
         common_prefix, super_interface_name,
         source_filter)
 
   def ProcessCallback(self, interface, info):
     """Generates a typedef for the callback interface."""
     interface_name = interface.id
     file_path = self._FilePathForDartInterface(interface_name)
     self._ProcessCallback(interface, info, file_path)
 
   def GenerateLibraries(self, lib_dir):
     # Library generated for implementation.
     self._GenerateLibFile(
-        'template_wrapping_dom.darttemplate',
+        'wrapping_dom.darttemplate',
         os.path.join(lib_dir, 'wrapping_dom.dart'),
         (self._dart_interface_file_paths +
          self._dart_callback_file_paths +
          # FIXME: Move the implementation to a separate
          # library.
          self._implementation_system._dart_wrapping_file_paths
          ))
 
 
   def _FilePathForDartInterface(self, interface_name):
     """Returns the file path of the Dart interface definition."""
     return os.path.join(self._output_dir, 'src', 'interface',
                         '%s.dart' % interface_name)
 
 
 # ------------------------------------------------------------------------------
 
 class WrappingImplementationSystem(System):
 
-  def __init__(self, database, emitters, output_dir):
+  def __init__(self, templates, database, emitters, output_dir):
     """Prepared for generating wrapping implementation.
 
     - Creates emitter for JS code.
     - Creates emitter for Dart code.
     """
     super(WrappingImplementationSystem, self).__init__(
-        database, emitters, output_dir)
+        templates, database, emitters, output_dir)
     self._dart_wrapping_file_paths = []
 
     js_file_name = os.path.join(output_dir, 'wrapping_dom.js')
     code = self._emitters.FileEmitter(js_file_name)
-    template = ''.join(open('template_wrapping_dom.js').readlines())
+    template = self._templates.Load('wrapping_dom.js')
     (self._wrapping_js_natives,
      self._wrapping_map) = code.Emit(template)
 
     _logger.info('Started Generating %s' % js_file_name)
 
     # Set of (interface, name, kind), kind is 'attribute' or 'operation'.
     self._wrapping_externs = set()
 
 
   def InterfaceGenerator(self,
                          interface,
                          common_prefix,
                          super_interface_name,
                          source_filter):
     """."""
     interface_name = interface.id
     dart_wrapping_file_path = self._FilePathForDartWrappingImpl(interface_name)
 
     self._dart_wrapping_file_paths.append(dart_wrapping_file_path)
 
     dart_code = self._emitters.FileEmitter(dart_wrapping_file_path)
-    dart_code.Emit(
-        ''.join(open('template_wrapping_impl.darttemplate').readlines()))
+    dart_code.Emit(self._templates.Load('wrapping_impl.darttemplate'))
     return WrappingInterfaceGenerator(interface, super_interface_name,
                                       dart_code, self._wrapping_js_natives,
                                       self._wrapping_map,
                                       self._wrapping_externs,
                                       self._BaseDefines(interface))
 
   def ProcessCallback(self, interface, info):
     pass
 
   def GenerateLibraries(self, lib_dir):
@@ skipping 11 matching lines @@
   def _GenerateJavaScriptExternsWrapping(self, database, output_dir):
     """Generates a JavaScript externs file.
 
     Generates an externs file that is consistent with generated JavaScript code
     and Dart APIs for the wrapping implementation.
     """
     externs_file_name = os.path.join(output_dir, 'wrapping_dom_externs.js')
     code = self._emitters.FileEmitter(externs_file_name)
     _logger.info('Started generating %s' % externs_file_name)
 
-    template = ''.join(open('template_wrapping_dom_externs.js').readlines())
+    template = self._templates.Load('wrapping_dom_externs.js')
     namespace = 'dom_externs'
     members = code.Emit(template, NAMESPACE=namespace)
 
     # TODO: Filter out externs that are known to the JavaScript back-end.  Some
     # of the known externs have useful declarations like @nosideeffects that
     # might improve back-end analysis.
 
     names = dict()  # maps name to (interface, kind)
     for (interface, name, kind) in self._wrapping_externs:
       if name not in _javascript_keywords:
@@ skipping 13 matching lines @@
       for (interface, kind) in sorted(names[name]):
         members.Emit('$SEP $KIND $INTERFACE.$NAME',
                      NAME=name, INTERFACE=interface, KIND=kind, SEP=separator)
         separator = ','
       members.Emit('\n')
 
 # ------------------------------------------------------------------------------
 
 class FrogSystem(System):
 
-  def __init__(self, database, emitters, output_dir):
-    super(FrogSystem, self).__init__(database, emitters, output_dir)
+  def __init__(self, templates, database, emitters, output_dir):
+    super(FrogSystem, self).__init__(
+        templates, database, emitters, output_dir)
     self._dart_frog_file_paths = []
 
   def InterfaceGenerator(self,
                          interface,
                          common_prefix,
                          super_interface_name,
                          source_filter):
     """."""
     dart_frog_file_path = self._FilePathForFrogImpl(interface.id)
 
     self._dart_frog_file_paths.append(dart_frog_file_path)
 
     dart_code = self._emitters.FileEmitter(dart_frog_file_path)
-    dart_code.Emit(
-        ''.join(open('template_frog_impl.darttemplate').readlines()))
+    dart_code.Emit(self._templates.Load('frog_impl.darttemplate'))
     return FrogInterfaceGenerator(interface, super_interface_name,
                                   dart_code)
 
   def ProcessCallback(self, interface, info):
     """Generates a typedef for the callback interface."""
     file_path = self._FilePathForFrogImpl(interface.id)
     self._ProcessCallback(interface, info, file_path)
 
   def GenerateLibraries(self, lib_dir):
     self._GenerateLibFile(
-        'template_frog_dom.darttemplate',
+        'frog_dom.darttemplate',
         os.path.join(lib_dir, 'dom_frog.dart'),
         self._dart_frog_file_paths +
         self._dart_callback_file_paths)
 
   def Finish(self):
     pass
 
   def _FilePathForFrogImpl(self, interface_name):
     """Returns the file path of the Frog implementation."""
     return os.path.join(self._output_dir, 'src', 'frog',
@@ skipping 646 matching lines @@
           '$!FALSE'
           '$(INDENT)}\n',
           COND=test, INDENT=indent)
       fallthrough1 = self.GenerateDispatch(
           true_code, info, indent + '  ', position + 1, positive)
       fallthrough2 = self.GenerateDispatch(
           false_code, info, indent + '  ', position, negative)
       return fallthrough1 or fallthrough2
 
     if negative:
-      raise 'Internal error, must be all positive'
+      raise Exception('Internal error, must be all positive')
 
     # All overloads require the same test.  Do we bother?
 
     # If the test is the same as the method's formal parameter then checked mode
     # will have done the test already. (It could be null too but we ignore that
     # case since all the overload behave the same and we don't know which types
     # in the IDL are not nullable.)
     if type == param_type:
       return self.GenerateDispatch(
           emitter, info, indent, position + 1, positive)
@@ skipping 225 matching lines @@
     Arguments:
       info: An OperationInfo object.
     """
     # TODO(vsm): Handle overloads.
     self._members_emitter.Emit(
         '\n'
         '  $TYPE $NAME($ARGS) native;\n',
         TYPE=info.type_name,
         NAME=info.name,
         ARGS=info.arg_implementation_declaration)