Add conditional feature to templates.

client/dom/scripts/dartgenerator.py

 #!/usr/bin/python
 # Copyright (c) 2012, 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
 import multiemitter
 import os
 import re
 import shutil
 from generator import *
 from systembase import *
 from systemfrog import *
 from systemhtml import *
 from systeminterface import *
 from systemnative import *
 from systemwrapping import *
+from templateloader import TemplateLoader
 
 _logger = logging.getLogger('dartgenerator')
 
 def MergeNodes(node, other):
   node.operations.extend(other.operations)
   for attribute in other.attributes:
     if not node.has_attribute(attribute):
       node.attributes.append(attribute)
 
   node.constants.extend(other.constants)
@@ skipping 243 matching lines @@
       frog_system = FrogSystem(
           TemplateLoader(self._template_dir, ['dom/frog', 'dom', '']),
           self._database, self._emitters, self._output_dir)
 
       frog_system._interface_system = interface_system
       self._systems.append(frog_system)
 
     if 'htmlfrog' in systems:
       html_system = HtmlFrogSystem(
           TemplateLoader(self._template_dir,
-              ['html/frog', 'html/impl', 'html', '']),
+                         ['html/frog', 'html/impl', 'html', ''],
+                         {'DARTIUM': False, 'FROG': True}),
           self._database, self._emitters, self._output_dir, self)
 
       html_system._interface_system = html_interface_system
       self._systems.append(html_system)
 
     if 'htmldartium' in systems:
       html_system = HtmlDartiumSystem(
           TemplateLoader(self._template_dir,
-              ['html/dartium', 'html/impl', 'html', '']),
+                         ['html/dartium', 'html/impl', 'html', ''],
+                         {'DARTIUM': True, 'FROG': False}),
           self._database, self._emitters, self._output_dir, self)
 
       html_system._interface_system = html_interface_system
       self._systems.append(html_system)
 
     # Collect interfaces
     interfaces = []
     for interface in database.GetInterfaces():
       if not MatchSourceFilter(source_filter, interface):
         # Skip this interface since it's not present in the required source
@@ skipping 231 matching lines @@
   setters = {}
   for attr in attributes:
     if attr.is_fc_getter:
       getters[attr.id] = attr
     elif attr.is_fc_setter and 'Replaceable' not in attr.ext_attrs:
       setters[attr.id] = attr
   return [(getters.get(id), setters.get(id)) for id in names]
 
 # ------------------------------------------------------------------------------
 
-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 DummyImplementationSystem(System):
   """Generates a dummy implementation for use by the editor analysis.
 
   All the code comes from hand-written library files.
   """
 
   def __init__(self, templates, database, emitters, output_dir):
     super(DummyImplementationSystem, self).__init__(
         templates, database, emitters, output_dir)
     factory_providers_file = os.path.join(self._output_dir, 'src', 'dummy',
@@ skipping 66 matching lines @@
     pass
 
   def AddTypedArrayConstructors(self, element_type):
     pass
 
   def AddOperation(self, info):
     pass
 
   def AddEventAttributes(self, event_attrs):
     pass