Add wider support to json_schema_compiler

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 os.path
 import re
 import copy
 
 class Model(object):
   """Model of all namespaces that comprise an API.
@@ skipping 42 matching lines @@
         function = Function(function_json)
         self.functions[function.name] = function
 
 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 names to their model.Property
+  - |serializable| indicates whether the Type should support conversion back to
+    the input format

[not at google - send to devlin, 2012/02/24 03:53:05]

i don't understand this comment in isolation. what's the "input format"? a
Value?

there are a lot of True/False scattered throughout this file. Could you also
explain why (in this comment) something is serializable or not? as in, what
determines that.

also, since boolean values as arguments are evil (very hard to read), can you
make it named? like serializable=False or whatever.

[calamity, 2012/02/24 15:10:40]

Made the changes we discussed. Settled on to_api and from_api as the names. Let
me know if you think of something better.

   """
   def __init__(self, json):
     self.name = json['id']
     self.description = json.get('description')
+    self.serializable = True
     self.properties = {}
     for prop_name, prop_json in json['properties'].items():
-      self.properties[prop_name] = Property(prop_name, prop_json)
+      self.properties[prop_name] = Property(prop_name, prop_json, False)
 
 class Callback(object):
   """A callback parameter to a Function.
 
   Properties:
   - |params| the parameters to this callback.
   """
   def __init__(self, json):
     params = json['parameters']
     self.params = []
     if len(params) == 0:
       return
     elif len(params) == 1:
       param = params[0]
-      self.params.append(Property(param['name'], param))
+      self.params.append(Property(param['name'], param, True))
     else:
       raise AssertionError("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, json):
     self.name = json['name']
     self.params = []
     self.description = json['description']
     self.callback = None
     for param in json['parameters']:
       if param.get('type') == 'function':
         assert (not self.callback), self.name + " has more than one callback"
         self.callback = Callback(param)
       else:
-        self.params.append(Property(param['name'], param))
-    assert (self.callback), self.name + " does not support callback"
+        self.params.append(Property(param['name'], param, False))
 
 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)
   - |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

[not at google - send to devlin, 2012/02/24 03:53:05]

add |serializable|

[calamity, 2012/02/24 15:10:40]

Done.

   """
-  def __init__(self, name, json):
-    if not re.match('^[a-z][a-zA-Z0-9]*$', name):
-      raise AssertionError('Name %s must be lowerCamelCase' % name)

[not at google - send to devlin, 2012/02/24 03:53:05]

is it worthwhile having a warning here? are there any problems if it isn't camel
case?

[calamity, 2012/02/24 15:10:40]

Minimal, at worst, names might be dodgy (possibly dodgy enough to not compile).

+  def __init__(self, name, json, serializable_objects):

[not at google - send to devlin, 2012/02/24 03:53:05]

this name makes it sound like an array or something. what is it, a flag that
says whether the objects are serializable? why would that matter to Property?

[Yoyo Zhou, 2012/02/24 04:02:22]

objects_serializable would be a clearer name, I think.

     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')
     if '$ref' in json:
       self.ref_type = json['$ref']
       self.type_ = PropertyType.REF
     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(name + "Element", json['items'])
+        self.item_type = Property(name + "Element", json['items'], False)
         self.type_ = PropertyType.ARRAY
       elif json_type == 'object':
         self.properties = {}
         self.type_ = PropertyType.OBJECT
+        self.serializable = serializable_objects

[Yoyo Zhou, 2012/02/24 04:02:22]

self.type_.serializable?

[calamity, 2012/02/24 15:10:40]

Now that I've switched this to to_api/from_api, they're probably more describing
the object itself than self.type_ which is the PropertyType.

         for key, val in json['properties'].items():
-          self.properties[key] = Property(key, val)
+          self.properties[key] = Property(key, val, serializable_objects)
       else:
         raise NotImplementedError(json_type)
     elif 'choices' in json:
       assert len(json['choices']), 'Choices has no choices\n%s' % json
       self.choices = {}
       self.type_ = PropertyType.CHOICES
       for choice_json in json['choices']:
-        choice = Property(self.name, choice_json)
+        choice = Property(self.name, choice_json, serializable_objects)
         # 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 NotImplementedError(json)
 
   def GetUnixName(self):
@@ skipping 48 matching lines @@
   CHOICES = _Info(False, "CHOICES")
   OBJECT = _Info(False, "OBJECT")
   ANY = _Info(False, "ANY")
 
 def _UnixName(name):
   """Returns the unix_style name for a given lowerCamelCase string.
   """
   return '_'.join([x.lower()
       for x in re.findall('[A-Z][a-z_]*', name[0].upper() + name[1:])])