IDL schema compiler: Fixed pseudo-random order

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 re
 import sys
 
 import schema_util
 
+try:
+  from collections import OrderedDict
+except ImportError:
+  # Failed to import, so we're running Python < 2.7. Use OrderedDict from
+  # simplejson.
+  import simplejson
+  from simplejson import OrderedDict

[not at google - send to devlin, 2013/01/14 15:26:25]

hm, we already have logic which does this in json_parse.py. You should use that
(see model.py).

[Matt Giuca, 2013/01/17 05:30:53]

Done.

+
 # 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
 # and json_schema.py.
 
 # idl_parser expects to be able to import certain files in its directory,
 # so let's set things up the way it wants.
 _idl_generators_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),
@@ skipping 39 matching lines @@
   first_parameter_location = (parameter_starts[0].start()
                               if parameter_starts else len(comment))
   parent_comment = comment[:first_parameter_location]
 
   # We replace \n\n with <br/><br/> here and below, because the documentation
   # needs to know where the newlines should be, and this is easier than
   # escaping \n.
   parent_comment = (parent_comment.strip().replace('\n\n', '<br/><br/>')
                                           .replace('\n', ''))
 
-  params = {}
+  params = OrderedDict()
   for (cur_param, next_param) in itertools.izip_longest(parameter_starts,
                                                         parameter_starts[1:]):
     param_name = cur_param.group(1)
 
     # A parameter's comment goes from the end of its introduction to the
     # beginning of the next parameter's introduction.
     param_comment_start = cur_param.end()
     param_comment_end = next_param.start() if next_param else len(comment)
     params[param_name] = (comment[param_comment_start:param_comment_end
                                   ].strip().replace('\n\n', '<br/><br/>')
@@ skipping 33 matching lines @@
 
 class Dictionary(object):
   '''
   Given an IDL Dictionary node, converts into a Python dictionary that the JSON
   schema compiler expects to see.
   '''
   def __init__(self, dictionary_node):
     self.node = dictionary_node
 
   def process(self, callbacks):
-    properties = {}
+    properties = OrderedDict()
     for node in self.node.children:
       if node.cls == 'Member':
         k, v = Member(node).process(callbacks)
         properties[k] = v
     result = {'id': self.node.GetName(),
               'properties': properties,
               'type': 'object'}
     if self.node.GetProperty('inline_doc'):
       result['inline_doc'] = True
     return result
 
 
 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):
-    properties = {}
+    properties = OrderedDict()
     name = self.node.GetName()
     for property_name in ('OPTIONAL', 'nodoc', 'nocompile'):
       if self.node.GetProperty(property_name):
         properties[property_name.lower()] = True
     is_function = False
-    parameter_comments = {}
+    parameter_comments = OrderedDict()
     for node in self.node.children:
       if node.cls == 'Comment':
         (parent_comment, parameter_comments) = ProcessComment(node.GetName())
         properties['description'] = parent_comment
       elif node.cls == 'Callspec':
         is_function = True
         name, parameters = Callspec(node, parameter_comments).process(callbacks)
         properties['parameters'] = parameters
     properties['name'] = name
     if is_function:
       properties['type'] = 'function'
     else:
       properties = Typeref(self.node.GetProperty('TYPEREF'),
                            self.node, properties).process(callbacks)
     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
     return name, properties
 
 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={}):
+  def __init__(self, typeref, parent, additional_properties=OrderedDict()):
     self.typeref = typeref
     self.parent = parent
     self.additional_properties = additional_properties
 
   def process(self, callbacks):
     properties = self.additional_properties
     result = properties
 
     if self.parent.GetProperty('OPTIONAL', False):
       properties['optional'] = True
 
     # The IDL parser denotes array types by adding a child 'Array' node onto
     # the Param node in the Callspec.
     for sibling in self.parent.GetChildren():
       if sibling.cls == 'Array' and sibling.GetName() == self.parent.GetName():
         properties['type'] = 'array'
-        properties['items'] = {}
+        properties['items'] = OrderedDict()
         properties = properties['items']
         break
 
     if self.typeref == 'DOMString':
       properties['type'] = 'string'
     elif self.typeref == 'boolean':
       properties['type'] = 'boolean'
     elif self.typeref == 'double':
       properties['type'] = 'number'
     elif self.typeref == 'long':
       properties['type'] = 'integer'
     elif self.typeref == 'any':
       properties['type'] = 'any'
     elif self.typeref == 'object':
       properties['type'] = 'object'
       if 'additionalProperties' not in properties:
-        properties['additionalProperties'] = {}
+        properties['additionalProperties'] = OrderedDict()
       properties['additionalProperties']['type'] = 'any'
       instance_of = self.parent.GetProperty('instanceOf')
       if instance_of:
         properties['isInstanceOf'] = instance_of
     elif self.typeref == 'ArrayBuffer':
       properties['type'] = 'binary'
       properties['isInstanceOf'] = 'ArrayBuffer'
     elif self.typeref is None:
       properties['type'] = 'function'
     else:
@@ skipping 45 matching lines @@
   '''
 
   def __init__(self, namespace_node, nodoc=False, permissions=None,
                internal=False):
     self.namespace = namespace_node
     self.nodoc = nodoc
     self.internal = internal
     self.events = []
     self.functions = []
     self.types = []
-    self.callbacks = {}
+    self.callbacks = OrderedDict()
     self.permissions = permissions or []
 
   def process(self):
     for node in self.namespace.children:
       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':
@@ skipping 76 matching lines @@
   '''
   Dump a json serialization of parse result for the IDL files whose names
   were passed in on the command line.
   '''
   for filename in sys.argv[1:]:
     schema = Load(filename)
     print json.dumps(schema, indent=2)
 
 if __name__ == '__main__':
   Main()