DevTools: split protocol.json into files per domain.

third_party/WebKit/Source/platform/inspector_protocol/CodeGenerator.py

 # 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 os.path
 import sys
 import string
 import optparse
 import re
 try:
@@ skipping 15 matching lines @@
     module_path, os.pardir, os.pardir, os.pardir, os.pardir))
 
 # jinja2 is in chromium's third_party directory.
 # Insert at 1 so at front to override system libraries, and
 # after path[0] == invoking script dir
 
 sys.path.insert(1, third_party_dir)
 import jinja2
 
 cmdline_parser = optparse.OptionParser()
-cmdline_parser.add_option("--domains")
+cmdline_parser.add_option("--protocol")
+cmdline_parser.add_option("--include")
+cmdline_parser.add_option("--string_type")
+cmdline_parser.add_option("--export_macro")
 cmdline_parser.add_option("--output_dir")
 cmdline_parser.add_option("--output_package")
-cmdline_parser.add_option("--string_type")
-cmdline_parser.add_option("--export_macro")
-
-generate_domains = set()
 
 try:
     arg_options, arg_values = cmdline_parser.parse_args()
-    if (len(arg_values) == 0):
-        raise Exception("At least one plain argument expected (found %s)" % len(arg_values))
+    protocol_file = arg_options.protocol
+    if not protocol_file:
+        raise Exception("Protocol directory must be specified")
+    include_file = arg_options.include
     output_dirname = arg_options.output_dir
     if not output_dirname:
         raise Exception("Output directory must be specified")
     output_package = arg_options.output_package
     if not output_package:
         raise Exception("Output package must be specified")
     string_type = arg_options.string_type
     if not string_type:
         raise Exception("String type must be specified")
     export_macro = arg_options.export_macro
     if not export_macro:
         raise Exception("Export macro must be specified")
-    output_domains = arg_options.domains
-    if output_domains and len(output_domains):
-        for domain in output_domains.split(","):
-            generate_domains.add(domain)
 except Exception:
     # Work with python 2 and 3 http://docs.python.org/py3k/howto/pyporting.html
     exc = sys.exc_info()[1]
     sys.stderr.write("Failed to parse command-line arguments: %s\n\n" % exc)
-    sys.stderr.write("Usage: <script> --output_dir <output_dir> protocol.json ...\n")
     exit(1)
 
-json_api = {"domains": []}
 
-json_timestamp = 0
+input_file = open(protocol_file, "r")
+json_string = input_file.read()
+parsed_json = json.loads(json_string)
 
-for filename in arg_values:
-    json_timestamp = max(os.path.getmtime(filename), json_timestamp)
-    input_file = open(filename, "r")
-    json_string = input_file.read()
-    parsed_json = json.loads(json_string)
-    json_api["domains"] += parsed_json["domains"]
+
+# Make gyp / make generatos happy, otherwise make rebuilds world.
+def up_to_date():
+    template_ts = max(
+        os.path.getmtime(__file__),
+        os.path.getmtime(os.path.join(templates_dir, "TypeBuilder_h.template")),
+        os.path.getmtime(os.path.join(templates_dir, "TypeBuilder_cpp.template")),
+        os.path.getmtime(protocol_file))
+
+    for domain in parsed_json["domains"]:
+        name = domain["domain"]
+        h_path = os.path.join(output_dirname, name)
+        cpp_path = os.path.join(output_dirname, name)
+        if not os.path.exists(h_path) or not os.path.exists(cpp_path):
+            return False
+        generated_ts = max(os.path.getmtime(h_path), os.path.getmtime(cpp_path))
+        if generated_ts < template_ts:
+            return False
+    return True
+
+
+if up_to_date():
+    sys.exit()
+
 
 def to_title_case(name):
     return name[:1].upper() + name[1:]
 
 
 def dash_to_camelcase(word):
     return ''.join(to_title_case(x) or '-' for x in word.split('-'))
 
 
 def initialize_jinja_env(cache_dir):
@@ skipping 114 matching lines @@
         "raw_return_type": typedefs[type],
     }
 
 type_definitions = {}
 type_definitions["number"] = create_primitive_type_definition("number")
 type_definitions["integer"] = create_primitive_type_definition("integer")
 type_definitions["boolean"] = create_primitive_type_definition("boolean")
 type_definitions["object"] = create_object_type_definition()
 type_definitions["any"] = create_any_type_definition()
 
+
 def wrap_array_definition(type):
     return {
         "return_type": "std::unique_ptr<protocol::Array<%s>>" % type["raw_type"],
         "pass_type": "std::unique_ptr<protocol::Array<%s>>" % type["raw_type"],
         "to_raw_type": "%s.get()",
         "to_pass_type": "std::move(%s)",
         "to_rvalue": "std::move(%s)",
         "type": "std::unique_ptr<protocol::Array<%s>>" % type["raw_type"],
         "raw_type": "protocol::Array<%s>" % type["raw_type"],
         "raw_pass_type": "protocol::Array<%s>*" % type["raw_type"],
@@ skipping 12 matching lines @@
             if type["type"] == "object":
                 type_definitions[domain["domain"] + "." + type["id"]] = create_user_type_definition(domain["domain"], type)
             elif type["type"] == "array":
                 items_type = type["items"]["type"]
                 type_definitions[domain["domain"] + "." + type["id"]] = wrap_array_definition(type_definitions[items_type])
             elif type["type"] == domain["domain"] + ".string":
                 type_definitions[domain["domain"] + "." + type["id"]] = create_string_type_definition(domain["domain"])
             else:
                 type_definitions[domain["domain"] + "." + type["id"]] = create_primitive_type_definition(type["type"])
 
-patch_full_qualified_refs()
-create_type_definitions()
-
 
 def type_definition(name):
     return type_definitions[name]
 
 
 def resolve_type(property):
     if "$ref" in property:
         return type_definitions[property["$ref"]]
     if property["type"] == "array":
         return wrap_array_definition(resolve_type(property["items"]))
     return type_definitions[property["type"]]
 
 
 def join_arrays(dict, keys):
     result = []
     for key in keys:
         if key in dict:
             result += dict[key]
     return result
 
 
 def has_disable(commands):
     for command in commands:
         if command["name"] == "disable":
             return True
     return False
 
 
-if os.path.exists(__file__):
-    current_script_timestamp = os.path.getmtime(__file__)
-else:
-    current_script_timestamp = 0
+generate_domains = []
+json_api = {}
+json_api["domains"] = parsed_json["domains"]
+
+for domain in parsed_json["domains"]:
+    generate_domains.append(domain["domain"])
+
+if include_file:
+    input_file = open(include_file, "r")
+    json_string = input_file.read()
+    parsed_json = json.loads(json_string)
+    json_api["domains"] += parsed_json["domains"]
 
 
-def is_up_to_date(file, template):
-    if not os.path.exists(file):
-        return False
-    timestamp = os.path.getmtime(file)
-    return timestamp > max(os.path.getmtime(module_path + template),
-                           current_script_timestamp, json_timestamp)
+patch_full_qualified_refs()
+create_type_definitions()
 
 if not os.path.exists(output_dirname):
     os.mkdir(output_dirname)
 jinja_env = initialize_jinja_env(output_dirname)
 
 h_template_name = "/TypeBuilder_h.template"
 cpp_template_name = "/TypeBuilder_cpp.template"
 h_template = jinja_env.get_template(h_template_name)
 cpp_template = jinja_env.get_template(cpp_template_name)
 
 
 def generate(domain):
     class_name = domain["domain"]
     h_file_name = output_dirname + "/" + class_name + ".h"
     cpp_file_name = output_dirname + "/" + class_name + ".cpp"
 
-    if (is_up_to_date(cpp_file_name, cpp_template_name) and
-            is_up_to_date(h_file_name, h_template_name)):
-        return
-
     template_context = {
         "domain": domain,
         "join_arrays": join_arrays,
         "resolve_type": resolve_type,
         "type_definition": type_definition,
         "has_disable": has_disable,
         "export_macro": export_macro,
         "output_package": output_package,
     }
     h_file = output_file(h_file_name)
     cpp_file = output_file(cpp_file_name)
     h_file.write(h_template.render(template_context))
     cpp_file.write(cpp_template.render(template_context))
     h_file.close()
     cpp_file.close()
 
 
 for domain in json_api["domains"]:
     if domain["domain"] in generate_domains:
         generate(domain)