Add constructors for SVG elements and remove static factory providers for html elements.

sdk/lib/html/scripts/generator.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 systems to generate
 Dart APIs from the IDL database."""
 
 import copy
 import re
@@ skipping 287 matching lines @@
 class OperationInfo(object):
   """Holder for various derived information from a set of overloaded operations.
 
   Attributes:
     overloads: A list of IDL operation overloads with the same name.
     name: A string, the simple name of the operation.
     constructor_name: A string, the name of the constructor iff the constructor
        is named, e.g. 'fromList' in  Int8Array.fromList(list).
     type_name: A string, the name of the return type of the operation.
     param_infos: A list of ParamInfo.
+    factory_parameters: A list of parameters used for custom designed Factory
+        calls.
   """
+  
+  def __init__(self):
+    self.factory_parameters = None
 
   def ParametersDeclaration(self, rename_type, force_optional=False):
     def FormatParam(param):
       dart_type = rename_type(param.type_id) if param.type_id else 'dynamic'
       return '%s%s' % (TypeOrNothing(dart_type, param.type_id), param.name)
 
     required = []
     optional = []
     for param_info in self.param_infos:
       if param_info.is_optional:
@@ skipping 30 matching lines @@
 
   def _ConstructorFullName(self, rename_type):
     if self.constructor_name:
       return rename_type(self.type_name) + '.' + self.constructor_name
     else:
       return rename_type(self.type_name)
 
   def ConstructorFactoryName(self, rename_type):
     return 'create' + self._ConstructorFullName(rename_type).replace('.', '_')
 
-  def GenerateFactoryInvocation(self, rename_type, emitter, factory_provider):
+  def GenerateFactoryInvocation(self, rename_type, emitter, factory_name,
+      factory_constructor_name=None, factory_parameters=None):
     has_optional = any(param_info.is_optional
         for param_info in self.param_infos)
 
-    factory_name = self.ConstructorFactoryName(rename_type)
+    if not factory_constructor_name:
+      factory_constructor_name = self.ConstructorFactoryName(rename_type)
+      factory_parameters = self.ParametersAsArgumentList()
+      has_factory_provider = True
+    else:
+      factory_parameters = ', '.join(factory_parameters)
+      has_factory_provider = False
     if not has_optional:
       emitter.Emit(
           '\n'
           '  factory $CTOR($PARAMS) => '
           '$FACTORY.$CTOR_FACTORY_NAME($FACTORY_PARAMS);\n',
           CTOR=self._ConstructorFullName(rename_type),
           PARAMS=self.ParametersDeclaration(rename_type),
-          FACTORY=factory_provider,
-          CTOR_FACTORY_NAME=factory_name,
-          FACTORY_PARAMS=self.ParametersAsArgumentList())
+          FACTORY=factory_name,
+          CTOR_FACTORY_NAME=factory_constructor_name,
+          FACTORY_PARAMS=factory_parameters)
       return
+    if has_factory_provider:
+      self._GenerateFactoryOptParams(rename_type, emitter, factory_name)
+    else:
+      self._GenerateFactoryOptParamsWithoutFactoryProvider(rename_type, emitter,
+          factory_name, factory_constructor_name, factory_parameters)
 
+  def _GenerateFactoryOptParams(self, rename_type, emitter, factory_provider):
+    """Helper method for creating generic factory constructors with optional
+    parameters that use factory providers."""
     dispatcher_emitter = emitter.Emit(
         '\n'
         '  factory $CTOR($PARAMS) {\n'
         '$!DISPATCHER'
         '    return $FACTORY.$CTOR_FACTORY_NAME($FACTORY_PARAMS);\n'
         '  }\n',
         CTOR=self._ConstructorFullName(rename_type),
         PARAMS=self.ParametersDeclaration(rename_type),
         FACTORY=factory_provider,
-        CTOR_FACTORY_NAME=factory_name,
+        CTOR_FACTORY_NAME=self.ConstructorFactoryName(rename_type),
         FACTORY_PARAMS=self.ParametersAsArgumentList())
 
     # If we have optional parameters, check to see if they are set
     # and call the appropriate factory method.
     def EmitOptionalParameterInvocation(index):
       dispatcher_emitter.Emit(
         '    if (!?$OPT_PARAM_NAME) {\n'
         '      return $FACTORY.$CTOR_FACTORY_NAME($FACTORY_PARAMS);\n'
         '    }\n',
         OPT_PARAM_NAME=self.param_infos[index].name,
         FACTORY=factory_provider,
-        CTOR_FACTORY_NAME=factory_name,
+        CTOR_FACTORY_NAME=self.ConstructorFactoryName(rename_type),
         FACTORY_PARAMS=self.ParametersAsArgumentList(index))
 
     for index, param_info in enumerate(self.param_infos):
       if param_info.is_optional:
         EmitOptionalParameterInvocation(index)
+  
+  def _GenerateFactoryOptParamsWithoutFactoryProvider(self, rename_type,
+      emitter, factory_name, factory_constructor_name, factory_parameters): 
+    """Helper method for creating a factory constructor with optional
+    parameters that does not call a factory provider, it simply creates the
+    object itself. This is currently used for SVGElements and HTMLElements."""
+    inits = emitter.Emit(
+        '\n'
+        '  factory $CONSTRUCTOR($PARAMS) {\n'   
+        '    var e = $FACTORY.$CTOR_FACTORY_NAME($FACTORY_PARAMS);\n'
+        '$!INITS'
+        '    return e;\n'
+        '  }\n',
+        CONSTRUCTOR=self._ConstructorFullName(rename_type),
+        FACTORY=factory_name,
+        CTOR_FACTORY_NAME=factory_constructor_name,
+        PARAMS=self.ParametersDeclaration(rename_type, force_optional=True),
+        FACTORY_PARAMS=factory_parameters)
+    for index, param_info in enumerate(self.param_infos):
+      if param_info.is_optional:
+        inits.Emit('    if (!?$E) e.$E = $E;\n',
+            E=self.param_infos[index].name)
 
 def ConstantOutputOrder(a, b):
   """Canonical output ordering for constants."""
   if a.id < b.id: return -1
   if a.id > b.id: return 1
   return 0
 
 
 def _FormatNameList(names):
   """Returns JavaScript array literal expression with one name per line."""
@@ skipping 671 matching lines @@
       else:
         dart_interface_name = type_name
       return InterfaceIDLTypeInfo(type_name, type_data, dart_interface_name,
                                   self)
 
     if type_data.clazz == 'SVGTearOff':
       return SVGTearOffIDLTypeInfo(type_name, type_data, self)
 
     class_name = '%sIDLTypeInfo' % type_data.clazz
     return globals()[class_name](type_name, type_data)