Add js_interface_generator for generating extensions interfaces

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 optparse
 import os
 import shlex
 import sys
 
 from cpp_bundle_generator import CppBundleGenerator
 from cpp_generator import CppGenerator
 from cpp_type_generator import CppTypeGenerator
 from js_externs_generator import JsExternsGenerator
+from js_interface_generator import JsInterfaceGenerator
 import json_schema
 from cpp_namespace_environment import CppNamespaceEnvironment
 from model import Model
 from schema_loader import SchemaLoader
 
 # Names of supported code generators, as specified on the command-line.
 # First is default.
-GENERATORS = ['cpp', 'cpp-bundle-registration', 'cpp-bundle-schema', 'externs']
+GENERATORS = [
+  'cpp', 'cpp-bundle-registration', 'cpp-bundle-schema', 'externs', 'interface'
+]
 
 def GenerateSchema(generator_name,
                    file_paths,
                    root,
                    destdir,
                    cpp_namespace_pattern,
                    bundle_name,
                    impl_dir,
                    include_rules):
   # Merge the source files into a single list of schemas.
@@ skipping 69 matching lines @@
   elif generator_name == 'cpp':
     cpp_generator = CppGenerator(type_generator)
     generators = [
       ('%s.h' % filename_base, cpp_generator.h_generator),
       ('%s.cc' % filename_base, cpp_generator.cc_generator)
     ]
   elif generator_name == 'externs':
     generators = [
       ('%s_externs.js' % namespace.unix_name, JsExternsGenerator())
     ]
+  elif generator_name == 'interface':
+    generators = [
+      ('%s_interface.js' % namespace.unix_name, JsInterfaceGenerator())
+    ]
   else:
     raise Exception('Unrecognised generator %s' % generator_name)
 
   output_code = []
   for filename, generator in generators:
     code = generator.Generate(namespace).Render()
     if destdir:
       if generator_name == 'cpp-bundle-registration':
         # Function registrations must be output to impl_dir, since they link in
         # API implementations.
         output_dir = os.path.join(destdir, impl_dir)
       else:
         output_dir = os.path.join(destdir, src_path)
       if not os.path.exists(output_dir):
         os.makedirs(output_dir)
       with open(os.path.join(output_dir, filename), 'w') as f:
         f.write(code)
-    output_code += [filename, '', code, '']
+    if len(generators) > 1:
+      output_code += [filename, '', code, '']

[michaelpg, 2015/12/04 21:02:19]

is this where the silly filename at the beginning of extern output comes from?
can we just... not?

[stevenjb, 2015/12/07 18:31:24]

It is. And this is correct: If we are writing a single file to std:out, we want
to skip the "sill" filename at the beginning. However if we generate, e.g., a
.cc and a .h to stdout then the filename separators are helpful.
Added a comment.

[michaelpg, 2015/12/07 18:46:53]

ah, I didn't realize that's what |generators| represented. Yay, thanks!
Does any *nix utility do this? it's wildly unexpected behavior and goes against
the "philosophy" of text-transforming tools IMO. Not a reason to change it now,
though.

[stevenjb, 2015/12/07 19:49:32]

So, I *think* that the intention is to specify an output directory and the
.cc/.h files will be placed there (see if destdir: above). I seem to recall
problems with specifying an output directory for the JS externs (or maybe
decided it was too much hassle?). Either way, this is at least an improvement to
the way we've been generating externs (and now interfaces) without affecting
existing behavior for other generators.

+    else:
+      output_code += [code]
 
   return '\n'.join(output_code)
 
 
 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'
@@ skipping 38 matching lines @@
   include_rules = []
   if opts.include_rules:
     include_rules = map(split_path_and_namespace,
                         shlex.split(opts.include_rules))
 
   result = GenerateSchema(opts.generator, file_paths, opts.root, opts.destdir,
                           opts.namespace, opts.bundle_name, opts.impl_dir,
                           include_rules)
   if not opts.destdir:
     print result