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
+  - |from_api| indicates that the type is coming from the API caller
+  - |to_api| indicates that the type is going to the API caller

[not at google - send to devlin, 2012/02/26 23:51:53]

This makes a lot more sense. I think it could still do with some improvements
documentation-wise.

Firstly the use of "api" is confusing because it can refer to either side (in
the c++ case, either Value or the compiled code). I was surprised reading
from_api and to_api uses and it seeming to be mixed up -- but I was thinking of
"api" as the "code generated to deal with the API".

A concept that will be common to all generators it the fact that they're
generating code, so perhaps we can use that as part of the documentation. So, we
could have |to_generator| and |from_generator| or similar? Like

|from_user| 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 Type can originate from the JSON (as
described by the schema), such as top-level types and function parameters.

WDYT? Does that make sense to you as well as me?

[not at google - send to devlin, 2012/02/26 23:53:34]

Heh, fail, changed my mind right after writing that.

[calamity, 2012/02/27 04:57:30]

Done. Changed to from_user/from_json

   """
   def __init__(self, json):
     self.name = json['id']
     self.description = json.get('description')
+    self.from_api = True
+    self.to_api = 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,
+          from_api=True,
+          to_api=True)
 
 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,
+          to_api=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,
+            from_api=True))
 
 class Property(object):
   """A property of a type OR a parameter to a function.
 
+  Parameters:
+  from_api: indicates whether the property is coming from the API caller
+  to_api: indicates whether the property will to go to the API caller
+
   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
   """
-  def __init__(self, name, json):
-    if not re.match('^[a-z][a-zA-Z0-9]*$', name):
-      raise AssertionError('Name %s must be lowerCamelCase' % name)
+  def __init__(self, name, json,
+      from_api=False,

[Yoyo Zhou, 2012/02/24 23:39:47]

Unless I'm reading something incorrectly, it looks like from_api/to_api are only
ever read from Type (and never set to anything but True), and they're only ever
set on Property (and never read).

[calamity, 2012/02/27 04:57:30]

The Property is used as a Type if it is an OBJECT. It's passed into GenerateType
in the generators. Commented.

+      to_api=False):
     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'],
+            from_api,
+            to_api)
         self.type_ = PropertyType.ARRAY
       elif json_type == 'object':
         self.properties = {}
         self.type_ = PropertyType.OBJECT
+        self.from_api = from_api
+        self.to_api = to_api
         for key, val in json['properties'].items():
-          self.properties[key] = Property(key, val)
+          self.properties[key] = Property(key, val,
+              from_api,
+              to_api)
       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,
+            from_api,
+            to_api)
         # 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:])])