Move naming related code in make_computed_style_base to name_utilities.

third_party/WebKit/Source/build/scripts/make_computed_style_base.py

 #!/usr/bin/env python
 # Copyright 2016 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.
 
 import math
 import sys
 
 import json5_generator
 import template_expander
 import make_style_builder
 
-from name_utilities import camel_case, lower_first, upper_first_letter, enum_for_css_keyword
+from name_utilities import (
+    enum_for_css_keyword, enumerator_name, class_member_name, method_name
+)
 
 
 # Temporary hard-coded list of fields that are not CSS properties.
 # Ideally these would be specified in a .json5 file.
 NONPROPERTY_FIELDS = [
-    {'name': 'isLink', 'field_template': 'monotonic_flag'},
+    {'name': 'IsLink', 'field_template': 'monotonic_flag'},
     # Style can not be shared.
-    {'name': 'unique', 'field_template': 'monotonic_flag'},
+    {'name': 'Unique', 'field_template': 'monotonic_flag'},
     # Whether this style is affected by these pseudo-classes.
-    {'name': 'affectedByFocus', 'field_template': 'monotonic_flag'},
-    {'name': 'affectedByHover', 'field_template': 'monotonic_flag'},
-    {'name': 'affectedByActive', 'field_template': 'monotonic_flag'},
-    {'name': 'affectedByDrag', 'field_template': 'monotonic_flag'},
+    {'name': 'AffectedByFocus', 'field_template': 'monotonic_flag'},
+    {'name': 'AffectedByHover', 'field_template': 'monotonic_flag'},
+    {'name': 'AffectedByActive', 'field_template': 'monotonic_flag'},
+    {'name': 'AffectedByDrag', 'field_template': 'monotonic_flag'},
     # A non-inherited property references a variable or @apply is used
-    {'name': 'hasVariableReferenceFromNonInheritedProperty', 'field_template': 'monotonic_flag'},
+    {'name': 'HasVariableReferenceFromNonInheritedProperty', 'field_template': 'monotonic_flag'},
     # Explicitly inherits a non-inherited property
-    {'name': 'hasExplicitlyInheritedProperties', 'field_template': 'monotonic_flag'}
+    {'name': 'HasExplicitlyInheritedProperties', 'field_template': 'monotonic_flag'}
 ]
 
 
 class Field(object):
     """
     The generated ComputedStyle object is made up of a series of Fields.
     Each Field has a name, size, type, etc, and a bunch of attributes to
     determine which methods it will be used in.
 
     A Field also has enough information to use any storage type in C++, such as
     regular member variables, or more complex storage like vectors or hashmaps.
     Almost all properties will have at least one Field, often more than one.
 
-    Fields also fall into various roles, which determine the logic that is
-    used to generate them. The available field roles are:
-      - 'property', for fields that store CSS properties
-      - 'inherited_flag', for single-bit flags that store whether a property is
-                          inherited by this style or set explicitly
-      - 'nonproperty', for fields that are not CSS properties
+    Most attributes in this class correspond to parameters in CSSProperties.json5.
+    See that file for a more detailed explanation of each attribute.
+
+    Attributes:
+        field_role: The semantic role of the field. Can be:
+            - 'property': for fields that store CSS properties
+            - 'inherited_flag': for single-bit flags that store whether a property is
+                                inherited by this style or set explicitly
+            - 'nonproperty': for fields that are not CSS properties
+        name_for_methods: String used to form the names of getters and setters.
+            Should be in upper camel case.
+        property_name: Name of the property that the field is part of.
+        type_name: Name of the C++ type exposed by the generated interface (e.g. EClear, int).
+        'field_template': Determines the interface generated for the field. Can be one of:
+            keyword, flag, or monotonic_flag.
+        'size': Number of bits needed for storage.
+        'default_value': Default value for this field when it is first initialized.
     """
 
-    # List of required attributes for a field which need to be passed in by
-    # keyword arguments. See CSSProperties.json5 for an explanation of each
-    # attribute.
-    REQUIRED_ATTRIBUTES = set([
-        # Name of field
-        'name',
-        # Name of property field is for
-        'property_name',
-        # Name of the type (e.g. EClear, int)
-        'type_name',
-        # Affects how the field is generated (keyword, flag, monotonic_flag)
-        'field_template',
-        # Bits needed for storage
-        'size',
-        # Default value for field
-        'default_value',
-        # Method names
-        'getter_method_name',
-        'setter_method_name',
-        'initial_method_name',
-        'resetter_method_name',
-    ])
-
-    def __init__(self, field_role, **kwargs):
-        # Values common to all fields
-        # Set attributes from the keyword arguments
-        for attrib in Field.REQUIRED_ATTRIBUTES:
-            setattr(self, attrib, kwargs.pop(attrib))
+    def __init__(self, field_role, name_for_methods, property_name, type_name,
+                 field_template, size, default_value, **kwargs):
+        """Creates a new field."""
+        self.name = class_member_name(name_for_methods)
+        self.property_name = property_name
+        self.type_name = type_name
+        self.field_template = field_template
+        self.size = size
+        self.default_value = default_value
 
         # Field role: one of these must be true
         self.is_property = field_role == 'property'
         self.is_inherited_flag = field_role == 'inherited_flag'
         self.is_nonproperty = field_role == 'nonproperty'
         assert (self.is_property, self.is_inherited_flag, self.is_nonproperty).count(True) == 1, \
             'Field role has to be exactly one of: property, inherited_flag, nonproperty'
 
         if self.is_property:
             self.is_inherited = kwargs.pop('inherited')
             self.is_independent = kwargs.pop('independent')
             assert self.is_inherited or not self.is_independent, 'Only inherited fields can be independent'
 
-            self.is_inherited_method_name = kwargs.pop('is_inherited_method_name')
-        elif self.is_inherited_flag:
-            # Inherited flag-only fields
-            pass
+            self.is_inherited_method_name = method_name(name_for_methods + 'IsInherited')
+
+        # Method names
+        getter_prefix = 'Get' if name_for_methods == self.type_name else ''
+        self.getter_method_name = method_name(getter_prefix + name_for_methods)
+        self.setter_method_name = method_name('Set' + name_for_methods)
+        self.initial_method_name = method_name('Initial' + name_for_methods)
+        self.resetter_method_name = method_name('Reset' + name_for_methods)
 
         assert len(kwargs) == 0, 'Unexpected arguments provided to Field: ' + str(kwargs)
 
 
 def _get_include_paths(properties):
     """
     Get a list of paths that need to be included for ComputedStyleBase.
     """
     include_paths = set()
     for property_ in properties:
         if property_['field_type_path'] is not None:
             include_paths.add(property_['field_type_path'] + '.h')
     return list(sorted(include_paths))
 
 
 def _create_enums(properties):
     """
     Returns a dictionary of enums to be generated, enum name -> [list of enum values]
     """
     enums = {}
     for property_ in properties:
         # Only generate enums for keyword properties that use the default field_type_path.
         if property_['field_template'] == 'keyword' and property_['field_type_path'] is None:
             enum_name = property_['type_name']
-            # From the Blink style guide: Enum members should use InterCaps with an initial capital letter. [names-enum-members]
-            enum_values = [('k' + camel_case(k)) for k in property_['keywords']]
+            enum_values = [enumerator_name(k) for k in property_['keywords']]
 
             if enum_name in enums:
                 # There's an enum with the same name, check if the enum values are the same
                 assert set(enums[enum_name]) == set(enum_values), \
                     ("'" + property_['name'] + "' can't have type_name '" + enum_name + "' "
                      "because it was used by a previous property, but with a different set of keywords. "
                      "Either give it a different name or ensure the keywords are the same.")
 
             enums[enum_name] = enum_values
 
     return enums
 
 
 def _create_property_field(property_):
     """
     Create a property field from a CSS property and return the Field object.
     """
-    property_name = property_['name_for_methods']
-    property_name_lower = lower_first(property_name)
+    name_for_methods = property_['name_for_methods']
 
-    # From the Blink style guide: Other data members should be prefixed by "m_". [names-data-members]
-    field_name = 'm_' + property_name_lower
     bits_needed = math.log(len(property_['keywords']), 2)  # TODO: implement for non-enums
     type_name = property_['type_name']
 
-    # For now, the getter name should match the field name. Later, getter names
-    # will start with an uppercase letter, so if they conflict with the type name,
-    # add 'get' to the front.
-    getter_method_name = property_name_lower
-    if type_name == property_name:
-        getter_method_name = 'get' + property_name
-
     assert property_['initial_keyword'] is not None, \
         ('MakeComputedStyleBase requires an initial keyword for keyword fields, none specified '
          'for property ' + property_['name'])
-    default_value = type_name + '::k' + camel_case(property_['initial_keyword'])
+    default_value = type_name + '::' + enumerator_name(property_['initial_keyword'])
 
     return Field(
         'property',
-        name=field_name,
+        name_for_methods,
         property_name=property_['name'],
         inherited=property_['inherited'],
         independent=property_['independent'],
         type_name=type_name,
         field_template=property_['field_template'],
         size=int(math.ceil(bits_needed)),
         default_value=default_value,
-        getter_method_name=getter_method_name,
-        setter_method_name='set' + property_name,
-        initial_method_name='initial' + property_name,
-        resetter_method_name='reset' + property_name,
-        is_inherited_method_name=property_name_lower + 'IsInherited',
     )
 
 
 def _create_inherited_flag_field(property_):
     """
     Create the field used for an inheritance fast path from an independent CSS property,
     and return the Field object.
     """
-    property_name = property_['name_for_methods']
-    property_name_lower = lower_first(property_name)
-
-    field_name_suffix_upper = property_name + 'IsInherited'
-    field_name_suffix_lower = property_name_lower + 'IsInherited'
-
     return Field(
         'inherited_flag',
-        name='m_' + field_name_suffix_lower,
+        property_['name_for_methods'] + 'IsInherited',
         property_name=property_['name'],
         type_name='bool',
         field_template='flag',
         size=1,
         default_value='true',
-        getter_method_name=field_name_suffix_lower,
-        setter_method_name='set' + field_name_suffix_upper,
-        initial_method_name='initial' + field_name_suffix_upper,
-        resetter_method_name='reset' + field_name_suffix_upper,
     )
 
 
 def _create_nonproperty_field(property_):
     """
     Create a nonproperty field from an entry in NONPROPERTY_FIELDS and return the Field object.
     """
     # TODO(shend): Make this work for nonflags
     assert property_['field_template'] in ('flag', 'monotonic_flag'), \
         "Nonproperties with arbitrary templates are not yet supported"
-    member_name = 'm_' + property_['name']
-    field_name_upper = upper_first_letter(property_['name'])
 
     return Field(
         'nonproperty',
-        name=member_name,
+        property_['name'],
         property_name=property_['name'],
         type_name='bool',
         field_template=property_['field_template'],
         size=1,
         default_value='false',
-        getter_method_name=property_['name'],
-        setter_method_name='set' + field_name_upper,
-        initial_method_name='initial' + field_name_upper,
-        resetter_method_name='reset' + field_name_upper,
     )
 
 
 def _create_fields(properties):
     """
     Create ComputedStyle fields from CSS properties and return a list of Field objects.
     """
     fields = []
     for property_ in properties:
         # Only generate properties that have a field template
@@ skipping 129 matching lines @@
             'expected_total_field_bytes': self._expected_total_field_bytes,
         }
 
     @template_expander.use_jinja('CSSValueIDMappingsGenerated.h.tmpl')
     def generate_css_value_mappings(self):
         mappings = {}
 
         for property_ in self._properties.values():
             if property_['field_template'] == 'keyword':
                 mappings[property_['type_name']] = {
-                    'default_value': 'k' + camel_case(property_['initial_keyword']),
-                    'mapping': [('k' + camel_case(k), enum_for_css_keyword(k)) for k in property_['keywords']],
+                    'default_value': enumerator_name(property_['initial_keyword']),
+                    'mapping': [(enumerator_name(k), enum_for_css_keyword(k)) for k in property_['keywords']],
                 }
 
         return {
             'include_paths': self._include_paths,
             'mappings': mappings,
         }
 
 if __name__ == '__main__':
     json5_generator.Maker(ComputedStyleBaseWriter).main()