Fix dart:html generated directory structure and unify file names between backends.

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
 
@@ skipping 419 matching lines @@
 
   def IsPrivate(self, name):
     return name.startswith('_')
 
 
 class HtmlInterfacesSystem(System):
   def __init__(self, options, backend):
     super(HtmlInterfacesSystem, self).__init__(options)
     self._backend = backend
     self._shared = HtmlSystemShared(options)
-    self._dart_interface_file_paths = []
+    self._dart_file_paths = []
     self._elements_factory_emitter = None
 
   def ProcessInterface(self, interface):
     HtmlDartInterfaceGenerator(self, interface).Generate()
 
   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)
+    code = self._CreateEmitter('%s.dart' % interface.id)
+    code.Emit(self._templates.Load('callback.darttemplate'))
+    code.Emit('typedef $TYPE $NAME($PARAMS);\n',
+              NAME=interface.id,
+              TYPE=DartType(info.type_name),
+              PARAMS=info.ParametersImplementationDeclaration(DartType))
     self._backend.ProcessCallback(interface, info)
 
   def GenerateLibraries(self):
-    self._backend.GenerateLibraries(self._dart_interface_file_paths)
+    self._backend.GenerateLibraries(self._dart_file_paths)
 
-  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)
+  def _CreateEmitter(self, filename):
+    path = os.path.join(self._output_dir, 'dart', filename)
+    self._dart_file_paths.append(path)
+    return self._emitters.FileEmitter(path)
 
 # ------------------------------------------------------------------------------
 
 class HtmlDartInterfaceGenerator(BaseGenerator):
   """Generates dart interface and implementation for the DOM IDL interface."""
 
   def __init__(self, system, interface):
     super(HtmlDartInterfaceGenerator, self).__init__(
         system._database, interface)
     self._system = system
     self._shared = system._shared
     self._html_interface_name = system._renamer.RenameInterface(self._interface)
     self._backend = system._backend.ImplementationGenerator(self._interface)
 
   def StartInterface(self):
     if not self._interface.id in _merged_html_interfaces:
-      path = self._system._FilePathForDartInterface(self._html_interface_name)
-      self._system._dart_interface_file_paths.append(path)
-      self._interface_emitter = self._system._emitters.FileEmitter(path)
+      path = '%s.dart' % self._html_interface_name
+      self._interface_emitter = self._system._CreateEmitter(path)
     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'))
 
     typename = self._html_interface_name
 
     extends = []
@@ skipping 22 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'
-      path = self._backend.FilePathForDartFactoryProviderImplementation()
-      self._system._dart_interface_file_paths.append(path)
-      factory_provider_emitter = self._system._emitters.FileEmitter(path)
+      factory_provider_emitter = self._system._CreateEmitter(
+          '_%sFactoryProvider.dart' % 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:
-        path = self._backend.FilePathForDartElementsFactoryProviderImplementation()
-        self._system._dart_interface_file_paths.append(path)
-        file_emitter = self._system._emitters.FileEmitter(path)
+        file_emitter = self._system._CreateEmitter('_Elements.dart')
         template = self._system._templates.Load(
             'factoryprovider_Elements.darttemplate')
         self._system._elements_factory_emitter = file_emitter.Emit(template)
       EmitHtmlElementFactoryConstructors(
           self._system._elements_factory_emitter,
           infos,
           self._html_interface_name,
           self._backend.ImplementationClassName())
 
     for info in infos:
@@ skipping 11 matching lines @@
      self._members_emitter,
      self._top_level_emitter) = self._interface_emitter.Emit(
          interface_template + '$!TOP_LEVEL',
          ID=typename,
          EXTENDS=extends_str)
 
     self._type_comment_emitter.Emit("/// @domName $DOMNAME",
         DOMNAME=self._interface.doc_js_name)
 
     if self._backend.HasImplementation():
-      path = self._backend.FilePathForDartImplementation()
-      self._system._dart_interface_file_paths.append(path)
-      self._implementation_emitter = self._system._emitters.FileEmitter(path)
+      if not self._interface.id in _merged_html_interfaces:
+        filename = '%sImpl.dart' % self._html_interface_name

[Anton Muhin, 2012/09/14 15:48:13]

as an option: filenameprefix = self._html_interface_name (in else part
self._interface.id) and then self._imlplementation_emitter =
self._system._CreateEmitter('%sImpl.dart' % filenamePrefix)

+      else:
+        filename = '%sImpl.dart' % self._interface.id
+      self._implementation_emitter = self._system._CreateEmitter(filename)
     else:
       self._implementation_emitter = emitter.Emitter()
     self._backend.SetImplementationEmitter(self._implementation_emitter)
     self._implementation_members_emitter = self._backend.StartInterface()
 
     for constructor_info in constructors:
       self._members_emitter.Emit(
           '\n'
           '  $CTOR($PARAMS);\n',
           CTOR=self._DartType(constructor_info.ConstructorFullName()),
@@ skipping 185 matching lines @@
         system, interface, None, None)
     self._html_interface_name = system._renamer.RenameInterface(self._interface)
 
   def HasImplementation(self):
     return not (IsPureInterface(self._interface.id) or
                 self._interface.id in _merged_html_interfaces)
 
   def ImplementationClassName(self):
     return self._ImplClassName(self._html_interface_name)
 
-  def FilePathForDartImplementation(self):
-    return os.path.join(self._system._output_dir, 'html', 'dart2js',
-                        '%s.dart' % self._html_interface_name)
-
-  def FilePathForDartFactoryProviderImplementation(self):
-    return os.path.join(self._system._output_dir, 'html', 'dart2js',
-                        '_%sFactoryProvider.dart' % self._html_interface_name)
-
-  def FilePathForDartElementsFactoryProviderImplementation(self):
-    return os.path.join(self._system._output_dir, 'html', 'dart2js',
-                        '_Elements.dart')
-
   def SetImplementationEmitter(self, implementation_emitter):
     self._dart_code = implementation_emitter
 
   def ImplementsMergedMembers(self):
     return True
 
   def _ImplClassName(self, type_name):
     return '_%sImpl' % type_name
 
   def StartInterface(self):
@@ skipping 439 matching lines @@
     return HtmlDart2JSClassGenerator(self, interface)
 
   def GenerateLibraries(self, dart_files):
     self._GenerateLibFile(
         'html_dart2js.darttemplate',
         os.path.join(self._output_dir, 'html_dart2js.dart'),
         dart_files)
 
   def Finish(self):
     pass