Clean up 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 re
 import sys
 
 from json_parse import OrderedDict
-import schema_util
 
 # 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.
@@ skipping 54 matching lines @@
 
     # 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/>')
                                            .replace('\n', ''))
   return (parent_comment, params)
 
+
 class Callspec(object):
   '''
   Given a Callspec node representing an IDL function declaration, converts into
   a tuple:
       (name, list of function parameters, return type)
   '''
   def __init__(self, callspec_node, comment):
     self.node = callspec_node
     self.comment = comment
 
   def process(self, callbacks):
     parameters = []
     return_type = None
     if self.node.GetProperty('TYPEREF') not in ('void', None):
       return_type = Typeref(self.node.GetProperty('TYPEREF'),
                             self.node,
                             {'name': self.node.GetName()}).process(callbacks)
       # The IDL parser doesn't allow specifying return types as optional.
       # Instead we infer any object return values to be optional.
       # TODO(asargent): fix the IDL parser to support optional return types.
       if return_type.get('type') == 'object' or '$ref' in return_type:
-        return_type['optional'] = True;
+        return_type['optional'] = True
     for node in self.node.children:
       parameter = Param(node).process(callbacks)
       if parameter['name'] in self.comment:
         parameter['description'] = self.comment[parameter['name']]
       parameters.append(parameter)
     return (self.node.GetName(), parameters, return_type)
 
+
 class Param(object):
   '''
   Given a Param node representing a function parameter, converts into a Python
   dictionary that the JSON schema compiler expects to see.
   '''
   def __init__(self, param_node):
     self.node = param_node
 
   def process(self, callbacks):
     return Typeref(self.node.GetProperty('TYPEREF'),
                    self.node,
                    {'name': self.node.GetName()}).process(callbacks)
 
+
 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 = 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
     elif self.node.GetProperty('noinline_doc'):
       result['noinline_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):
@@ skipping 33 matching lines @@
                            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=OrderedDict()):
     self.typeref = typeref
     self.parent = parent
     self.additional_properties = additional_properties
@@ skipping 126 matching lines @@
             'events': self.events}
 
   def process_interface(self, node):
     members = []
     for member in node.children:
       if member.cls == 'Member':
         name, properties = Member(member).process(self.callbacks)
         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.
   '''
 
   def __init__(self, idl):
     self.idl = idl
 
   def process(self):
@@ skipping 20 matching lines @@
         if node.name == 'nodoc':
           nodoc = bool(node.value)
         elif node.name == 'internal':
           internal = bool(node.value)
         else:
           continue
       else:
         sys.exit('Did not process %s %s' % (node.cls, node))
     return namespaces
 
+
 def Load(filename):
   '''
   Given the filename of an IDL file, parses it and returns an equivalent
   Python dictionary in a format that the JSON schema compiler expects to see.
   '''
 
   f = open(filename, 'r')
   contents = f.read()
   f.close()
 
   idl = idl_parser.IDLParser().ParseData(contents, filename)
   idl_schema = IDLSchema(idl)
   return idl_schema.process()
 
+
 def Main():
   '''
   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()