start of code to generate dart:html using dart:dom scripts

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
@@ skipping 358 matching lines @@
     """
 
     self._emitters = multiemitter.MultiEmitter()
     self._database = database
     self._output_dir = output_dir
 
     self._ComputeInheritanceClosure()
 
     self._systems = []
 
+    # TODO(jmesserly): only create these if needed
     interface_system = InterfacesSystem(
         TemplateLoader(self._template_dir, ['dom/interface', 'dom', '']),
         self._database, self._emitters, self._output_dir)
     self._systems.append(interface_system)
 
+    html_interface_system = HtmlInterfacesSystem(
+        TemplateLoader(self._template_dir, ['html/interface', 'html', '']),
+        self._database, self._emitters, self._output_dir)
+    self._systems.append(html_interface_system)
+
     if 'native' in systems:
       native_system = NativeImplementationSystem(
           TemplateLoader(self._template_dir, ['dom/native', 'dom', '']),
           self._database, self._emitters, self._auxiliary_dir,
           self._output_dir)
 
       self._systems.append(native_system)
 
     if 'wrapping' in systems:
       wrapping_system = WrappingImplementationSystem(
@@ skipping 16 matching lines @@
       self._systems.append(dummy_system)
 
     if 'frog' in systems:
       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', '']),
+          self._database, self._emitters, self._output_dir)
+
+      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', '']),
+          self._database, self._emitters, self._output_dir)
+
+      html_system._interface_system = html_interface_system
+      self._systems.append(html_system)
 
     # Render all interfaces into Dart and save them in files.
     for interface in database.GetInterfaces():
 
       super_interface = None
       super_name = interface.id
 
       if not _MatchSourceFilter(source_filter, interface):
         # Skip this interface since it's not present in the required source
         _logger.info('Omitting interface - %s' % interface.id)
@@ skipping 46 matching lines @@
                   for system in self._systems]
 
     for generator in generators:
       generator.StartInterface()
 
     for const in sorted(interface.constants, ConstantOutputOrder):
       for generator in generators:
         generator.AddConstant(const)
 
     attributes = [attr for attr in interface.attributes
-                  if not self._OmitAttribute(interface, attr)]
+                  if not self._IsEventAttribute(interface, attr)]
     for (getter, setter) in  _PairUpAttributes(attributes):
       for generator in generators:
         generator.AddAttribute(getter, setter)
 
+    events = _PairUpAttributes([attr for attr in interface.attributes
+                  if self._IsEventAttribute(interface, attr)])
+    if events:
+      for generator in generators:
+        generator.AddEventAttributes(events)
+
     # The implementation should define an indexer if the interface directly
     # extends List.
     element_type = MaybeListElementType(interface)
     if element_type:
       for generator in generators:
         generator.AddIndexer(element_type)
 
     # Group overloaded operations by id
     operationsById = {}
     for operation in interface.operations:
@@ skipping 34 matching lines @@
         if not any(op.id == id for op in interface.operations):
           operations = operationsById[id]
           info = _AnalyzeOperation(interface, operations)
           for generator in generators:
             generator.AddSecondaryOperation(parent_interface, info)
 
     for generator in generators:
       generator.FinishInterface()
     return
 
-  def _OmitAttribute(self, interface, attr):
+  def _IsEventAttribute(self, interface, attr):
     # Remove EventListener attributes like 'onclick' when addEventListener
     # is available.
     if attr.type.id == 'EventListener':
       if 'EventTarget' in self._AllImplementedInterfaces(interface):
         return True
     return False
 
   def _DefinesSameAttribute(self, interface, attr1):
     return any(attr1.id == attr2.id
                and attr1.is_fc_getter == attr2.is_fc_getter
@@ skipping 419 matching lines @@
 
 
   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 HtmlInterfacesSystem(System):
+
+  def __init__(self, templates, database, emitters, output_dir):
+    super(HtmlInterfacesSystem, self).__init__(
+        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 = 'interface_%s.darttemplate' % interface_name
+    template = self._templates.TryLoad(template_file)
+    if not template:
+      template = self._templates.Load('interface.darttemplate')
+
+    return HtmlDartInterfaceGenerator(
+        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):
+    pass
+
+
+  def _FilePathForDartInterface(self, interface_name):
+    """Returns the file path of the Dart interface definition."""
+    # TODO(jmesserly): is this the right path
+    return os.path.join(self._output_dir, 'html', 'interface',
+                        '%s.dart' % interface_name)
+
+
+# ------------------------------------------------------------------------------
+
 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)
 
@@ skipping 92 matching lines @@
     """."""
     dart_frog_file_path = self._FilePathForFrogImpl(interface.id)
     self._dart_frog_file_paths.append(dart_frog_file_path)
 
     template_file = 'impl_%s.darttemplate' % interface.id
     template = self._templates.TryLoad(template_file)
     if not template:
       template = self._templates.Load('frog_impl.darttemplate')
 
     dart_code = self._emitters.FileEmitter(dart_frog_file_path)
-    # dart_code.Emit(self._templates.Load('frog_impl.darttemplate'))
     return FrogInterfaceGenerator(self, interface, template,
                                   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(
         'frog_dom.darttemplate',
         os.path.join(lib_dir, 'dom_frog.dart'),
         (self._interface_system._dart_interface_file_paths +
          self._interface_system._dart_callback_file_paths +
          self._dart_frog_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',
                         '%s.dart' % interface_name)
 
+
+# ------------------------------------------------------------------------------
+
+class HtmlFrogSystem(System):
+
+  def __init__(self, templates, database, emitters, output_dir):
+    super(HtmlFrogSystem, 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)
+
+    template_file = 'impl_%s.darttemplate' % interface.id
+    template = self._templates.TryLoad(template_file)
+    if not template:
+      template = self._templates.Load('frog_impl.darttemplate')
+
+    dart_code = self._emitters.FileEmitter(dart_frog_file_path)
+    return HtmlFrogInterfaceGenerator(self, interface, template,
+                                  super_interface_name, dart_code)
+
+  def GenerateLibraries(self, lib_dir):
+    self._GenerateLibFile(
+        'html_frog.darttemplate',
+        os.path.join(lib_dir, 'html_frog.dart'),
+        (self._interface_system._dart_interface_file_paths +
+         self._interface_system._dart_callback_file_paths +
+         self._dart_frog_file_paths))
+
+  def Finish(self):
+    pass
+
+  def _FilePathForFrogImpl(self, interface_name):
+    """Returns the file path of the Frog implementation."""
+    # TODO(jmesserly): is this the right path
+    return os.path.join(self._output_dir, 'html', 'frog',
+                        '%s.dart' % interface_name)
+
 # ------------------------------------------------------------------------------
 
 class DartInterfaceGenerator(object):
   """Generates Dart Interface definition for one DOM IDL interface."""
 
   def __init__(self, interface, emitter, template,
                common_prefix, super_interface, source_filter):
     """Generates Dart code for the given interface.
 
     Args:
@@ skipping 122 matching lines @@
                                NAME=info.name,
                                PARAMS=info.ParametersInterfaceDeclaration())
 
   # Interfaces get secondary members directly via the superinterfaces.
   def AddSecondaryAttribute(self, interface, getter, setter):
     pass
 
   def AddSecondaryOperation(self, interface, attr):
     pass
 
+  def AddEventAttributes(self, event_attrs):
+    pass
 
 # Given a sorted sequence of type identifiers, return an appropriate type
 # name
 def TypeName(typeIds, interface):
   # Dynamically type this field for now.
   return 'var'
 
+# ------------------------------------------------------------------------------
+
+# TODO(jmesserly): inheritance is probably not the right way to factor this long
+# term, but it makes merging better for now.
+class HtmlDartInterfaceGenerator(DartInterfaceGenerator):
+  """Generates Dart Interface definition for one DOM IDL interface."""
+
+  def __init__(self, interface, emitter, template,
+               common_prefix, super_interface, source_filter):
+    super(HtmlDartInterfaceGenerator, self).__init__(interface,
+      emitter, template, common_prefix, super_interface, source_filter)
+
+  def AddEventAttributes(self, event_attrs):
+    events_interface = self._interface.id + 'Events'
+    self._members_emitter.Emit('\n  $TYPE get on();\n',
+                               TYPE=events_interface)
+    events_members = self._emitter.Emit(
+        '\ninterface $INTERFACE {\n$!MEMBERS}\n',
+        INTERFACE=events_interface)
+
+    for getter, setter in event_attrs:
+      event = getter or setter
+      events_members.Emit('\n  EventListenerList get $NAME();\n', NAME=event.id)
+
 
 # ------------------------------------------------------------------------------
 
 class DummyInterfaceGenerator(object):
   """Generates nothing."""
 
   def __init__(self, system, interface):
     pass
 
   def StartInterface(self):
@@ skipping 16 matching lines @@
 
   def AddIndexer(self, element_type):
     pass
 
   def AddTypedArrayConstructors(self, element_type):
     pass
 
   def AddOperation(self, info):
     pass
 
+  def AddEventAttributes(self, event_attrs):
+    pass
+
 # ------------------------------------------------------------------------------
 
 class WrappingInterfaceGenerator(object):
   """Generates Dart and JS implementation for one DOM IDL interface."""
 
   def __init__(self, interface, super_interface, dart_code, base_members):
     """Generates Dart and JS code for the given interface.
 
     Args:
 
@@ skipping 108 matching lines @@
         NAME=attr.id, TYPE=attr.type.id, METHOD=method_name)
 
   def AddSecondaryAttribute(self, interface, getter, setter):
     self._SecondaryContext(interface)
     self.AddAttribute(getter, setter)
 
   def AddSecondaryOperation(self, interface, info):
     self._SecondaryContext(interface)
     self.AddOperation(info)
 
+  def AddEventAttributes(self, event_attrs):
+    pass
+
   def _SecondaryContext(self, interface):
     if interface is not self._current_secondary_parent:
       self._current_secondary_parent = interface
       self._members_emitter.Emit('\n  // From $WHERE\n', WHERE=interface.id)
 
   def AddIndexer(self, element_type):
     """Adds all the methods required to complete implementation of List."""
     # We would like to simply inherit the implementation of everything except
     # get length(), [], and maybe []=.  It is possible to extend from a base
     # array implementation class only when there is no other implementation
@@ skipping 477 matching lines @@
         NAME=attr.id, TYPE=self._NarrowInputType(attr.type.id))
 
   def AddSecondaryAttribute(self, interface, getter, setter):
     self._SecondaryContext(interface)
     self.AddAttribute(getter, setter)
 
   def AddSecondaryOperation(self, interface, info):
     self._SecondaryContext(interface)
     self.AddOperation(info)
 
+  def AddEventAttributes(self, event_attrs):
+    pass
+
   def _SecondaryContext(self, interface):
     if interface is not self._current_secondary_parent:
       self._current_secondary_parent = interface
       self._members_emitter.Emit('\n  // From $WHERE\n', WHERE=interface.id)
 
   def AddIndexer(self, element_type):
     """Adds all the methods required to complete implementation of List."""
     # We would like to simply inherit the implementation of everything except
     # get length(), [], and maybe []=.  It is possible to extend from a base
     # array implementation class only when there is no other implementation
@@ skipping 60 matching lines @@
         '\n'
         '  $TYPE $NAME($PARAMS) native;\n',
         TYPE=self._NarrowOutputType(info.type_name),
         NAME=info.name,
         PARAMS=info.ParametersImplementationDeclaration(
             lambda type_name: self._NarrowInputType(type_name)))
 
 
 # ------------------------------------------------------------------------------
 
+# TODO(jmesserly): inheritance is probably not the right way to factor this long
+# term, but it makes merging better for now.
+class HtmlFrogInterfaceGenerator(FrogInterfaceGenerator):
+  """Generates a Frog class for the dart:html library from a DOM IDL
+  interface.
+  """
+
+  def __init__(self, system, interface, template, super_interface, dart_code):
+    super(HtmlFrogInterfaceGenerator, self).__init__(
+        system, interface, template, super_interface, dart_code)
+
+  def AddEventAttributes(self, event_attrs):
+    events_class = self._interface.id + 'EventsImpl'
+    events_interface = self._interface.id + 'Events'
+    self._members_emitter.Emit('\n  $TYPE get on() =>\n    new $TYPE(this);\n',
+                               TYPE=events_class)
+
+    events_members = self._dart_code.Emit(
+        '\n'
+        'class $CLASSNAME extends EventsImplementation '
+            'implements $INTERFACE {\n'
+        '  $CLASSNAME(_ptr) : super._wrap(_ptr);\n'
+        '$!MEMBERS}\n',
+        CLASSNAME=events_class,
+        INTERFACE=events_interface)
+
+    for getter, setter in event_attrs:
+      event = getter or setter
+      events_members.Emit(
+          "\n"
+          "EventListenerList get $NAME() => _get('$NAME');\n",
+          NAME=event.id)
+
+
+# ------------------------------------------------------------------------------
+
 class NativeImplementationSystem(System):
 
   def __init__(self, templates, database, emitters, auxiliary_dir, output_dir):
     super(NativeImplementationSystem, self).__init__(
         templates, database, emitters, output_dir)
 
     self._auxiliary_dir = auxiliary_dir
     self._dom_public_files = []
     self._dom_impl_files = []
 
@@ skipping 190 matching lines @@
                    INDENT=indent,
                    NATIVENAME=native_name,
                    ARGS=argument_expressions)
 
     self._members_emitter.Emit('  $TYPE $NATIVE_NAME($PARAMS) native '
                                '"$(INTERFACE)$(NATIVE_NAME)_Callback";\n',
                                NATIVE_NAME=native_name,
                                TYPE=info.type_name,
                                PARAMS=', '.join(arg_names),
                                INTERFACE=self._interface.id)