Get rid of System class.

lib/html/scripts/systemhtml.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 provides shared functionality for the system to generate
 Dart:html APIs from the IDL database."""
 
 import emitter
 
 from systembase import *
-from systeminterface import *
 
 _js_custom_members = set([
     'CSSStyleDeclaration.setProperty',
     'Element.insertAdjacentElement',
     'Element.insertAdjacentHTML',
     'Element.insertAdjacentText',
     'Element.remove',
     'ElementEvents.mouseWheel',
     'IDBDatabase.transaction',
     'IFrameElement.contentWindow',
@@ skipping 351 matching lines @@
       event_names.add(manual_event_name)
 
   return sorted(event_names, key=lambda name: _html_event_names[name])
 
 def DomToHtmlEvent(event_name):
   assert event_name in _html_event_names, \
          'No known html event name for event: ' + event_name
   return _html_event_names[event_name]
 
 # ------------------------------------------------------------------------------
 class HtmlSystemShared(object):

[Anton Muhin, 2012/10/01 13:30:35]

this class becomes pretty thin and many of methods look like perfect
freestanding functions (e.g. IsPrivate and many more).

Do we really need it as a class at all?

The only shared state seems to be _event_classes, but it's not trivial to
understand who operates on it.

[podivilov, 2012/10/01 14:49:18]

I have another cl to fix this: http://codereview.chromium.org/11020008/.

 
-  def __init__(self, context):
+  def __init__(self, database):
     self._event_classes = set()
-    self._seen_event_names = {}
-    self._database = context.database
-
-  # TODO(jacobr): this already exists
-  def _TraverseParents(self, interface, callback):
-    for parent in interface.parents:
-      parent_id = parent.type.id
-      if self._database.HasInterface(parent_id):
-        parent_interface = self._database.GetInterface(parent_id)
-        callback(parent_interface)
-        self._TraverseParents(parent_interface, callback)
+    self._database = database
 
   # TODO(jacobr): this isn't quite right....
   def GetParentsEventsClasses(self, interface):
     # Ugly hack as we don't specify that Document and DocumentFragment inherit
     # from Element in our IDL.
     if interface.id == 'Document' or interface.id == 'DocumentFragment':
       return ['ElementEvents']
 
     interfaces_with_events = set()
-    def visit(parent):
-      if parent.id in self._event_classes:
+    for parent in self._database.Hierarchy(interface):
+      if parent != interface and parent.id in self._event_classes:

[Anton Muhin, 2012/10/01 13:30:35]

when parent can equal to some of interface in hiearchy?

[podivilov, 2012/10/01 14:49:18]

database.Hierarchy() includes the interface itself (this is what most callers
actually need).

         interfaces_with_events.add(parent)
 
-    self._TraverseParents(interface, visit)
     if len(interfaces_with_events) == 0:
       return ['Events']
     else:
       names = []
       for interface in interfaces_with_events:
         names.append(interface.id + 'Events')
       return names
 
   def GetParentEventsClass(self, interface):
     parent_event_classes = self.GetParentsEventsClasses(interface)
     if len(parent_event_classes) != 1:
       raise Exception('Only one parent event class allowed ' + interface.id)
     return parent_event_classes[0]
 
   # This returns two values: the first is whether or not an "on" property should
   # be generated for the interface, and the second is the event attributes to
   # generate if it should.
   def GetEventAttributes(self, interface):
     events =  set([attr for attr in interface.attributes
                    if attr.type.id == 'EventListener'])
 
     if events or interface.id in _html_explicit_event_classes:
       return True, events
     else:
       return False, None
 
   def IsPrivate(self, name):
     return name.startswith('_')
 
-
-class HtmlInterfacesSystem(System):
-  def __init__(self, options, dart_library_generator, backend_factory):
-    super(HtmlInterfacesSystem, self).__init__(options)
-    self._dart_library_generator = dart_library_generator
-    self._backend_factory = backend_factory
-    self._shared = HtmlSystemShared(options)
-    self._elements_factory_emitter = None
-
-  def ProcessInterface(self, interface):
-    backend = self._backend_factory(interface)
-    HtmlDartInterfaceGenerator(self, interface, backend).Generate()
-
-  def _CreateEmitter(self, filename):
-    return self._dart_library_generator.CreateFileEmitter(filename)
-
 # ------------------------------------------------------------------------------
 
 class HtmlDartInterfaceGenerator(BaseGenerator):
   """Generates dart interface and implementation for the DOM IDL interface."""
 
-  def __init__(self, system, interface, backend):
-    super(HtmlDartInterfaceGenerator, self).__init__(
-        system._database, system._type_registry, interface)
-    self._system = system
+  def __init__(self, shared, options, library_emitter, interface, backend):
+    super(HtmlDartInterfaceGenerator, self).__init__(None, None, interface)
+    self._renamer = options.renamer
+    self._database = options.database
+    self._template_loader = options.templates
+    self._type_registry = options.type_registry
+    self._library_emitter = library_emitter
     self._backend = backend
-    self._shared = system._shared
-    self._html_interface_name = system._renamer.RenameInterface(self._interface)
+    self._shared = shared
+    self._html_interface_name = options.renamer.RenameInterface(self._interface)
 
   def GenerateCallback(self, info):
     """Generates a typedef for the callback interface."""
-    code = self._system._CreateEmitter('%s.dart' % self._interface.id)
-    code.Emit(self._system._templates.Load('callback.darttemplate'))
+    code = self._library_emitter.FileEmitter(self._interface.id)
+    code.Emit(self._template_loader.Load('callback.darttemplate'))
     code.Emit('typedef $TYPE $NAME($PARAMS);\n',
               NAME=self._interface.id,
               TYPE=DartType(info.type_name),
               PARAMS=info.ParametersImplementationDeclaration(DartType))
     self._backend.GenerateCallback(info)
 
   def StartInterface(self):
     if (not self._interface.id in _merged_html_interfaces and
         # Don't re-generate types that have been converted to native dart types.
         self._html_interface_name not in nativified_classes):
-      path = '%s.dart' % self._html_interface_name
-      self._interface_emitter = self._system._CreateEmitter(path)
+      self._interface_emitter = self._library_emitter.FileEmitter(
+          self._html_interface_name)
     else:
       self._interface_emitter = emitter.Emitter()
 
     template_file = 'interface_%s.darttemplate' % self._html_interface_name
-    interface_template = (self._system._templates.TryLoad(template_file) or
-                          self._system._templates.Load('interface.darttemplate'))
+    interface_template = (self._template_loader.TryLoad(template_file) or
+                          self._template_loader.Load('interface.darttemplate'))
 
     typename = self._html_interface_name
 
     implements = []
     suppressed_implements = []
 
     for parent in self._interface.parents:
       # TODO(vsm): Remove source_filter.
       if MatchSourceFilter(parent):
         # Parent is a DOM type.
@@ skipping 17 matching lines @@
 
     factory_provider = None
     if typename in interface_factories:
       factory_provider = interface_factories[typename]
 
     constructors = []
     constructor_info = AnalyzeConstructor(self._interface)
     if constructor_info:
       constructors.append(constructor_info)
       factory_provider = '_' + typename + 'FactoryProvider'
-      factory_provider_emitter = self._system._CreateEmitter(
-          '_%sFactoryProvider.dart' % self._html_interface_name)
+      factory_provider_emitter = self._library_emitter.FileEmitter(
+          '_%sFactoryProvider' % self._html_interface_name)
       self._backend.EmitFactoryProvider(
           constructor_info, factory_provider, factory_provider_emitter)
 
     infos = HtmlElementConstructorInfos(typename)
     if infos:
-      if not self._system._elements_factory_emitter:
-        file_emitter = self._system._CreateEmitter('_Elements.dart')
-        template = self._system._templates.Load(
-            'factoryprovider_Elements.darttemplate')
-        self._system._elements_factory_emitter = file_emitter.Emit(template)
+      template = self._template_loader.Load(
+          'factoryprovider_Elements.darttemplate')
       EmitHtmlElementFactoryConstructors(
-          self._system._elements_factory_emitter,
+          self._library_emitter.FileEmitter('_Elements', template),
           infos,
           self._html_interface_name,
           self._backend.ImplementationClassName())
 
     for info in infos:
       constructors.append(info.ConstructorInfo(typename))
       if factory_provider:
         assert factory_provider == info.factory_provider_name
       else:
         factory_provider = info.factory_provider_name
 
     # TODO(vsm): Add appropriate package / namespace syntax.
     (self._type_comment_emitter,
      self._members_emitter,
      self._top_level_emitter) = self._interface_emitter.Emit(
          interface_template + '$!TOP_LEVEL',
          ID=typename,
          EXTENDS=implements_str)
 
     self._type_comment_emitter.Emit("/// @domName $DOMNAME",
         DOMNAME=self._interface.doc_js_name)
 
     if self._backend.HasImplementation():
       if not self._interface.id in _merged_html_interfaces:
         name = self._html_interface_name
         if self._html_interface_name in nativified_classes:
           name = nativified_classes[self._html_interface_name]
-        filename = '%sImpl.dart' % name
+        basename = '%sImpl' % name
       else:
-        filename = '%sImpl_Merged.dart' % self._html_interface_name
-      self._implementation_emitter = self._system._CreateEmitter(filename)
+        basename = '%sImpl_Merged' % self._html_interface_name
+      self._implementation_emitter = self._library_emitter.FileEmitter(basename)
     else:
       self._implementation_emitter = emitter.Emitter()
     self._backend.SetImplementationEmitter(self._implementation_emitter)
     self._implementation_members_emitter = self._backend.StartInterface()
 
     for constructor_info in constructors:
       constructor_info.GenerateFactoryInvocation(
           self._DartType, self._members_emitter, factory_provider)
 
     element_type = MaybeTypedArrayElementTypeInHierarchy(
-        self._interface, self._system._database)
+        self._interface, self._database)
     if element_type:
       self._members_emitter.Emit(
           '\n'
           '  factory $CTOR(int length) =>\n'
           '    $FACTORY.create$(CTOR)(length);\n'
           '\n'
           '  factory $CTOR.fromList(List<$TYPE> list) =>\n'
           '    $FACTORY.create$(CTOR)_fromList(list);\n'
           '\n'
           '  factory $CTOR.fromBuffer(ArrayBuffer buffer, [int byteOffset, int length]) => \n'
@@ skipping 14 matching lines @@
     self._backend = old_backend
 
   def AddIndexer(self, element_type):
     self._backend.AddIndexer(element_type)
 
   def AmendIndexer(self, element_type):
     self._backend.AmendIndexer(element_type)
 
   def AddAttribute(self, attribute, is_secondary=False):
     dom_name = DartDomNameOfAttribute(attribute)
-    html_name = self._system._renamer.RenameMember(
+    html_name = self._renamer.RenameMember(
       self._interface.id, dom_name, 'get:')
     if not html_name or self._shared.IsPrivate(html_name):
       return
 
 
-    html_setter_name = self._system._renamer.RenameMember(
+    html_setter_name = self._renamer.RenameMember(
         self._interface.id, dom_name, 'set:')
     read_only = IsReadOnly(attribute) or not html_setter_name
 
     # We don't yet handle inconsistent renames of the getter and setter yet.
     assert(not html_setter_name or html_name == html_setter_name)
 
     if not is_secondary:
       self._members_emitter.Emit('\n  /** @domName $DOMINTERFACE.$DOMNAME */',
           DOMINTERFACE=attribute.doc_js_interface_name,
           DOMNAME=dom_name)
@@ skipping 11 matching lines @@
   def AddSecondaryAttribute(self, interface, attribute):
     self._backend.SecondaryContext(interface)
     self.AddAttribute(attribute, True)
 
   def AddOperation(self, info, skip_declaration=False):
     """
     Arguments:
       operations - contains the overloads, one or more operations with the same
         name.
     """
-    html_name = self._system._renamer.RenameMember(self._interface.id, info.name)
+    html_name = self._renamer.RenameMember(self._interface.id, info.name)
     if not html_name:
       if info.name == 'item':
         # FIXME: item should be renamed to operator[], not removed.
         self._backend.AddOperation(info, '_item')
       return
 
     if not self._shared.IsPrivate(html_name) and not skip_declaration:
       self._members_emitter.Emit('\n  /** @domName $DOMINTERFACE.$DOMNAME */',
           DOMINTERFACE=info.overloads[0].doc_js_interface_name,
           DOMNAME=info.name)
@@ skipping 44 matching lines @@
 
     self._EmitEventGetter(events_interface, events_class)
 
     events_members = self._interface_emitter.Emit(
         '\nabstract class $INTERFACE implements $PARENTS {\n$!MEMBERS}\n',
         INTERFACE=events_interface,
         PARENTS=', '.join(
             self._shared.GetParentsEventsClasses(self._interface)))
 
     template_file = 'impl_%s.darttemplate' % events_interface
-    template = (self._system._templates.TryLoad(template_file) or
+    template = (self._template_loader.TryLoad(template_file) or
         '\n'
         'class $CLASSNAME extends $SUPER implements $INTERFACE {\n'
         '  $CLASSNAME(_ptr) : super(_ptr);\n'
         '$!MEMBERS}\n')
 
     # TODO(jacobr): specify the type of _ptr as EventTarget
     implementation_events_members = self._implementation_emitter.Emit(
         template,
         CLASSNAME=events_class,
         INTERFACE=events_interface,
@@ skipping 579 matching lines @@
 
           return FindInParent(
               self._database.GetInterface(parent_interface_name))
       return (None, None)
 
     return FindInParent(self._interface) if attr else (None, None)
 
 # ------------------------------------------------------------------------------
 
 class DartLibraryEmitter():
-  def __init__(self, emitters, template, dart_sources_dir):
-    self._emitters = emitters
+  def __init__(self, multiemitter, template, dart_sources_dir):
+    self._multiemitter = multiemitter
     self._template = template
     self._dart_sources_dir = dart_sources_dir
-    self._dart_sources_list = []
+    self._path_to_emitter = {}
 
-  def CreateFileEmitter(self, filename):
-    path = os.path.join(self._dart_sources_dir, filename)
-    self._dart_sources_list.append(path)
-    return self._emitters.FileEmitter(path)
+  def FileEmitter(self, basename, template=None):
+    path = os.path.join(self._dart_sources_dir, '%s.dart' % basename)
+    emitter = self._path_to_emitter.get(path)
+    if not emitter:

[Anton Muhin, 2012/10/01 13:30:35]

emitter is None might be slightly more robust, or even good old path in
self._path_to_emitter

[podivilov, 2012/10/01 14:49:18]

Done.

+      emitter = self._multiemitter.FileEmitter(path)
+      if template:

[Anton Muhin, 2012/10/01 13:30:35]

ditto for is None check

[podivilov, 2012/10/01 14:49:18]

Done.

+        emitter = emitter.Emit(template)
+      self._path_to_emitter[path] = emitter
+    return emitter
 
   def EmitLibrary(self, library_file_path, auxiliary_dir):
     def massage_path(path):
       # The most robust way to emit path separators is to use / always.
       return path.replace('\\', '/')
 
-    library_emitter = self._emitters.FileEmitter(library_file_path)
+    library_emitter = self._multiemitter.FileEmitter(library_file_path)
     library_file_dir = os.path.dirname(library_file_path)
     auxiliary_dir = os.path.relpath(auxiliary_dir, library_file_dir)
     imports_emitter = library_emitter.Emit(
         self._template, AUXILIARY_DIR=massage_path(auxiliary_dir))
-    for path in sorted(self._dart_sources_list):
+    for path in sorted(self._path_to_emitter.keys()):
       relpath = os.path.relpath(path, library_file_dir)
       imports_emitter.Emit(
           "#source('$PATH');\n", PATH=massage_path(relpath))