Convert make_names and make_event_factory to use json5 config format.

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

 # Copyright (c) 2017 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.
 
 """Generic generator for configuration files in JSON5 format.
 
 The configuration file is expected to contain either a data array or a data map,
 an optional parameters validation map, and an optional metdata map. Examples:
 {
   data: [
@@ skipping 47 matching lines @@
 import os
 import os.path
 import re
 
 
 def _json5_load(lines):
     # Use json5.loads when json5 is available. Currently we use simple
     # regexs to convert well-formed JSON5 to PYL format.
     # Strip away comments and quote unquoted keys.
     re_comment = re.compile(r"^\s*//.*$|//+ .*$", re.MULTILINE)
-    re_map_keys = re.compile(r"^\s+([$A-Za-z_][\w]*)\s*:", re.MULTILINE)
+    re_map_keys = re.compile(r"^\s*([$A-Za-z_][\w]*)\s*:", re.MULTILINE)
     pyl = re.sub(re_map_keys, r"'\1':", re.sub(re_comment, "", lines))
     # Convert map values of true/false to Python version True/False.
     re_true = re.compile(r":\s*true\b")
     re_false = re.compile(r":\s*false\b")
     pyl = re.sub(re_true, ":True", re.sub(re_false, ":False", pyl))
     return ast.literal_eval(pyl)
 
 
 def _merge_doc(doc, doc2):
     def _merge_dict(key):
         if key in doc or key in doc2:
             merged = doc.get(key, {})
             merged.update(doc2.get(key, {}))
             doc[key] = merged
 
     _merge_dict("metadata")
     _merge_dict("parameters")
     if type(doc["data"]) is list:
         doc["data"].extend(doc2["data"])
     else:
         _merge_dict("data")
 
 
 class Json5File(object):
-    def __init__(self, doc, default_metadata=None):
+    def __init__(self, file_paths, doc, default_metadata=None, default_parameters=None):
+        self.file_paths = file_paths
         self.name_dictionaries = []
         self.metadata = copy.deepcopy(default_metadata if default_metadata else {})
+        self.parameters = copy.deepcopy(default_parameters if default_parameters else {})
         self._defaults = {}
         self._process(doc)
 
     @classmethod
-    def load_from_files(cls, file_paths, default_metadata):
+    def load_from_files(cls, file_paths, default_metadata, default_parameters=None):
         merged_doc = dict()
         for path in file_paths:
             assert path.endswith(".json5")
             with open(os.path.abspath(path)) as json5_file:
                 doc = _json5_load(json5_file.read())
                 if not merged_doc:
                     merged_doc = doc
                 else:
                     _merge_doc(merged_doc, doc)
-        return Json5File(merged_doc, default_metadata)
+        return Json5File(file_paths, merged_doc, default_metadata, default_parameters)
 
     def _process(self, doc):
         # Process optional metadata map entries.
         for key, value in doc.get("metadata", {}).items():
             self._process_metadata(key, value)
         # Get optional parameters map, and get the default value map from it.
-        parameters = doc.get("parameters", {})
-        if parameters:
-            self._get_defaults(parameters)
+        self.parameters.update(doc.get("parameters", {}))
+        if self.parameters:
+            self._get_defaults()
         # Process normal entries.
         items = doc["data"]
         if type(items) is list:
             for item in items:
-                entry = self._get_entry(item, parameters)
+                entry = self._get_entry(item)
                 self.name_dictionaries.append(entry)
         else:
             for key, value in items.items():
                 value["name"] = key
-                entry = self._get_entry(value, parameters)
+                entry = self._get_entry(value)
                 self.name_dictionaries.append(entry)
             self.name_dictionaries.sort(key=lambda entry: entry["name"])
 
     def _process_metadata(self, key, value):
         if key not in self.metadata:
             raise Exception("Unknown metadata: '%s'\nKnown metadata: %s" %
                             (key, self.metadata.keys()))
         self.metadata[key] = value
 
-    def _get_defaults(self, parameters):
-        for key, value in parameters.items():
+    def _get_defaults(self):
+        for key, value in self.parameters.items():
             if value and "default" in value:
                 self._defaults[key] = value["default"]
             else:
                 self._defaults[key] = None
 
-    def _get_entry(self, item, parameters):
+    def _get_entry(self, item):
         entry = copy.deepcopy(self._defaults)
         if type(item) is not dict:
             entry["name"] = item
             return entry
         if "name" not in item:
             raise Exception("Missing name in item: %s" % item)
         entry["name"] = item.pop("name")
         for key, value in item.items():
-            if key not in parameters:
+            if key not in self.parameters:
                 raise Exception(
                     "Unknown parameter: '%s'\nKnown params: %s" %
-                    (key, parameters.keys()))
-            if parameters[key]:
-                self._validate_parameter(parameters[key], value)
+                    (key, self.parameters.keys()))
+            if self.parameters[key]:
+                self._validate_parameter(self.parameters[key], value)
             entry[key] = value
         return entry
 
     def _validate_parameter(self, parameter, value):
         valid_values = parameter.get("valid_values")
         if valid_values and value not in valid_values:
             raise Exception("Unknown value: '%s'\nKnown values: %s" %
                             (value, valid_values))
         valid_type = parameter.get("valid_type")
         if valid_type and type(value).__name__ != valid_type:
             raise Exception("Incorrect type: '%s'\nExpected type: %s" %
                             (type(value).__name__, valid_type))
 
 
 class Writer(object):
     # Subclasses should override.
     class_name = None
     default_metadata = None
+    default_parameters = None
 
     def __init__(self, json5_files):
         self._outputs = {}  # file_name -> generator
         self.gperf_path = None
         if isinstance(json5_files, basestring):
             json5_files = [json5_files]
         if json5_files:
             self.json5_file = Json5File.load_from_files(json5_files,
-                                                        self.default_metadata)
+                                                        self.default_metadata,
+                                                        self.default_parameters)
 
     def _write_file_if_changed(self, output_dir, contents, file_name):
         path = os.path.join(output_dir, file_name)
 
         # The build system should ensure our output directory exists, but just
         # in case.
         directory = os.path.dirname(path)
         if not os.path.exists(directory):
             os.makedirs(directory)
 
@@ skipping 26 matching lines @@
         parser.add_argument("--developer_dir", help="Path to Xcode.")
         parser.add_argument("--output_dir", default=os.getcwd())
         args = parser.parse_args()
 
         if args.developer_dir:
             os.environ["DEVELOPER_DIR"] = args.developer_dir
 
         writer = self._writer_class(args.files)
         writer.set_gperf_path(args.gperf)
         writer.write_files(args.output_dir)