Mojo bindings generator: introduce Stylizer to specify naming rules.

mojo/public/tools/bindings/pylib/mojom/generate/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.
 
 """Code shared by the various language-specific code generators."""
 
 from functools import partial
 import os.path
 import re
 
@@ skipping 14 matching lines @@
   if |lower_initial| is set to True), and joins the words. Please note that for
   each word, all the characters except the first one are untouched.
   """
   result = ''.join(
       word[0].upper() + word[1:] for word in identifier.split(dilimiter))
   if lower_initial:
     result = result[0].lower() + result[1:]
   return result
 
 
+class Stylizer(object):
+  """Stylizers specify naming rules to map mojom names to names in generated
+  code. For example, if you would like method_name in mojom to be mapped to
+  MethodName in the generated code, you need to define a subclass of Stylizer
+  and override StylizeMethod to do the conversion."""
+
+  def StylizeConstant(self, mojom_name):
+    return mojom_name
+
+  def StylizeField(self, mojom_name):
+    return mojom_name
+
+  def StylizeStruct(self, mojom_name):
+    return mojom_name
+
+  def StylizeUnion(self, mojom_name):
+    return mojom_name
+
+  def StylizeParameter(self, mojom_name):
+    return mojom_name
+
+  def StylizeMethod(self, mojom_name):
+    return mojom_name
+
+  def StylizeInterface(self, mojom_name):
+    return mojom_name
+
+  def StylizeEnumField(self, mojom_name):
+    return mojom_name
+
+  def StylizeEnum(self, mojom_name):
+    return mojom_name
+
+  def StylizeModule(self, mojom_namespace):
+    return mojom_namespace
+
+
 def WriteFile(contents, full_path):
   # Make sure the containing directory exists.
   full_dir = os.path.dirname(full_path)
   fileutil.EnsureDirectoryExists(full_dir)
 
   # Dump the data to disk.
   with open(full_path, "w+") as f:
     f.write(contents)
 
 
@@ skipping 33 matching lines @@
       if method.response_parameters is not None:
         method.response_param_struct = _GetResponseStructFromMethod(method)
         interface.version = max(
             interface.version,
             method.response_param_struct.versions[-1].version)
       else:
         method.response_param_struct = None
 
   def _GetStructFromMethod(method):
     """Converts a method's parameters into the fields of a struct."""
-    params_class = "%s_%s_Params" % (method.interface.name, method.name)
+    params_class = "%s_%s_Params" % (method.interface.mojom_name,
+                                     method.mojom_name)
     struct = mojom.Struct(params_class, module=method.interface.module)
     for param in method.parameters:
-      struct.AddField(param.name, param.kind, param.ordinal,
+      struct.AddField(param.mojom_name, param.kind, param.ordinal,
                       attributes=param.attributes)
     _AddStructComputedData(False, struct)
     return struct
 
   def _GetResponseStructFromMethod(method):
     """Converts a method's response_parameters into the fields of a struct."""
-    params_class = "%s_%s_ResponseParams" % (method.interface.name, method.name)
+    params_class = "%s_%s_ResponseParams" % (method.interface.mojom_name,
+                                             method.mojom_name)
     struct = mojom.Struct(params_class, module=method.interface.module)
     for param in method.response_parameters:
-      struct.AddField(param.name, param.kind, param.ordinal,
+      struct.AddField(param.mojom_name, param.kind, param.ordinal,
                       attributes=param.attributes)
     _AddStructComputedData(False, struct)
     return struct
 
   for struct in module.structs:
     _AddStructComputedData(True, struct)
   for union in module.unions:
     _AddUnionComputedData(union)
   for interface in module.interfaces:
     _AddInterfaceComputedData(interface)
@@ skipping 11 matching lines @@
     self.typemap = typemap or {}
     self.variant = variant
     self.bytecode_path = bytecode_path
     self.for_blink = for_blink
     self.use_once_callback = use_once_callback
     self.use_new_js_bindings = use_new_js_bindings
     self.export_attribute = export_attribute
     self.export_header = export_header
     self.generate_non_variant_code = generate_non_variant_code
 
-  # Prepend the filename with a directory that matches the directory of the
-  # original .mojom file, relative to the import root.
-  def MatchMojomFilePath(self, filename):
-    return os.path.join(os.path.dirname(self.module.path), filename)
-
   def Write(self, contents, filename):
     if self.output_dir is None:
       print contents
       return
     full_path = os.path.join(self.output_dir, filename)
     WriteFile(contents, full_path)
 
   def GenerateFiles(self, args):
     raise NotImplementedError("Subclasses must override/implement this method")
 
   def GetJinjaParameters(self):
     """Returns default constructor parameters for the jinja environment."""
     return {}
 
   def GetGlobals(self):
     """Returns global mappings for the template generation."""
     return {}