Allow comments in extension config files.

tools/json_schema_compiler/compiler.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.
 """Generator for C++ structs from api json files.
 
 The purpose of this tool is to remove the need for hand-written code that
 converts to and from base::Value types when receiving javascript api calls.
 Originally written for generating code for extension apis. Reference schemas
 are in chrome/common/extensions/api.
 
 Usage example:
   compiler.py --root /home/Work/src --namespace extensions windows.json
     tabs.json
   compiler.py --destdir gen --root /home/Work/src
     --namespace extensions windows.json tabs.json
 """
 
 import cc_generator
 import cpp_type_generator
 import h_generator
 import json
 import model
 import optparse
 import os.path
 import sys
 
+# We need to get json_minify from the third_party directory.
+# This is similar to what is done in chrome/common/extensions/docs/build.py
+third_party_path = os.path.dirname(os.path.realpath(__file__)) + \
+                                   '/../../third_party/'

[not at google - send to devlin, 2012/03/02 02:15:08]

Won't this cause problems on Windows? os.path.join.

also you may need to use os.pardir instead of '..'

+if third_party_path not in sys.path:
+  sys.path.insert(0, third_party_path)
+import json_minify as minify
+
 if __name__ == '__main__':
   parser = optparse.OptionParser(
       description='Generates a C++ model of an API from JSON schema',
       usage='usage: %prog [option]... schema')
   parser.add_option('-r', '--root', default='.',
       help='logical include root directory. Path to schema files from specified'
       'dir will be the include path.')
   parser.add_option('-d', '--destdir',
       help='root directory to output generated files.')
   parser.add_option('-n', '--namespace', default='generated_api_schemas',
       help='C++ namespace for generated files. e.g extensions::api.')
 
   (opts, args) = parser.parse_args()
   if not args:
     sys.exit(parser.get_usage())
   dest_dir = opts.destdir
   root_namespace = opts.namespace
 
   schema = os.path.normpath(args[0])
 
   api_model = model.Model()
 
 
   # Actually generate for source file.
   with open(schema, 'r') as schema_file:
-    api_defs = json.loads(schema_file.read())
+    api_defs = json.loads(minify.json_minify(schema_file.read()))
 
   for target_namespace in api_defs:
     referenced_schemas = target_namespace.get('dependencies', [])
     # Load type dependencies into the model.
     for referenced_schema in referenced_schemas:
       referenced_schema_path = os.path.join(
           os.path.dirname(schema), referenced_schema + '.json')
       with open(referenced_schema_path, 'r') as referenced_schema_file:
-        referenced_api_defs = json.loads(referenced_schema_file.read())
+        referenced_api_defs = json.loads(minify.json_minify(
+                                           referenced_schema_file.read()))
 
       for namespace in referenced_api_defs:
         api_model.AddNamespace(namespace,
             os.path.relpath(referenced_schema_path, opts.root))
 
     # Gets the relative path from opts.root to the schema to correctly determine
     # the include path.
     relpath = os.path.relpath(schema, opts.root)
     namespace = api_model.AddNamespace(target_namespace, relpath)
     if not namespace:
@@ skipping 24 matching lines @@
           'w') as h_file:
         h_file.write(h_code)
     else:
       print '%s.h' % out_file
       print
       print h_code
       print
       print '%s.cc' % out_file
       print
       print cc_code