Let json schema compiler handle using arrays as types

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 Model(object):
   """Model of all namespaces that comprise an API.
@@ skipping 32 matching lines @@
     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.types = {}
     self.functions = {}
     self.parent = None
     # TODO(calamity): Implement properties on namespaces for shared structures
     # or constants across a namespace (e.g Windows::WINDOW_ID_NONE).
     for property_json in json.get('properties', []):
       pass
     for type_json in json.get('types', []):

[Yoyo Zhou, 2012/04/09 23:48:47]

This looks fragile. You're building the types and passing the list of types in
as you go along, so it is now dependent on the order in which things are
declared (although I think the ordering is okay in existing API json).

An alternative approach is to not try to establish what kind of referenced type
you have until you need to use it. (I wrote more about that in the other
comment.)

[cduvall, 2012/04/10 03:06:08]

Fixed this to not pass types around everywhere.

-      type_ = Type(self, type_json['id'], type_json)
+      type_ = Type(self, type_json['id'], type_json, self.types)
       self.types[type_.name] = type_
     for function_json in json.get('functions', []):
       if not function_json.get('nocompile', False):
-        self.functions[function_json['name']] = Function(self, function_json)
+        self.functions[function_json['name']] = Function(self, function_json,

[Yoyo Zhou, 2012/04/09 23:48:47]

nit: line continuation should be 4 spaces if you put the first arg on the new
line, otherwise it should line up with the open paren. (Sadly, that isn't the
style in most of the file.)

[cduvall, 2012/04/10 03:06:08]

Done.

+            self.types)
 
 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
   - |from_client| indicates that instances of the Type can originate from the
     users of generated code, such as top-level types and function results
   - |from_json| indicates that instances of the Type can originate from the
     JSON (as described by the schema), such as top-level types and function
     parameters
   """
-  def __init__(self, parent, name, json):
-    if not (
-        'properties' in json or
-        'additionalProperties' in json or
-        'functions' in json):
-      raise ParseException(name + " has no properties or functions")
+  def __init__(self, parent, name, json, types):
+    if json.get('type') == 'array':
+      self.type_ = PropertyType.ARRAY
+      self.item_type = Property(self, name + "Element", json['items'], types,
+          from_json=True,
+          from_client=True)
+    else:
+      if not (
+          'properties' in json or
+          'additionalProperties' in json or
+          'functions' in json):
+        raise ParseException(name + " has no properties or functions")
+      self.type_ = PropertyType.OBJECT
     self.name = name
     self.description = json.get('description')
     self.from_json = True
     self.from_client = True
     self.properties = {}
     self.functions = {}
     self.parent = parent
     for function_json in json.get('functions', []):
       if not function_json.get('nocompile', False):
-        self.functions[function_json['name']] = Function(self, function_json)
+        self.functions[function_json['name']] = Function(self, function_json,
+            types)
     props = []
     for prop_name, prop_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 prop_json.get('type') == 'function':
         continue
-      props.append(Property(self, prop_name, prop_json,
+      props.append(Property(self, prop_name, prop_json, types,
           from_json=True,
           from_client=True))
 
     additional_properties = json.get('additionalProperties')
     if additional_properties:
       props.append(Property(self, 'additionalProperties', additional_properties,
-          is_additional_properties=True))
+          types, is_additional_properties=True))
 
     for prop in props:
       if prop.unix_name in self.properties:
         raise ParseException(
             self.properties[prop.unix_name].name + ' and ' + prop.name +
             ' are both named ' + prop.unix_name)
       self.properties[prop.unix_name] = prop
 
 class Callback(object):
   """A callback parameter to a Function.
 
   Properties:
   - |params| the parameters to this callback.
   """
-  def __init__(self, parent, json):
+  def __init__(self, parent, json, types):
     params = json['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,
+      self.params.append(Property(self, param['name'], param, types,
           from_client=True))
     else:
       raise ParseException("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, types):
     self.name = json['name']
     self.params = []
     self.description = json.get('description')
     self.callback = None
     self.parent = parent
     for param in json['parameters']:
       if param.get('type') == 'function':
         if self.callback:
           raise ParseException(self.name + " has more than one callback")
-        self.callback = Callback(self, param)
+        self.callback = Callback(self, param, types)
       else:
-        self.params.append(Property(self, param['name'], param,
+        self.params.append(Property(self, param['name'], param, types,
             from_json=True))
 
 class Property(object):
   """A property of a type OR a parameter to a function.
 
   Properties:

[Yoyo Zhou, 2012/04/09 23:48:47]

Make sure to update these.

[cduvall, 2012/04/10 03:06:08]

Done.

   - |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)
   - |type_| the model.PropertyType of this property
   - |ref_type| the type that the REF property is referencing. Can be used to
     map to its model.Type
   - |item_type| a model.Property representing the type of each element in an
     ARRAY
   - |properties| the properties of an OBJECT parameter
   """
 
-  def __init__(self, parent, name, json, is_additional_properties=False,
+  def __init__(self, parent, name, json, types, is_additional_properties=False,
       from_json=False, from_client=False):
     """
     Parameters:
     - |from_json| indicates that instances of the Type can originate from the
       JSON (as described by the schema), such as top-level types and function
       parameters
     - |from_client| indicates that instances of the Type can originate from the
       users of generated code, such as top-level types and function results
     """
     self.name = name
     self._unix_name = UnixName(self.name)
     self._unix_name_used = False
     self.optional = json.get('optional', False)
     self.description = json.get('description')
     self.parent = parent
+    self.is_array = False
     if is_additional_properties:
       self.type_ = PropertyType.ADDITIONAL_PROPERTIES
     elif '$ref' in json:
       self.ref_type = json['$ref']
       self.type_ = PropertyType.REF
+      if self.ref_type in types:
+        type_reffed = types[self.ref_type]
+        self.is_array = type_reffed.type_ == PropertyType.ARRAY
+        if self.is_array:
+          self.item_type = type_reffed.item_type
     elif 'enum' in json:
       self.enum_values = []
       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':
         self.type_ = PropertyType.BOOLEAN
       elif json_type == 'integer':
         self.type_ = PropertyType.INTEGER
       elif json_type == 'number':
         self.type_ = PropertyType.DOUBLE
       elif json_type == 'array':
-        self.item_type = Property(self, name + "Element", json['items'],
+        self.item_type = Property(self, name + "Element", json['items'], types,
             from_json=from_json,
             from_client=from_client)
         self.type_ = PropertyType.ARRAY
       elif json_type == 'object':
         self.type_ = PropertyType.OBJECT
         # These members are read when this OBJECT Property is used as a Type
         self.properties = {}
         self.from_json = from_json
         self.from_client = from_client
-        type_ = Type(self, self.name, json)
+        type_ = Type(self, self.name, json, types)
         self.properties = type_.properties
         self.functions = type_.functions
       else:
         raise ParseException(self, 'type ' + json_type + ' not recognized')
     elif 'choices' in json:
       if not json['choices']:
         raise ParseException('Choices has no choices')
       self.choices = {}
       self.type_ = PropertyType.CHOICES
       for choice_json in json['choices']:
-        choice = Property(self, self.name, choice_json,
+        choice = Property(self, self.name, choice_json, types,
             from_json=from_json,
             from_client=from_client)
         # A choice gets its unix_name set in
         # cpp_type_generator.GetExpandedChoicesInParams
         choice._unix_name = None
         # The existence of any single choice is optional
         choice.optional = True
         self.choices[choice.type_] = choice
     else:
       raise ParseException('Property has no type, $ref or choices')
@@ skipping 74 matching lines @@
   """Returns the hierarchy of the given model entity."""
   hierarchy = []
   while entity:
     try:
       hierarchy.append(entity.name)
     except AttributeError:
       hierarchy.append(repr(entity))
     entity = entity.parent
   hierarchy.reverse()
   return hierarchy