Modify java_cpp_enum.py to preserve comments

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
 from datetime import date
 import re
 import optparse
 import os
 from string import Template
 import sys
 import textwrap
 import zipfile
 
 from util import build_utils
 
 # List of C++ types that are compatible with the Java code generated by this
 # script.
 #
 # This script can parse .idl files however, at present it ignores special
 # rules such as [cpp_enum_prefix_override="ax_attr"].
 ENUM_FIXED_TYPE_WHITELIST = ['char', 'unsigned char',
   'short', 'unsigned short',
   'int', 'int8_t', 'int16_t', 'int32_t', 'uint8_t', 'uint16_t']
 
 class EnumDefinition(object):
   def __init__(self, original_enum_name=None, class_name_override=None,
-               enum_package=None, entries=None, fixed_type=None):
+               enum_package=None, entries=None, comments=None, fixed_type=None):
     self.original_enum_name = original_enum_name
     self.class_name_override = class_name_override
     self.enum_package = enum_package
     self.entries = collections.OrderedDict(entries or [])
+    self.comments = collections.OrderedDict(comments or [])
     self.prefix_to_strip = None
     self.fixed_type = fixed_type
 
   def AppendEntry(self, key, value):
     if key in self.entries:
       raise Exception('Multiple definitions of key %s found.' % key)
     self.entries[key] = value
 
+  def AppendEntryComment(self, key, value):
+    if key in self.comments:
+      raise Exception('Multiple definitions of key %s found.' % key)
+    self.comments[key] = value
+
   @property
   def class_name(self):
     return self.class_name_override or self.original_enum_name
 
   def Finalize(self):
     self._Validate()
     self._AssignEntryIndices()
     self._StripPrefix()
 
   def _Validate(self):
@@ skipping 64 matching lines @@
   def UpdateDefinition(self, definition):
     definition.class_name_override = self._directives.get(
         DirectiveSet.class_name_override_key, '')
     definition.enum_package = self._directives.get(
         DirectiveSet.enum_package_key)
     definition.prefix_to_strip = self._directives.get(
         DirectiveSet.prefix_to_strip_key)
 
 
 class HeaderParser(object):
-  single_line_comment_re = re.compile(r'\s*//')
+  single_line_comment_re = re.compile(r'\s*//\s*([^\n]+)')
   multi_line_comment_start_re = re.compile(r'\s*/\*')
   enum_line_re = re.compile(r'^\s*(\w+)(\s*\=\s*([^,\n]+))?,?')
   enum_end_re = re.compile(r'^\s*}\s*;\.*$')
   generator_directive_re = re.compile(
       r'^\s*//\s+GENERATED_JAVA_(\w+)\s*:\s*([\.\w]+)$')
   multi_line_generator_directive_start_re = re.compile(
       r'^\s*//\s+GENERATED_JAVA_(\w+)\s*:\s*\(([\.\w]*)$')
   multi_line_directive_continuation_re = re.compile(
       r'^\s*//\s+([\.\w]+)$')
   multi_line_directive_end_re = re.compile(
       r'^\s*//\s+([\.\w]*)\)$')
 
   optional_class_or_struct_re = r'(class|struct)?'
   enum_name_re = r'(\w+)'
   optional_fixed_type_re = r'(\:\s*(\w+\s*\w+?))?'
   enum_start_re = re.compile(r'^\s*(?:\[cpp.*\])?\s*enum\s+' +
       optional_class_or_struct_re + '\s*' + enum_name_re + '\s*' +
       optional_fixed_type_re + '\s*{\s*$')
 
   def __init__(self, lines, path=None):
     self._lines = lines
     self._path = path
     self._enum_definitions = []
     self._in_enum = False
     self._current_definition = None
+    self._current_comments = []
     self._generator_directives = DirectiveSet()
     self._multi_line_generator_directive = None
 
   def _ApplyGeneratorDirectives(self):
     self._generator_directives.UpdateDefinition(self._current_definition)
     self._generator_directives = DirectiveSet()
 
   def ParseDefinitions(self):
     for line in self._lines:
       self._ParseLine(line)
     return self._enum_definitions
 
   def _ParseLine(self, line):
     if self._multi_line_generator_directive:
       self._ParseMultiLineDirectiveLine(line)
     elif not self._in_enum:
       self._ParseRegularLine(line)
     else:
       self._ParseEnumLine(line)
 
   def _ParseEnumLine(self, line):
     if HeaderParser.single_line_comment_re.match(line):
+      enum_comment = HeaderParser.single_line_comment_re.match(line).groups()[0]

[agrieve, 2016/08/03 23:09:53]

nit: Avoid calling match() twice using a variable.

[xunjieli, 2016/08/04 13:54:22]

Done.

+      if len(self._current_comments) > 0:
+        self._current_comments.append(' ')

[agrieve, 2016/08/03 23:09:53]

nit: Could you just use ' '.join() later on rather than adding in spaces?

[xunjieli, 2016/08/04 13:54:22]

Done. Ah, you are right! I didn't thought about that.

+      self._current_comments.append(enum_comment)
       return
     if HeaderParser.multi_line_comment_start_re.match(line):
       raise Exception('Multi-line comments in enums are not supported in ' +
                       self._path)
     enum_end = HeaderParser.enum_end_re.match(line)
     enum_entry = HeaderParser.enum_line_re.match(line)
     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)
+      if self._current_comments:
+         self._current_definition.AppendEntryComment(
+                 enum_key, ''.join(self._current_comments))
+         self._current_comments = []
 
   def _ParseMultiLineDirectiveLine(self, line):
     multi_line_directive_continuation = (
         HeaderParser.multi_line_directive_continuation_re.match(line))
     multi_line_directive_end = (
         HeaderParser.multi_line_directive_end_re.match(line))
 
     if multi_line_directive_continuation:
       value_cont = multi_line_directive_continuation.groups()[0]
       self._multi_line_generator_directive[1].append(value_cont)
@@ skipping 82 matching lines @@
 """)
 
   enum_template = Template('  public static final int ${NAME} = ${VALUE};')
   enum_entries_string = []
   enum_names = []
   for enum_name, enum_value in enum_definition.entries.iteritems():
     values = {
         'NAME': enum_name,
         'VALUE': enum_value,
     }
+    enum_comments = enum_definition.comments.get(enum_name)
+    if enum_comments:
+        enum_comments_indent = '   * '
+        comments_line_wrapper = textwrap.TextWrapper(
+                initial_indent = enum_comments_indent,

[agrieve, 2016/08/03 23:09:53]

nit: no spaces around = for arguments.  initial_indent=enum_comments_indent,

[xunjieli, 2016/08/04 13:54:22]

Done.

+                subsequent_indent = enum_comments_indent,
+                width = 100)
+        enum_entries_string.append('  /**')
+        enum_entries_string.append(
+                '\n'.join(comments_line_wrapper.wrap(enum_comments)))
+        enum_entries_string.append('   */')
     enum_entries_string.append(enum_template.substitute(values))
     enum_names.append(enum_name)
   enum_entries_string = '\n'.join(enum_entries_string)
 
   enum_names_indent = ' ' * 6
   wrapper = textwrap.TextWrapper(initial_indent = enum_names_indent,
                                  subsequent_indent = enum_names_indent,
                                  width = 100)
   enum_names_string = '\n'.join(wrapper.wrap(', '.join(enum_names)))
 
@@ skipping 83 matching lines @@
     if options.verbose:
       print 'Output paths:'
       print '\n'.join(output_paths)
 
     # Used by GYP.
     return ' '.join(output_paths)
 
 
 if __name__ == '__main__':
   DoMain(sys.argv[1:])