Support JSON Schema properties with values in the JSON Schema Compiler.

tools/json_schema_compiler/idl_schema.py

 #! /usr/bin/env python
 # 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 itertools
 import json
 import os.path
+import pprint
 import re
 import sys
 
 from json_parse import OrderedDict
 
 # This file is a peer to json_schema.py. Each of these files understands a
 # certain format describing APIs (either JSON or IDL), reads files written
 # in that format into memory, and emits them as a Python array of objects
 # corresponding to those APIs, where the objects are formatted in a way that
 # the JSON schema compiler understands. compiler.py drives both idl_schema.py
@@ skipping 141 matching lines @@
 
 class Member(object):
   '''
   Given an IDL dictionary or interface member, converts into a name/value pair
   where the value is a Python dictionary that the JSON schema compiler expects
   to see.
   '''
   def __init__(self, member_node):
     self.node = member_node
 
-  def process(self, callbacks):
+  def process(self, callbacks, functions_are_properties=False):
     properties = OrderedDict()
     name = self.node.GetName()
     if self.node.GetProperty('deprecated'):
       properties['deprecated'] = self.node.GetProperty('deprecated')
     if self.node.GetProperty('allowAmbiguousOptionalArguments'):
       properties['allowAmbiguousOptionalArguments'] = True
     for property_name in ('OPTIONAL', 'nodoc', 'nocompile', 'nodart'):
       if self.node.GetProperty(property_name):
         properties[property_name.lower()] = True
     for option_name, sanitizer in [
         ('maxListeners', int),
         ('supportsFilters', lambda s: s == 'true'),
         ('supportsListeners', lambda s: s == 'true'),
         ('supportsRules', lambda s: s == 'true')]:
       if self.node.GetProperty(option_name):
         if 'options' not in properties:
           properties['options'] = {}
         properties['options'][option_name] = sanitizer(self.node.GetProperty(
           option_name))
-    is_function = False
+    type_override = None
     parameter_comments = OrderedDict()
     for node in self.node.GetChildren():
       if node.cls == 'Comment':
         (parent_comment, parameter_comments) = ProcessComment(node.GetName())
         properties['description'] = parent_comment
       elif node.cls == 'Callspec':
-        is_function = True
         name, parameters, return_type = (Callspec(node, parameter_comments)
                                          .process(callbacks))
-        properties['parameters'] = parameters
-        if return_type is not None:
-          properties['returns'] = return_type
+        if functions_are_properties:
+          # If functions are treated as properties (which will happen if the
+          # interface is named Properties) then this isn't a function, it's a
+          # property which is encoded as a function with no arguments. The
+          # property type is the return type. This is an egregious hack in lieu
+          # of the IDL parser supporting 'const'.
+          assert parameters == [], (
+                 'Properties must be no-argument functions '
+                 'with a non-void return type')

[Devlin, 2015/04/01 22:46:19]

including "name" here would probably be helpful if this fails.

[not at google - send to devlin, 2015/04/01 23:44:00]

Done.

+          assert return_type is not None, (
+                 'Properties must be no-argument functions '
+                 'with a non-void return type')
+          assert 'type' in return_type, (
+                 'Return type "%s" from "%s" must specify a fundamental IDL '
+                 'type.' % (pprint.pformat(return_type), name))
+          type_override = return_type['type']
+        else:
+          type_override = 'function'
+          properties['parameters'] = parameters
+          if return_type is not None:
+            properties['returns'] = return_type
     properties['name'] = name
-    if is_function:
-      properties['type'] = 'function'
+    if type_override is not None:
+      properties['type'] = type_override
     else:
       properties = Typeref(self.node.GetProperty('TYPEREF'),
                            self.node, properties).process(callbacks)
+    value = self.node.GetProperty('value')
+    if value is not None:
+      # IDL always returns values as strings, so cast to their real type.
+      properties['value'] = self.cast_from_json_type(properties['type'], value)
     enum_values = self.node.GetProperty('legalValues')
     if enum_values:
-      if properties['type'] == 'integer':
-        enum_values = map(int, enum_values)
-      elif properties['type'] == 'double':
-        enum_values = map(float, enum_values)
-      properties['enum'] = enum_values
+      # IDL always returns enum values as strings, so cast to their real type.
+      properties['enum'] = [self.cast_from_json_type(properties['type'], enum)

[Devlin, 2015/04/01 22:46:19]

why not:
map(lambda e: self.cast_from_json_type(properties['type'], e), enum_values)?

[not at google - send to devlin, 2015/04/01 23:44:00]

List comprehensions are preferred over map for anything non-trivial:
https://google-styleguide.googlecode.com/svn/trunk/pyguide.html#Deprecated_La...

+                            for enum in enum_values]
     return name, properties
 
+  def cast_from_json_type(self, json_type, string_value):
+    '''Casts from string |string_value| to a real Python type based on a JSON
+    Schema type |json_type|. For example, a string value of '42' and a JSON
+    Schema type 'integer' will cast to int('42') ==> 42.
+    '''
+    if json_type == 'integer':
+      return int(string_value)
+    if json_type == 'number':
+      return float(string_value)
+    # Add more as necessary.
+    assert json_type == 'string', (
+           'No rule exists to cast JSON Schema type "%s" to its equivalent '
+           'Python type for value "%s". You must add a new rule here.' %
+           (json_type, string_value))
+    return string_value
+
 
 class Typeref(object):
   '''
   Given a TYPEREF property representing the type of dictionary member or
   function parameter, converts into a Python dictionary that the JSON schema
   compiler expects to see.
   '''
   def __init__(self, typeref, parent, additional_properties):
     self.typeref = typeref
     self.parent = parent
@@ skipping 117 matching lines @@
                compiler_options=None,
                deprecated=None,
                documentation_options=None):
     self.namespace = namespace_node
     self.nodoc = nodoc
     self.internal = internal
     self.platforms = platforms
     self.compiler_options = compiler_options
     self.events = []
     self.functions = []
+    self.properties = OrderedDict()
     self.types = []
     self.callbacks = OrderedDict()
     self.description = description
     self.deprecated = deprecated
     self.documentation_options = documentation_options
 
   def process(self):
     for node in self.namespace.GetChildren():
       if node.cls == 'Dictionary':
         self.types.append(Dictionary(node).process(self.callbacks))
       elif node.cls == 'Callback':
         k, v = Member(node).process(self.callbacks)
         self.callbacks[k] = v
       elif node.cls == 'Interface' and node.GetName() == 'Functions':
         self.functions = self.process_interface(node)
       elif node.cls == 'Interface' and node.GetName() == 'Events':
         self.events = self.process_interface(node)
+      elif node.cls == 'Interface' and node.GetName() == 'Properties':
+        # Properties are given as key-value pairs, but IDL will parse
+        # it as a list. Convert back to key-value pairs.

[Devlin, 2015/04/01 22:46:19]

Nit: put this comment two lines lower (above where you do the conversion).

[not at google - send to devlin, 2015/04/01 23:44:00]

you could argue it either way (the reason why it's called "properties_as_list"
is because the return type is a list) but sure.

+        properties_as_list = self.process_interface(
+            node, functions_are_properties=True)
+        for prop in properties_as_list:

[Devlin, 2015/04/01 22:46:19]

Would this be crazy?
map(lambda p: self.properties[p.pop('name')] = p, properties_as_list)

[not at google - send to devlin, 2015/04/01 23:44:00]

Yes, that would be crazy, however - good point, I can inline the
prop.pop('name').

+          name = prop.pop('name')
+          self.properties[name] = prop

[Red Daly, 2015/04/01 23:12:54]

Does the IDL parser ensure there are no duplicate names?

[not at google - send to devlin, 2015/04/01 23:44:00]

Good question - and I just tested, and it doesn't. The effect here would be to
only take the last declaration. We could add validation, which might help in
rare cases, though we don't validate other places this would also be a problem
(e.g. duplicate function names - less of an issue because they're tuples in a
list, I suppose).

[Devlin, 2015/04/01 23:53:12]

Enh, why not assert that we don't.  Doesn't hurt.

[not at google - send to devlin, 2015/04/02 00:10:33]

Done.

       elif node.cls == 'Enum':
         self.types.append(Enum(node).process())
       else:
         sys.exit('Did not process %s %s' % (node.cls, node))
     compiler_options = self.compiler_options or {}
     documentation_options = self.documentation_options or {}
     return {'namespace': self.namespace.GetName(),
             'description': self.description,
             'nodoc': self.nodoc,
             'types': self.types,
             'functions': self.functions,
+            'properties': self.properties,
             'internal': self.internal,
             'events': self.events,
             'platforms': self.platforms,
             'compiler_options': compiler_options,
             'deprecated': self.deprecated,
             'documentation_options': documentation_options}
 
-  def process_interface(self, node):
+  def process_interface(self, node, functions_are_properties=False):
     members = []
     for member in node.GetChildren():
       if member.cls == 'Member':
-        _, properties = Member(member).process(self.callbacks)
+        _, properties = Member(member).process(
+            self.callbacks,
+            functions_are_properties=functions_are_properties)
         members.append(properties)
     return members
 
 
 class IDLSchema(object):
   '''
   Given a list of IDLNodes and IDLAttributes, converts into a Python list
   of api_defs that the JSON schema compiler expects to see.
   '''
 
@@ skipping 92 matching lines @@
       print json.dumps(schema, indent=2)
   else:
     contents = sys.stdin.read()
     idl = idl_parser.IDLParser().ParseData(contents, '<stdin>')
     schema = IDLSchema(idl).process()
     print json.dumps(schema, indent=2)
 
 
 if __name__ == '__main__':
   Main()