Mojo bindings: support generating identifers using different style rules for different target langu…

mojo/public/tools/bindings/generators/mojom_js_generator.py

 # Copyright 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Generates JavaScript source files from a mojom.Module."""
 
 import mojom.generate.generator as generator
 import mojom.generate.module as mojom
 import mojom.generate.pack as pack
 import os
@@ skipping 24 matching lines @@
   mojom.STRING:                "null",
   mojom.NULLABLE_STRING:       "null"
 }
 
 
 def JavaScriptType(kind):
   name = []
   if kind.imported_from:
     name.append(kind.imported_from["unique_name"])
   if kind.parent_kind:
-    name.append(kind.parent_kind.name)
-  name.append(kind.name)
+    name.append(kind.parent_kind.stylized_name)
+  if not hasattr(kind, 'stylized_name'):
+    print kind
+  name.append(kind.stylized_name)
   return ".".join(name)
 
 
 def JavaScriptDefaultValue(field):
   if field.default:
     if mojom.IsStructKind(field.kind):
       assert field.default == "default"
       return "new %s()" % JavaScriptType(field.kind)
     return ExpressionToText(field.default)
   if field.kind in mojom.PRIMITIVES:
@@ skipping 207 matching lines @@
 
 
 def TranslateConstants(token):
   if isinstance(token, (mojom.EnumValue, mojom.NamedValue)):
     # Both variable and enum constants are constructed like:
     # NamespaceUid.Struct[.Enum].CONSTANT_NAME
     name = []
     if token.imported_from:
       name.append(token.imported_from["unique_name"])
     if token.parent_kind:
-      name.append(token.parent_kind.name)
+      name.append(token.parent_kind.stylized_name)
     if isinstance(token, mojom.EnumValue):
-      name.append(token.enum.name)
+      name.append(token.enum.stylized_name)
     name.append(token.name)
     return ".".join(name)
 
   if isinstance(token, mojom.BuiltinValue):
     if token.value == "double.INFINITY" or token.value == "float.INFINITY":
       return "Infinity";
     if token.value == "double.NEGATIVE_INFINITY" or \
        token.value == "float.NEGATIVE_INFINITY":
       return "-Infinity";
     if token.value == "double.NAN" or token.value == "float.NAN":
@@ skipping 47 matching lines @@
 def IsAnyHandleOrInterfaceField(field):
   return mojom.IsAnyHandleOrInterfaceKind(field.kind)
 
 def IsEnumField(field):
   return mojom.IsEnumKind(field.kind)
 
 def GetRelativePath(module, base_module):
   return os.path.relpath(module.path, os.path.dirname(base_module.path))
 
 
+class JsStylizer(generator.Stylizer):
+  def __init__(self, use_new_js_bindings):
+    self.use_new_js_bindings = use_new_js_bindings
+
+  def StylizeField(self, name):
+    if not self.use_new_js_bindings:
+      return name
+    return generator.ToCamel(name, lower_initial=True)
+
+  def StylizeParameter(self, name):
+    if not self.use_new_js_bindings:
+      return name
+    return generator.ToCamel(name, lower_initial=True)
+
+  def StylizeMethod(self, name):
+    return generator.ToCamel(name, lower_initial=True)
+
+  def StylizeModule(self, name):
+    if not self.use_new_js_bindings:
+      return name
+    return '.'.join(
+        generator.ToCamel(word, lower_initial=True) for word in name.split('.'))
+
+
 class Generator(generator.Generator):
 
   js_filters = {
     "decode_snippet": JavaScriptDecodeSnippet,
     "default_value": JavaScriptDefaultValue,
     "encode_snippet": JavaScriptEncodeSnippet,
     "expression_to_text": ExpressionToText,
     "field_offset": JavaScriptFieldOffset,
+    "get_relative_path": GetRelativePath,
     "has_callbacks": mojom.HasCallbacks,
     "is_any_handle_or_interface_field": IsAnyHandleOrInterfaceField,
     "is_array_pointer_field": IsArrayPointerField,
     "is_associated_interface_field": IsAssociatedInterfaceField,
     "is_associated_interface_request_field": IsAssociatedInterfaceRequestField,
     "is_bool_field": IsBoolField,
     "is_enum_field": IsEnumField,
     "is_handle_field": IsHandleField,
     "is_interface_field": IsInterfaceField,
     "is_interface_request_field": IsInterfaceRequestField,
     "is_map_pointer_field": IsMapPointerField,
     "is_object_field": IsObjectField,
     "is_string_pointer_field": IsStringPointerField,
     "is_struct_pointer_field": IsStructPointerField,
     "is_union_field": IsUnionField,
     "js_type": JavaScriptType,
     "method_passes_associated_kinds": mojom.MethodPassesAssociatedKinds,
     "payload_size": JavaScriptPayloadSize,
-    "get_relative_path": GetRelativePath,
-    "stylize_method": generator.StudlyCapsToCamel,
+    "to_camel": generator.ToCamel,
     "union_decode_snippet": JavaScriptUnionDecodeSnippet,
     "union_encode_snippet": JavaScriptUnionEncodeSnippet,
     "validate_array_params": JavaScriptValidateArrayParams,
     "validate_enum_params": JavaScriptValidateEnumParams,
     "validate_map_params": JavaScriptValidateMapParams,
     "validate_nullable_params": JavaScriptNullableParam,
     "validate_struct_params": JavaScriptValidateStructParams,
     "validate_union_params": JavaScriptValidateUnionParams,
   }
 
   def GetParameters(self):
     return {
-      "namespace": self.module.namespace,
-      "imports": self.GetImports(),
+      "enums": self.module.enums,
+      "imports": self.module.imports,
+      "interfaces": self.module.interfaces,
       "kinds": self.module.kinds,
-      "enums": self.module.enums,
       "module": self.module,
-      "structs": self.GetStructs() + self.GetStructsFromMethods(),
-      "unions": self.GetUnions(),
+      "structs": self.module.structs + self.GetStructsFromMethods(),
+      "unions": self.module.unions,
       "use_new_js_bindings": self.use_new_js_bindings,
-      "interfaces": self.GetInterfaces(),
-      "imported_interfaces": self.GetImportedInterfaces(),
     }
 
   @staticmethod
   def GetTemplatePrefix():
     return "js_templates"
 
   @classmethod
   def GetFilters(cls):
     return cls.js_filters
 
   @UseJinja("module.amd.tmpl")
   def GenerateAMDModule(self):
     return self.GetParameters()
 
   def GenerateFiles(self, args):
     if self.variant:
       raise Exception("Variants not supported in JavaScript bindings.")
 
+    self.FinalizeModule(JsStylizer(self.use_new_js_bindings))
+
     self.Write(self.GenerateAMDModule(),
         self.MatchMojomFilePath("%s.js" % self.module.name))
 
-  def GetImports(self):
+  def FinalizeModule(self, stylizer=None):
+    super(Generator, self).FinalizeModule(stylizer)
+
     used_names = set()
     for each_import in self.module.imports:
       simple_name = each_import["module_name"].split(".")[0]
 
       # Since each import is assigned a variable in JS, they need to have unique
       # names.
       unique_name = simple_name
       counter = 0
       while unique_name in used_names:
         counter += 1
         unique_name = simple_name + str(counter)
 
       used_names.add(unique_name)
       each_import["unique_name"] = unique_name + "$"
       counter += 1
-    return self.module.imports
-
-  def GetImportedInterfaces(self):
-    interface_to_import = {};
-    for each_import in self.module.imports:
-      for each_interface in each_import["module"].interfaces:
-        name = each_interface.name
-        interface_to_import[name] = each_import["unique_name"] + "." + name
-    return interface_to_import;
-