1#!/usr/bin/env python
2# Copyright (c) 2011 Google Inc. All rights reserved.
3#
4# Redistribution and use in source and binary forms, with or without
5# modification, are permitted provided that the following conditions are
6# met:
7#
8#     * Redistributions of source code must retain the above copyright
9# notice, this list of conditions and the following disclaimer.
10#     * Redistributions in binary form must reproduce the above
11# copyright notice, this list of conditions and the following disclaimer
12# in the documentation and/or other materials provided with the
13# distribution.
14#     * Neither the name of Google Inc. nor the names of its
15# contributors may be used to endorse or promote products derived from
16# this software without specific prior written permission.
17#
18# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30import os
31import re
32import json
33
34type_traits = {
35    "any": "*",
36    "string": "string",
37    "integer": "number",
38    "number": "number",
39    "boolean": "boolean",
40    "array": "!Array.<*>",
41    "object": "!Object",
42}
43
44promisified_domains = {
45    "Accessibility",
46    "Animation",
47    "CSS",
48    "Emulation",
49    "Profiler"
50}
51
52ref_types = {}
53
54def full_qualified_type_id(domain_name, type_id):
55    if type_id.find(".") == -1:
56        return "%s.%s" % (domain_name, type_id)
57    return type_id
58
59
60def fix_camel_case(name):
61    prefix = ""
62    if name[0] == "-":
63        prefix = "Negative"
64        name = name[1:]
65    refined = re.sub(r'-(\w)', lambda pat: pat.group(1).upper(), name)
66    refined = to_title_case(refined)
67    return prefix + re.sub(r'(?i)HTML|XML|WML|API', lambda pat: pat.group(0).upper(), refined)
68
69
70def to_title_case(name):
71    return name[:1].upper() + name[1:]
72
73
74def generate_enum(name, json):
75    enum_members = []
76    for member in json["enum"]:
77        enum_members.append("    %s: \"%s\"" % (fix_camel_case(member), member))
78    return "\n/** @enum {string} */\n%s = {\n%s\n};\n" % (name, (",\n".join(enum_members)))
79
80
81def param_type(domain_name, param):
82    if "type" in param:
83        if param["type"] == "array":
84            items = param["items"]
85            return "!Array.<%s>" % param_type(domain_name, items)
86        else:
87            return type_traits[param["type"]]
88    if "$ref" in param:
89        type_id = full_qualified_type_id(domain_name, param["$ref"])
90        if type_id in ref_types:
91            return ref_types[type_id]
92        else:
93            print "Type not found: " + type_id
94            return "!! Type not found: " + type_id
95
96
97def load_schema(file, domains):
98    input_file = open(file, "r")
99    json_string = input_file.read()
100    parsed_json = json.loads(json_string)
101    domains.extend(parsed_json["domains"])
102
103
104def generate_protocol_externs(output_path, file1):
105    domains = []
106    load_schema(file1, domains)
107    output_file = open(output_path, "w")
108
109    output_file.write(
110"""
111var InspectorBackend = {}
112
113var Protocol = {};
114/** @typedef {string}*/
115Protocol.Error;
116""")
117
118    for domain in domains:
119        domain_name = domain["domain"]
120        if "types" in domain:
121            for type in domain["types"]:
122                type_id = full_qualified_type_id(domain_name, type["id"])
123                ref_types[type_id] = "%sAgent.%s" % (domain_name, type["id"])
124
125    for domain in domains:
126        domain_name = domain["domain"]
127        promisified = domain_name in promisified_domains
128
129        output_file.write("\n\n/**\n * @constructor\n*/\n")
130        output_file.write("Protocol.%sAgent = function(){};\n" % domain_name)
131
132        if "commands" in domain:
133            for command in domain["commands"]:
134                output_file.write("\n/**\n")
135                params = []
136                has_return_value = "returns" in command
137                explicit_parameters = promisified and has_return_value
138                if ("parameters" in command):
139                    for in_param in command["parameters"]:
140                        # All parameters are not optional in case of promisified domain with return value.
141                        if (not explicit_parameters and "optional" in in_param):
142                            params.append("opt_%s" % in_param["name"])
143                            output_file.write(" * @param {%s=} opt_%s\n" % (param_type(domain_name, in_param), in_param["name"]))
144                        else:
145                            params.append(in_param["name"])
146                            output_file.write(" * @param {%s} %s\n" % (param_type(domain_name, in_param), in_param["name"]))
147                returns = []
148                returns.append("?Protocol.Error")
149                if ("error" in command):
150                    returns.append("%s=" % param_type(domain_name, command["error"]))
151                if (has_return_value):
152                    for out_param in command["returns"]:
153                        if ("optional" in out_param):
154                            returns.append("%s=" % param_type(domain_name, out_param))
155                        else:
156                            returns.append("%s" % param_type(domain_name, out_param))
157                callback_return_type = "void="
158                if explicit_parameters:
159                    callback_return_type = "T"
160                elif promisified:
161                    callback_return_type = "T="
162                output_file.write(" * @param {function(%s):%s} opt_callback\n" % (", ".join(returns), callback_return_type))
163                if (promisified):
164                    output_file.write(" * @return {!Promise.<T>}\n")
165                    output_file.write(" * @template T\n")
166                params.append("opt_callback")
167
168                output_file.write(" */\n")
169                output_file.write("Protocol.%sAgent.prototype.%s = function(%s) {}\n" % (domain_name, command["name"], ", ".join(params)))
170                output_file.write("/** @param {function(%s):void=} opt_callback */\n" % ", ".join(returns))
171                output_file.write("Protocol.%sAgent.prototype.invoke_%s = function(obj, opt_callback) {}\n" % (domain_name, command["name"]))
172
173        output_file.write("\n\n\nvar %sAgent = function(){};\n" % domain_name)
174
175        if "types" in domain:
176            for type in domain["types"]:
177                if type["type"] == "object":
178                    typedef_args = []
179                    if "properties" in type:
180                        for property in type["properties"]:
181                            suffix = ""
182                            if ("optional" in property):
183                                suffix = "|undefined"
184                            if "enum" in property:
185                                enum_name = "%sAgent.%s%s" % (domain_name, type["id"], to_title_case(property["name"]))
186                                output_file.write(generate_enum(enum_name, property))
187                                typedef_args.append("%s:(%s%s)" % (property["name"], enum_name, suffix))
188                            else:
189                                typedef_args.append("%s:(%s%s)" % (property["name"], param_type(domain_name, property), suffix))
190                    if (typedef_args):
191                        output_file.write("\n/** @typedef {!{%s}} */\n%sAgent.%s;\n" % (", ".join(typedef_args), domain_name, type["id"]))
192                    else:
193                        output_file.write("\n/** @typedef {!Object} */\n%sAgent.%s;\n" % (domain_name, type["id"]))
194                elif type["type"] == "string" and "enum" in type:
195                    output_file.write(generate_enum("%sAgent.%s" % (domain_name, type["id"]), type))
196                elif type["type"] == "array":
197                    output_file.write("\n/** @typedef {!Array.<!%s>} */\n%sAgent.%s;\n" % (param_type(domain_name, type["items"]), domain_name, type["id"]))
198                else:
199                    output_file.write("\n/** @typedef {%s} */\n%sAgent.%s;\n" % (type_traits[type["type"]], domain_name, type["id"]))
200
201        output_file.write("/** @interface */\n")
202        output_file.write("%sAgent.Dispatcher = function() {};\n" % domain_name)
203        if "events" in domain:
204            for event in domain["events"]:
205                params = []
206                if ("parameters" in event):
207                    output_file.write("/**\n")
208                    for param in event["parameters"]:
209                        if ("optional" in param):
210                            params.append("opt_%s" % param["name"])
211                            output_file.write(" * @param {%s=} opt_%s\n" % (param_type(domain_name, param), param["name"]))
212                        else:
213                            params.append(param["name"])
214                            output_file.write(" * @param {%s} %s\n" % (param_type(domain_name, param), param["name"]))
215                    output_file.write(" */\n")
216                output_file.write("%sAgent.Dispatcher.prototype.%s = function(%s) {};\n" % (domain_name, event["name"], ", ".join(params)))
217
218    output_file.write("\n/** @constructor\n * @param {!Object.<string, !Object>} agentsMap\n */\n")
219    output_file.write("Protocol.Agents = function(agentsMap){this._agentsMap;};\n")
220    output_file.write("/**\n * @param {string} domain\n * @param {!Object} dispatcher\n */\n")
221    output_file.write("Protocol.Agents.prototype.registerDispatcher = function(domain, dispatcher){};\n")
222    for domain in domains:
223        domain_name = domain["domain"]
224        uppercase_length = 0
225        while uppercase_length < len(domain_name) and domain_name[uppercase_length].isupper():
226            uppercase_length += 1
227
228        output_file.write("/** @return {!Protocol.%sAgent}*/\n" % domain_name)
229        output_file.write("Protocol.Agents.prototype.%s = function(){};\n" % (domain_name[:uppercase_length].lower() + domain_name[uppercase_length:] + "Agent"))
230
231        output_file.write("/**\n * @param {!%sAgent.Dispatcher} dispatcher\n */\n" % domain_name)
232        output_file.write("Protocol.Agents.prototype.register%sDispatcher = function(dispatcher) {}\n" % domain_name)
233
234
235    output_file.close()
236
237if __name__ == "__main__":
238    import sys
239    import os.path
240    program_name = os.path.basename(__file__)
241    if len(sys.argv) < 4 or sys.argv[1] != "-o":
242        sys.stderr.write("Usage: %s -o OUTPUT_FILE INPUT_FILE\n" % program_name)
243        exit(1)
244    output_path = sys.argv[2]
245    input_path = sys.argv[3]
246    generate_protocol_externs(output_path, input_path)
247