Fixing json compiler preview.

tools/json_schema_compiler/preview.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.
 """Server for viewing the compiled C++ code from tools/json_schema_compiler.
 """
 
 import cc_generator
 import code
 import cpp_type_generator
 import cpp_util
 import h_generator
 import idl_schema
 import json_schema
 import model
 import optparse
 import os
-import schema_loader
+import shlex
 import urlparse
 from highlighters import (
     pygments_highlighter, none_highlighter, hilite_me_highlighter)
 from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
+from cpp_namespace_environment import CppNamespaceEnvironment
+from schema_loader import SchemaLoader
 
 
 class CompilerHandler(BaseHTTPRequestHandler):
   """A HTTPRequestHandler that outputs the result of tools/json_schema_compiler.
   """
   def do_GET(self):
     parsed_url = urlparse.urlparse(self.path)
     request_path = self._GetRequestPath(parsed_url)
 
     chromium_favicon = 'http://codereview.chromium.org/static/favicon.ico'
@@ skipping 135 matching lines @@
   var cachedValue = localStorage[highlighterStyle.id + 'Value'];
   if (cachedValue)
     highlighterStyle.value = cachedValue;
 });
 })();
 
 window.addEventListener('hashchange', updateEverything, false);
 updateEverything();
 </script>''')
 
-  def _LoadModel(self, basedir, name):
-    """Loads and returns the model for the |name| API from either its JSON or
-    IDL file, e.g.
-        name=contextMenus will be loaded from |basedir|/context_menus.json,
-        name=alarms will be loaded from |basedir|/alarms.idl.
-    """
-    loaders = {
-      'json': json_schema.Load,
-      'idl': idl_schema.Load
-    }
-    # APIs are referred to like "webRequest" but that's in a file
-    # "web_request.json" so we need to unixify the name.
-    unix_name = model.UnixName(name)
-    for loader_ext, loader_fn in loaders.items():
-      file_path = '%s/%s.%s' % (basedir, unix_name, loader_ext)
-      if os.path.exists(file_path):
-        # For historical reasons these files contain a singleton list with the
-        # model, so just return that single object.
-        return (loader_fn(file_path)[0], file_path)
-    raise ValueError('File for model "%s" not found' % name)
-
   def _ShowCompiledFile(self, parsed_url, head, body):
     """Show the compiled version of a json or idl file given the path to the
     compiled file.
     """
     api_model = model.Model()
 
     request_path = self._GetRequestPath(parsed_url)
     (file_root, file_ext) = os.path.splitext(request_path)
     (filedir, filename) = os.path.split(file_root)
 
+    schema_loader = SchemaLoader(filedir,
+                                 filedir,
+                                 self.server.include_rules,
+                                 '')
     try:
       # Get main file.
-      (api_def, file_path) = self._LoadModel(filedir, filename)
-      namespace = api_model.AddNamespace(api_def, file_path)
+      namespace = schema_loader.ResolveNamespace(filename)
       type_generator = cpp_type_generator.CppTypeGenerator(
            api_model,
-           schema_loader.SchemaLoader(filedir),
+           schema_loader,
            namespace)
 
       # Get the model's dependencies.
-      for dependency in api_def.get('dependencies', []):
+      for dependency in namespace.dependencies:
         # Dependencies can contain : in which case they don't refer to APIs,
         # rather, permissions or manifest keys.
         if ':' in dependency:
           continue
         (api_def, file_path) = self._LoadModel(filedir, dependency)
         referenced_namespace = api_model.AddNamespace(api_def, file_path)
         if referenced_namespace:
           type_generator.AddNamespace(referenced_namespace,
               cpp_util.Classname(referenced_namespace.name).lower())
 
       # Generate code
       cpp_namespace = 'generated_api_schemas'
       if file_ext == '.h':
-        cpp_code = (h_generator.HGenerator(type_generator, cpp_namespace)
+        cpp_code = (h_generator.HGenerator(type_generator)
             .Generate(namespace).Render())
       elif file_ext == '.cc':
-        cpp_code = (cc_generator.CCGenerator(type_generator, cpp_namespace)
+        cpp_code = (cc_generator.CCGenerator(type_generator)
             .Generate(namespace).Render())
       else:
         self.send_error(404, "File not found: %s" % request_path)
         return
 
       # Do highlighting on the generated code
       (highlighter_param, style_param) = self._GetHighlighterParams(parsed_url)
       head.Append('<style>' +
           self.server.highlighters[highlighter_param].GetCSS(style_param) +
           '</style>')
       body.Append(self.server.highlighters[highlighter_param]
           .GetCodeElement(cpp_code, style_param))
     except IOError:
       self.send_error(404, "File not found: %s" % request_path)
+      raise
       return

[not at google - send to devlin, 2014/08/28 19:22:09]

No point returning after a raise - but I prefer the old behaviour anyway. I
think it was because showing a stack trace is quite user unfriendly.

[lfg, 2014/08/28 19:33:35]

Oops, that was left over after I debugged this code. Removed.

     except (TypeError, KeyError, AttributeError,
         AssertionError, NotImplementedError) as error:
       body.Append('<pre>')
       body.Append('compiler error: %s' % error)
       body.Append('Check server log for more details')
       body.Append('</pre>')
       raise
 
   def _GetHighlighterParams(self, parsed_url):
     """Get the highlighting parameters from a parsed url.
@@ skipping 58 matching lines @@
         # cc/h panes will automatically update via the hash change event.
         html.Append('<li><a href="#%s">%s</a>' %
             (filename, filename))
 
     html.Append('</ul>')
 
     return html.Render()
 
 
 class PreviewHTTPServer(HTTPServer, object):
-  def __init__(self, server_address, handler, highlighters):
+  def __init__(self, server_address, handler, highlighters, include_rules):
     super(PreviewHTTPServer, self).__init__(server_address, handler)
     self.highlighters = highlighters
+    self.include_rules = include_rules
 
 
 if __name__ == '__main__':
   parser = optparse.OptionParser(
       description='Runs a server to preview the json_schema_compiler output.',
       usage='usage: %prog [option]...')
   parser.add_option('-p', '--port', default='8000',
       help='port to run the server on')
+  parser.add_option('-I', '--include-rules',
+      help='A list of paths to include when searching for referenced objects,'
+      ' with the namespace separated by a \':\'. Example: '
+      '/foo/bar:Foo::Bar::%(namespace)s')
 
   (opts, argv) = parser.parse_args()
 
+  def split_path_and_namespace(path_and_namespace):
+    if ':' not in path_and_namespace:
+      raise ValueError('Invalid include rule "%s". Rules must be of '
+                       'the form path:namespace' % path_and_namespace)
+    return path_and_namespace.split(':', 1)
+
+  include_rules = []
+  if opts.include_rules:
+    include_rules = map(split_path_and_namespace,
+                        shlex.split(opts.include_rules))
+
   try:
     print('Starting previewserver on port %s' % opts.port)
     print('The extension documentation can be found at:')
     print('')
     print('  http://localhost:%s/chrome/common/extensions/api' % opts.port)
     print('')
 
     highlighters = {
       'hilite': hilite_me_highlighter.HiliteMeHighlighter(),
       'none': none_highlighter.NoneHighlighter()
     }
     try:
       highlighters['pygments'] = pygments_highlighter.PygmentsHighlighter()
     except ImportError as e:
       pass
 
     server = PreviewHTTPServer(('', int(opts.port)),
                                CompilerHandler,
-                               highlighters)
+                               highlighters,
+                               include_rules)
     server.serve_forever()
   except KeyboardInterrupt:
     server.socket.close()