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

mojo/public/tools/bindings/pylib/mojom/generate/module.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.
 
 # This module's classes provide an interface to mojo modules. Modules are
 # collections of interfaces and structs to be used by mojo ipc clients and
 # servers.
 #
 # A simple interface would be created this way:
 # module = mojom.generate.module.Module('Foo')
@@ skipping 246 matching lines @@
         self.enum.name + '.' + self.name)
 
 
 class Constant(object):
   def __init__(self, name=None, kind=None, value=None, parent_kind=None):
     self.name = name
     self.kind = kind
     self.value = value
     self.parent_kind = parent_kind
 
+  def Stylize(self, stylizer):
+    self.stylized_name = stylizer.StylizeConstant(self.name)
+
 
 class Field(object):
   def __init__(self, name=None, kind=None, ordinal=None, default=None,
                attributes=None):
     if self.__class__.__name__ == 'Field':
       raise Exception()
     self.name = name
     self.kind = kind
     self.ordinal = ordinal
     self.default = default
     self.attributes = attributes
 
   def Repr(self, as_ref=True):
     # Fields are only referenced by objects which define them and thus
     # they are always displayed as non-references.
     return GenericRepr(self, {'name': False, 'kind': True})
 
   @property
   def min_version(self):
     return self.attributes.get(ATTRIBUTE_MIN_VERSION) \
         if self.attributes else None
 
+  def Stylize(self, stylizer):
+    self.stylized_name = stylizer.StylizeField(self.name)
+
 
 class StructField(Field): pass
 
 
 class UnionField(Field): pass
 
 
 class Struct(ReferenceKind):
   """A struct with typed fields.
 
   Attributes:
     name: {str} The name of the struct type.
     native_only: {bool} Does the struct have a body (i.e. any fields) or is it
         purely a native struct.
     module: {Module} The defining module.
     imported_from: {dict} Information about where this union was
         imported from.
     fields: {List[StructField]} The members of the struct.
     attributes: {dict} Additional information about the struct, such as
         if it's a native struct.
   """
 
   ReferenceKind.AddSharedProperty('name')
+  ReferenceKind.AddSharedProperty('stylized_name')
   ReferenceKind.AddSharedProperty('native_only')
   ReferenceKind.AddSharedProperty('module')
   ReferenceKind.AddSharedProperty('imported_from')
   ReferenceKind.AddSharedProperty('fields')
   ReferenceKind.AddSharedProperty('attributes')
 
   def __init__(self, name=None, module=None, attributes=None):
     if name is not None:
       spec = 'x:' + name
     else:
       spec = None
     ReferenceKind.__init__(self, spec)
     self.name = name
     self.native_only = False
     self.module = module
     self.imported_from = None
     self.fields = []
+    self.enums = []
+    self.constants = []
     self.attributes = attributes
 
   def Repr(self, as_ref=True):
     if as_ref:
       return '<%s name=%r imported_from=%s>' % (
           self.__class__.__name__, self.name,
           Repr(self.imported_from, as_ref=True))
     else:
       return GenericRepr(self, {'name': False, 'fields': False,
                                 'imported_from': True})
 
   def AddField(self, name, kind, ordinal=None, default=None, attributes=None):
     field = StructField(name, kind, ordinal, default, attributes)
     self.fields.append(field)
     return field
 
+  def Stylize(self, stylizer):
+    self.stylized_name = stylizer.StylizeStruct(self.name)
+    for field in self.fields:
+      field.Stylize(stylizer)
+    for enum in self.enums:
+      enum.Stylize(stylizer)
+    for constant in self.constants:
+      constant.Stylize(stylizer)
+
 
 class Union(ReferenceKind):
   """A union of several kinds.
 
   Attributes:
     name: {str} The name of the union type.
     module: {Module} The defining module.
     imported_from: {dict} Information about where this union was
         imported from.
     fields: {List[UnionField]} The members of the union.
     attributes: {dict} Additional information about the union, such as
         which Java class name to use to represent it in the generated
         bindings.
   """
   ReferenceKind.AddSharedProperty('name')
+  ReferenceKind.AddSharedProperty('stylized_name')
   ReferenceKind.AddSharedProperty('module')
   ReferenceKind.AddSharedProperty('imported_from')
   ReferenceKind.AddSharedProperty('fields')
   ReferenceKind.AddSharedProperty('attributes')
 
   def __init__(self, name=None, module=None, attributes=None):
     if name is not None:
       spec = 'x:' + name
     else:
       spec = None
@@ skipping 10 matching lines @@
           self.__class__.__name__, self.spec, self.is_nullable,
           Repr(self.fields))
     else:
       return GenericRepr(self, {'fields': True, 'is_nullable': False})
 
   def AddField(self, name, kind, ordinal=None, attributes=None):
     field = UnionField(name, kind, ordinal, None, attributes)
     self.fields.append(field)
     return field
 
+  def Stylize(self, stylizer):
+    self.stylized_name = stylizer.StylizeUnion(self.name)
+    for field in self.fields:
+      field.Stylize(stylizer)
+
 
 class Array(ReferenceKind):
   """An array.
 
   Attributes:
     kind: {Kind} The type of the elements. May be None.
     length: The number of elements. None if unknown.
   """
 
   ReferenceKind.AddSharedProperty('kind')
@@ skipping 101 matching lines @@
 
   def Repr(self, as_ref=True):
     return '<%s name=%r kind=%s>' % (self.__class__.__name__, self.name,
                                      self.kind.Repr(as_ref=True))
 
   @property
   def min_version(self):
     return self.attributes.get(ATTRIBUTE_MIN_VERSION) \
         if self.attributes else None
 
+  def Stylize(self, stylizer):
+    self.stylized_name = stylizer.StylizeParameter(self.name)
+
 
 class Method(object):
   def __init__(self, interface, name, ordinal=None, attributes=None):
     self.interface = interface
     self.name = name
     self.ordinal = ordinal
     self.parameters = []
     self.response_parameters = None
     self.attributes = attributes
 
@@ skipping 21 matching lines @@
   @property
   def min_version(self):
     return self.attributes.get(ATTRIBUTE_MIN_VERSION) \
         if self.attributes else None
 
   @property
   def sync(self):
     return self.attributes.get(ATTRIBUTE_SYNC) \
         if self.attributes else None
 
+  def Stylize(self, stylizer):
+    self.stylized_name = stylizer.StylizeMethod(self.name)
+    for param in self.parameters:
+      param.Stylize(stylizer)
+    if self.response_parameters:
+      for param in self.response_parameters:
+        param.Stylize(stylizer)
+
 
 class Interface(ReferenceKind):
   ReferenceKind.AddSharedProperty('module')
   ReferenceKind.AddSharedProperty('name')
+  ReferenceKind.AddSharedProperty('stylized_name')
   ReferenceKind.AddSharedProperty('imported_from')
   ReferenceKind.AddSharedProperty('methods')
   ReferenceKind.AddSharedProperty('attributes')
 
   def __init__(self, name=None, module=None, attributes=None):
     if name is not None:
       spec = 'x:' + name
     else:
       spec = None
     ReferenceKind.__init__(self, spec)
     self.module = module
     self.name = name
     self.imported_from = None
     self.methods = []
+    self.enums = []
+    self.constants = []
     self.attributes = attributes
 
   def Repr(self, as_ref=True):
     if as_ref:
       return '<%s name=%r>' % (self.__class__.__name__, self.name)
     else:
       return GenericRepr(self, {'name': False, 'attributes': False,
                                 'methods': False})
 
   def AddMethod(self, name, ordinal=None, attributes=None):
     method = Method(self, name, ordinal, attributes)
     self.methods.append(method)
     return method
 
   # TODO(451323): Remove when the language backends no longer rely on this.
   @property
   def client(self):
     return None
 
+  def Stylize(self, stylizer):
+    self.stylized_name = stylizer.StylizeInterface(self.name)
+    for method in self.methods:
+      method.Stylize(stylizer)
+    for enum in self.enums:
+      enum.Stylize(stylizer)
+    for constant in self.constants:
+      constant.Stylize(stylizer)
+
 
 class AssociatedInterface(ReferenceKind):
   ReferenceKind.AddSharedProperty('kind')
 
   def __init__(self, kind=None):
     if kind is not None:
       if not isinstance(kind, Interface):
         raise Exception(
             "Associated interface requires %r to be an interface." % kind.spec)
       assert not kind.is_nullable
       ReferenceKind.__init__(self, 'asso:' + kind.spec)
     else:
       ReferenceKind.__init__(self)
     self.kind = kind
 
 
 class EnumField(object):
   def __init__(self, name=None, value=None, attributes=None,
                numeric_value=None):
     self.name = name
     self.value = value
     self.attributes = attributes
     self.numeric_value = numeric_value
 
   @property
   def min_version(self):
     return self.attributes.get(ATTRIBUTE_MIN_VERSION) \
         if self.attributes else None
 
+  def Stylize(self, stylizer):
+    self.stylized_name = stylizer.StylizeEnumField(self.name)
+
 
 class Enum(Kind):
   def __init__(self, name=None, module=None, attributes=None):
     self.module = module
     self.name = name
     self.native_only = False
     self.imported_from = None
     if name is not None:
       spec = 'x:' + name
     else:
       spec = None
     Kind.__init__(self, spec)
     self.fields = []
     self.attributes = attributes
 
   def Repr(self, as_ref=True):
     if as_ref:
       return '<%s name=%r>' % (self.__class__.__name__, self.name)
     else:
       return GenericRepr(self, {'name': False, 'fields': False})
 
   @property
   def extensible(self):
     return self.attributes.get(ATTRIBUTE_EXTENSIBLE, False) \
         if self.attributes else False
 
+  def Stylize(self, stylizer):
+    self.stylized_name = stylizer.StylizeEnum(self.name)
+    for field in self.fields:
+      field.Stylize(stylizer)
+
 
 class Module(object):
   def __init__(self, name=None, namespace=None, attributes=None):
     self.name = name
     self.path = name
     self.namespace = namespace
     self.structs = []
     self.unions = []
     self.interfaces = []
+    self.enums = []
+    self.constants = []
     self.kinds = {}
     self.attributes = attributes
+    self.imports = []
 
   def __repr__(self):
     # Gives us a decent __repr__ for modules.
     return self.Repr()
 
   def Repr(self, as_ref=True):
     if as_ref:
       return '<%s name=%r namespace=%r>' % (
           self.__class__.__name__, self.name, self.namespace)
     else:
       return GenericRepr(self, {'name': False, 'namespace': False,
                                 'attributes': False, 'structs': False,
                                 'interfaces': False, 'unions': False})
 
   def AddInterface(self, name, attributes=None):
     interface = Interface(name, self, attributes)
     self.interfaces.append(interface)
     return interface
 
   def AddStruct(self, name, attributes=None):
     struct = Struct(name, self, attributes)
     self.structs.append(struct)
     return struct
 
   def AddUnion(self, name, attributes=None):
     union = Union(name, self, attributes)
     self.unions.append(union)
     return union
 
+  def Stylize(self, stylizer):
+    self.stylized_namespace = stylizer.StylizeModule(self.namespace)
+    for struct in self.structs:
+      struct.Stylize(stylizer)
+    for union in self.unions:
+      union.Stylize(stylizer)
+    for interface in self.interfaces:
+      interface.Stylize(stylizer)
+    for enum in self.enums:
+      enum.Stylize(stylizer)
+    for constant in self.constants:
+      constant.Stylize(stylizer)
+    for imported_module in self.imports:
+      imported_module['module'].Stylize(stylizer)
+
 
 def IsBoolKind(kind):
   return kind.spec == BOOL.spec
 
 
 def IsFloatKind(kind):
   return kind.spec == FLOAT.spec
 
 
 def IsDoubleKind(kind):
@@ skipping 199 matching lines @@
       return True
     elif IsAnyInterfaceKind(kind):
       return True
     elif IsArrayKind(kind):
       return Check(kind.kind)
     elif IsMapKind(kind):
       return Check(kind.key_kind) or Check(kind.value_kind)
     else:
       return False
   return Check(kind)