Added JSON schema compiler support for serialized 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 ParseException(Exception):
   """Thrown when data in the model is invalid.
@@ skipping 132 matching lines @@
 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
+  - |compiled_type| the model.PropertyType that this property should be
+    compiled to from the JSON. Defaults to type_.
   - |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
   - |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, is_additional_properties=False,
       from_json=False, from_client=False):
     self.name = name
     self._unix_name = UnixName(self.name)
     self._unix_name_used = False
     self.optional = json.get('optional', False)
     self.functions = {}
     self.has_value = False
     self.description = json.get('description')
     self.parent = parent
     self.from_json = from_json
     self.from_client = from_client
     self.instance_of = json.get('isInstanceOf', None)
     _AddProperties(self, json)
     if is_additional_properties:
       self.type_ = PropertyType.ADDITIONAL_PROPERTIES
+      self.compiled_type = self.type_

[not at google - send to devlin, 2012/07/31 06:37:41]

a lot of repetitive assigning to compiled_type. Could be the source of subtle
bugs in the future? Certainly it could be more concise, by doing that "if
'compiled_type' in json" check after all this if/elif stuff.

[mitchellwrosen, 2012/07/31 17:50:25]

Okay. I was originally thinking that a compiled_type is only valid if there's a
type as well. Should I put a check to see that 'type' is in the json if
'compiled_type' is as well, and throw a ParseException?

     elif '$ref' in json:
       self.ref_type = json['$ref']
       self.type_ = PropertyType.REF
+      self.compiled_type = self.type_
     elif 'enum' in json and json.get('type') == 'string':
       # Non-string enums (as in the case of [legalValues=(1,2)]) should fall
       # through to the next elif.
       self.enum_values = []
       for value in json['enum']:
         self.enum_values.append(value)
       self.type_ = PropertyType.ENUM
+      self.compiled_type = self.type_
     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.type_ = self._JsonTypeToPropertyType(json['type'])
+      if self.type_ == PropertyType.ARRAY:
         self.item_type = Property(self, name + "Element", json['items'],
             from_json=from_json,
             from_client=from_client)
-        self.type_ = PropertyType.ARRAY
-      elif json_type == 'object':
-        self.type_ = PropertyType.OBJECT
+      elif self.type_ == PropertyType.OBJECT:
         # These members are read when this OBJECT Property is used as a Type
         type_ = Type(self, self.name, json)
         # self.properties will already have some value from |_AddProperties|.
         self.properties.update(type_.properties)
         self.functions = type_.functions
-      elif json_type == 'function':
-        self.type_ = PropertyType.FUNCTION
-      elif json_type == 'binary':
-        self.type_ = PropertyType.BINARY
+      if 'compiled_type' in json:
+        self.compiled_type = self._JsonTypeToPropertyType(json['compiled_type'])
       else:
-        raise ParseException(self, 'type ' + json_type + ' not recognized')
+        self.compiled_type = self.type_
     elif 'choices' in json:
       if not json['choices'] or len(json['choices']) == 0:
         raise ParseException(self, 'Choices has no choices')
       self.choices = {}
       self.type_ = PropertyType.CHOICES
+      self.compiled_type = self.type_
       for choice_json in json['choices']:
         choice = Property(self, self.name, choice_json,
             from_json=from_json,
             from_client=from_client)
         choice.unix_name = UnixName(self.name + choice.type_.name)
         # The existence of any single choice is optional
         choice.optional = True
         self.choices[choice.type_] = choice
     elif 'value' in json:
       self.has_value = True
       self.value = json['value']
       if type(self.value) == int:
         self.type_ = PropertyType.INTEGER
+        self.compiled_type = self.type_
       else:
         # TODO(kalman): support more types as necessary.
         raise ParseException(
             self, '"%s" is not a supported type' % type(self.value))
     else:
       raise ParseException(
           self, 'Property has no type, $ref, choices, or value')
 
+  def _JsonTypeToPropertyType(self, json_type):
+    if json_type == 'any':
+      return PropertyType.ANY
+    if json_type == 'array':
+      return PropertyType.ARRAY
+    if json_type == 'binary':
+       return PropertyType.BINARY
+    if json_type == 'boolean':
+      return PropertyType.BOOLEAN
+    if json_type == 'integer':
+      return PropertyType.INTEGER
+    if json_type == 'int64':
+      return PropertyType.INT_64
+    if json_type == 'function':
+       return PropertyType.FUNCTION
+    if json_type == 'number':
+      return PropertyType.DOUBLE
+    if json_type == 'object':
+      return PropertyType.OBJECT
+    if json_type == 'string':
+      return PropertyType.STRING
+    raise NotImplementedError('Type %s not recognized' % json_type)

[not at google - send to devlin, 2012/07/31 06:37:41]

you could do the old

try:
  return {
    'any': PropertyType.ANY,
    ...
  }[json_type]
except KeyError:
  raise NotImplementedError(..)

thing, right?

[mitchellwrosen, 2012/07/31 17:50:25]

Yes. My never-written-python-before-in-my-life is showing =(

+
   def GetUnixName(self):
     """Gets the property's unix_name. Raises AttributeError if not set.
     """
     if not self._unix_name:
       raise AttributeError('No unix_name set on %s' % self.name)
     self._unix_name_used = True
     return self._unix_name
 
   def SetUnixName(self, unix_name):
     """Set the property's unix_name. Raises AttributeError if the unix_name has
@@ skipping 23 matching lines @@
   """
   class _Info(object):
     def __init__(self, is_fundamental, name):
       self.is_fundamental = is_fundamental
       self.name = name
 
     def __repr__(self):
       return self.name
 
   INTEGER = _Info(True, "INTEGER")
+  INT_64 = _Info(True, "INT_64")

[not at google - send to devlin, 2012/07/31 06:37:41]

the c++ type is int64 not int_64 so this should be INT64.

[mitchellwrosen, 2012/07/31 17:50:25]

Sure, I actually changed it from INT64 to INT_64 because of an earlier comment
of yours. A typo I'm sure =)

   DOUBLE = _Info(True, "DOUBLE")
   BOOLEAN = _Info(True, "BOOLEAN")
   STRING = _Info(True, "STRING")
   ENUM = _Info(False, "ENUM")
   ARRAY = _Info(False, "ARRAY")
   REF = _Info(False, "REF")
   CHOICES = _Info(False, "CHOICES")
   OBJECT = _Info(False, "OBJECT")
   FUNCTION = _Info(False, "FUNCTION")
   BINARY = _Info(False, "BINARY")
@@ skipping 52 matching lines @@
   of |json|.
   """
   model.properties = {}
   for name, property_json in json.get('properties', {}).items():
     model.properties[name] = Property(
         model,
         name,
         property_json,
         from_json=from_json,
         from_client=from_client)