Final step of the java_cpp_template -> java_cpp_enum migration.

build/android/gyp/java_cpp_enum.py

 #!/usr/bin/env python
 #
 # Copyright 2014 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 collections
 import re
 import optparse
 import os
 from string import Template
 import sys
 
 from util import build_utils
 
 class EnumDefinition(object):
-  def __init__(self, class_name=None, class_package=None, entries=None):
-    self.class_name = class_name
+  def __init__(self, original_enum_name=None, override_class_name=None,
+               class_package=None, entries=None):
+    self.original_enum_name = original_enum_name
+    self.override_class_name = override_class_name
     self.class_package = class_package
     self.entries = collections.OrderedDict(entries or [])
-    self.prefix_to_strip = ''
+    self.prefix_to_strip = None
 
   def AppendEntry(self, key, value):
     if key in self.entries:
       raise Exception('Multiple definitions of key %s found.' % key)
     self.entries[key] = value
 
+  @property
+  def class_name(self):
+    return self.override_class_name or self.original_enum_name
+
   def Finalize(self):
     self._Validate()
     self._AssignEntryIndices()
     self._StripPrefix()
 
   def _Validate(self):
     assert self.class_name
     assert self.class_package
     assert self.entries
 
   def _AssignEntryIndices(self):
     # Enums, if given no value, are given the value of the previous enum + 1.
     if not all(self.entries.values()):
       prev_enum_value = -1
       for key, value in self.entries.iteritems():
         if not value:
           self.entries[key] = prev_enum_value + 1
         elif value in self.entries:
           self.entries[key] = self.entries[value]
         else:
           try:
             self.entries[key] = int(value)
           except ValueError:
             raise Exception('Could not interpret integer from enum value "%s" '
                             'for key %s.' % (value, key))
         prev_enum_value = self.entries[key]
 
 
   def _StripPrefix(self):
-    if not self.prefix_to_strip:
-      prefix_to_strip = re.sub('(?!^)([A-Z]+)', r'_\1', self.class_name).upper()
+    prefix_to_strip = self.prefix_to_strip
+    if not prefix_to_strip:
+      prefix_to_strip = self.original_enum_name
+      prefix_to_strip = re.sub('(?!^)([A-Z]+)', r'_\1', prefix_to_strip).upper()
       prefix_to_strip += '_'
       if not all([w.startswith(prefix_to_strip) for w in self.entries.keys()]):
         prefix_to_strip = ''
-    else:
-      prefix_to_strip = self.prefix_to_strip
-    entries = ((k.replace(prefix_to_strip, '', 1), v) for (k, v) in
-               self.entries.iteritems())
-    self.entries = collections.OrderedDict(entries)
+
+    entries = collections.OrderedDict()
+    for (k, v) in self.entries.iteritems():
+      stripped_key = k.replace(prefix_to_strip, '', 1)
+      if isinstance(v, basestring):
+        stripped_value = v.replace(prefix_to_strip, '', 1)
+      else:
+        stripped_value = v
+      entries[stripped_key] = stripped_value
+
+    self.entries = entries
 
 class HeaderParser(object):
   single_line_comment_re = re.compile(r'\s*//')
   multi_line_comment_start_re = re.compile(r'\s*/\*')
   enum_start_re = re.compile(r'^\s*enum\s+(\w+)\s+{\s*$')
   enum_line_re = re.compile(r'^\s*(\w+)(\s*\=\s*([^,\n]+))?,?')
-  enum_end_re = re.compile(r'^\s*}\s*;\s*$')
+  enum_end_re = re.compile(r'^\s*}\s*;\.*$')
   generator_directive_re = re.compile(
       r'^\s*//\s+GENERATED_JAVA_(\w+)\s*:\s*([\.\w]+)$')
 
   def __init__(self, lines):
     self._lines = lines
     self._enum_definitions = []
     self._in_enum = False
     self._current_definition = None
     self._generator_directives = {}
 
@@ skipping 18 matching lines @@
     if enum_end:
       self._ApplyGeneratorDirectives()
       self._current_definition.Finalize()
       self._enum_definitions.append(self._current_definition)
       self._in_enum = False
     elif enum_entry:
       enum_key = enum_entry.groups()[0]
       enum_value = enum_entry.groups()[2]
       self._current_definition.AppendEntry(enum_key, enum_value)
 
+  def _GetCurrentEnumClassNameOverride(self):
+    return self._generator_directives.get('CLASS_NAME_OVERRIDE')
+
   def _GetCurrentEnumPackageName(self):
     return self._generator_directives.get('ENUM_PACKAGE')
 
   def _GetCurrentEnumPrefixToStrip(self):
     return self._generator_directives.get('PREFIX_TO_STRIP', '')
 
   def _ApplyGeneratorDirectives(self):
     current_definition = self._current_definition
     current_definition.class_package = self._GetCurrentEnumPackageName()
     current_definition.prefix_to_strip = self._GetCurrentEnumPrefixToStrip()

[cjhopman, 2014/10/16 16:54:51]

We should probably have this check that you aren't using an unrecognized
directive.

[mkosiba (inactive), 2014/10/20 15:09:05]

Done.

     self._generator_directives = {}
 
   def _ParseRegularLine(self, line):
     enum_start = HeaderParser.enum_start_re.match(line)
     generator_directive = HeaderParser.generator_directive_re.match(line)
     if enum_start:
       if not self._GetCurrentEnumPackageName():
         return
-      self._current_definition = EnumDefinition()
-      self._current_definition.class_name = enum_start.groups()[0]
+      self._current_definition = EnumDefinition(
+          original_enum_name=enum_start.groups()[0],
+          override_class_name=self._GetCurrentEnumClassNameOverride())
       self._in_enum = True
     elif generator_directive:
       directive_name = generator_directive.groups()[0]
       directive_value = generator_directive.groups()[1]
       self._generator_directives[directive_name] = directive_value
 
 
 def GetScriptName():
   script_components = os.path.abspath(sys.argv[0]).split(os.path.sep)
   build_index = script_components.index('build')
@@ skipping 86 matching lines @@
 
   output_paths = DoGenerate(options, args)
 
   if options.assert_files_list:
     AssertFilesList(output_paths, options.assert_files_list)
 
   return " ".join(output_paths)
 
 if __name__ == '__main__':
   DoMain(sys.argv[1:])