JSON Schema Compiler: Added event compilation.

tools/json_schema_compiler/model.py

 # Copyright (c) 2012 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 copy
 import os.path
 import re
 
 class ParseException(Exception):
   """Thrown when data in the model is invalid.
@@ skipping 24 matching lines @@
   """An API namespace.
 
   Properties:
   - |name| the name of the namespace
   - |unix_name| the unix_name of the namespace
   - |source_file| the file that contained the namespace definition
   - |source_file_dir| the directory component of |source_file|
   - |source_file_filename| the filename component of |source_file|
   - |types| a map of type names to their model.Type
   - |functions| a map of function names to their model.Function
+  - |events| a map of event names to their model.Function
   - |properties| a map of property names to their model.Property
   """
   def __init__(self, json, source_file):
     self.name = json['namespace']
     self.unix_name = UnixName(self.name)
     self.source_file = source_file
     self.source_file_dir, self.source_file_filename = os.path.split(source_file)
     self.parent = None
     _AddTypes(self, json)
     _AddFunctions(self, json)
+    _AddEvents(self, json)
     _AddProperties(self, json)
 
 class Type(object):
   """A Type defined in the json.
 
   Properties:
   - |name| the type name
   - |description| the description of the type (if provided)
   - |properties| a map of property unix_names to their model.Property
   - |functions| a map of function names to their model.Function
@@ skipping 37 matching lines @@
           additional_properties,
           is_additional_properties=True)
 
 class Callback(object):
   """A callback parameter to a Function.
 
   Properties:
   - |params| the parameters to this callback.
   """
   def __init__(self, parent, json):
-    params = json['parameters']
+    params = json.get('parameters', [])
     self.parent = parent
     self.params = []
     if len(params) == 0:
       return
     elif len(params) == 1:
       param = params[0]
       self.params.append(Property(self, param['name'], param,
           from_client=True))
     else:
       raise ParseException(
           self,
           "Callbacks can have at most a single parameter")
 
 class Function(object):
   """A Function defined in the API.
 
   Properties:
   - |name| the function name
   - |params| a list of parameters to the function (order matters). A separate
     parameter is used for each choice of a 'choices' parameter.
   - |description| a description of the function (if provided)
   - |callback| the callback parameter to the function. There should be exactly
     one
   """
-  def __init__(self, parent, json):
+  def __init__(self, parent, json, from_json=False, from_client=False):
     self.name = json['name']
     self.params = []
     self.description = json.get('description')
     self.callback = None
     self.parent = parent
     self.nocompile = json.get('nocompile')
     for param in json['parameters']:
       if param.get('type') == 'function':
         if self.callback:
           raise ParseException(self, self.name + " has more than one callback")
         self.callback = Callback(self, param)
       else:
         self.params.append(Property(self, param['name'], param,
-            from_json=True))
+            from_json=from_json, from_client=from_client))
 
 class Property(object):
   """A property of a type OR a parameter to a function.
 
   Properties:
   - |name| name of the property as in the json. This shouldn't change since
     it is the key used to access DictionaryValues
   - |unix_name| the unix_style_name of the property. Used as variable name
   - |optional| a boolean representing whether the property is optional
   - |description| a description of the property (if provided)
@@ skipping 23 matching lines @@
     self.description = json.get('description')
     self.parent = parent
     _AddProperties(self, json)
     if is_additional_properties:
       self.type_ = PropertyType.ADDITIONAL_PROPERTIES
     elif '$ref' in json:
       self.ref_type = json['$ref']
       self.type_ = PropertyType.REF
     elif 'enum' in json:
       self.enum_values = []
+      self.from_json = from_json
+      self.from_client = from_client
       for value in json['enum']:
         self.enum_values.append(value)
       self.type_ = PropertyType.ENUM
     elif 'type' in json:
       json_type = json['type']
       if json_type == 'string':
         self.type_ = PropertyType.STRING
       elif json_type == 'any':
         self.type_ = PropertyType.ANY
       elif json_type == 'boolean':
@@ skipping 127 matching lines @@
 
 def _AddTypes(model, json):
   """Adds Type objects to |model| contained in the 'types' field of |json|.
   """
   model.types = {}
   for type_json in json.get('types', []):
     type_ = Type(model, type_json['id'], type_json)
     model.types[type_.name] = type_
 
 def _AddFunctions(model, json):
-  """Adds Function objects to |model| contained in the 'types' field of |json|.
+  """Adds Function objects to |model| contained in the 'functions' field of
+  |json|.
   """
   model.functions = {}
   for function_json in json.get('functions', []):
-    function = Function(model, function_json)
+    function = Function(model, function_json, from_json=True)
     model.functions[function.name] = function
 
+def _AddEvents(model, json):
+  """Adds Function objects to |model| contained in the 'events' field of |json|.
+  """
+  model.events = {}
+  for event_json in json.get('events', []):
+    event = Function(model, event_json, from_client=True)
+    model.events[event.name] = event
+
 def _AddProperties(model, json, from_json=False, from_client=False):
   """Adds model.Property objects to |model| contained in the 'properties' field
   of |json|.
   """
   model.properties = {}
   for name, property_json in json.get('properties', {}).items():
     # TODO(calamity): support functions (callbacks) as properties.  The model
     # doesn't support it yet because the h/cc generators don't -- this is
     # because we'd need to hook it into a base::Callback or something.
     #
     # However, pragmatically it's not necessary to support them anyway, since
     # the instances of functions-on-properties in the extension APIs are all
     # handled in pure Javascript on the render process (and .: never reach
     # C++ let alone the browser).
     if property_json.get('type') == 'function':
       continue
     model.properties[name] = Property(
         model,
         name,
         property_json,
         from_json=from_json,
         from_client=from_client)