Home | History | Annotate | Download | only in json_schema_compiler 
      1 #!/usr/bin/env python
      2 
      3 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
      4 # Use of this source code is governed by a BSD-style license that can be
      5 # found in the LICENSE file.
      6 """Server for viewing the compiled C++ code from tools/json_schema_compiler.
      7 """
      8 
      9 import cc_generator
     10 import code
     11 import cpp_type_generator
     12 import cpp_util
     13 import h_generator
     14 import idl_schema
     15 import json_schema
     16 import model
     17 import optparse
     18 import os
     19 import schema_loader
     20 import urlparse
     21 from highlighters import (
     22     pygments_highlighter, none_highlighter, hilite_me_highlighter)
     23 from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
     24 
     25 
     26 class CompilerHandler(BaseHTTPRequestHandler):
     27   """A HTTPRequestHandler that outputs the result of tools/json_schema_compiler.
     28   """
     29   def do_GET(self):
     30     parsed_url = urlparse.urlparse(self.path)
     31     request_path = self._GetRequestPath(parsed_url)
     32 
     33     chromium_favicon = 'http://codereview.chromium.org/static/favicon.ico'
     34 
     35     head = code.Code()
     36     head.Append('<link rel="icon" href="%s">' % chromium_favicon)
     37     head.Append('<link rel="shortcut icon" href="%s">' % chromium_favicon)
     38 
     39     body = code.Code()
     40 
     41     try:
     42       if os.path.isdir(request_path):
     43         self._ShowPanels(parsed_url, head, body)
     44       else:
     45         self._ShowCompiledFile(parsed_url, head, body)
     46     finally:
     47       self.wfile.write('<html><head>')
     48       self.wfile.write(head.Render())
     49       self.wfile.write('</head><body>')
     50       self.wfile.write(body.Render())
     51       self.wfile.write('</body></html>')
     52 
     53   def _GetRequestPath(self, parsed_url, strip_nav=False):
     54     """Get the relative path from the current directory to the requested file.
     55     """
     56     path = parsed_url.path
     57     if strip_nav:
     58       path = parsed_url.path.replace('/nav', '')
     59     return os.path.normpath(os.curdir + path)
     60 
     61   def _ShowPanels(self, parsed_url, head, body):
     62     """Show the previewer frame structure.
     63 
     64     Code panes are populated via XHR after links in the nav pane are clicked.
     65     """
     66     (head.Append('<style>')
     67          .Append('body {')
     68          .Append('  margin: 0;')
     69          .Append('}')
     70          .Append('.pane {')
     71          .Append('  height: 100%;')
     72          .Append('  overflow-x: auto;')
     73          .Append('  overflow-y: scroll;')
     74          .Append('  display: inline-block;')
     75          .Append('}')
     76          .Append('#nav_pane {')
     77          .Append('  width: 20%;')
     78          .Append('}')
     79          .Append('#nav_pane ul {')
     80          .Append('  list-style-type: none;')
     81          .Append('  padding: 0 0 0 1em;')
     82          .Append('}')
     83          .Append('#cc_pane {')
     84          .Append('  width: 40%;')
     85          .Append('}')
     86          .Append('#h_pane {')
     87          .Append('  width: 40%;')
     88          .Append('}')
     89          .Append('</style>')
     90     )
     91 
     92     body.Append(
     93         '<div class="pane" id="nav_pane">%s</div>'
     94         '<div class="pane" id="h_pane"></div>'
     95         '<div class="pane" id="cc_pane"></div>' %
     96         self._RenderNavPane(parsed_url.path[1:])
     97     )
     98 
     99     # The Javascript that interacts with the nav pane and panes to show the
    100     # compiled files as the URL or highlighting options change.
    101     body.Append('''<script type="text/javascript">
    102 // Calls a function for each highlighter style <select> element.
    103 function forEachHighlighterStyle(callback) {
    104   var highlighterStyles =
    105       document.getElementsByClassName('highlighter_styles');
    106   for (var i = 0; i < highlighterStyles.length; ++i)
    107     callback(highlighterStyles[i]);
    108 }
    109 
    110 // Called when anything changes, such as the highlighter or hashtag.
    111 function updateEverything() {
    112   var highlighters = document.getElementById('highlighters');
    113   var highlighterName = highlighters.value;
    114 
    115   // Cache in localStorage for when the page loads next.
    116   localStorage.highlightersValue = highlighterName;
    117 
    118   // Show/hide the highlighter styles.
    119   var highlighterStyleName = '';
    120   forEachHighlighterStyle(function(highlighterStyle) {
    121     if (highlighterStyle.id === highlighterName + '_styles') {
    122       highlighterStyle.removeAttribute('style')
    123       highlighterStyleName = highlighterStyle.value;
    124     } else {
    125       highlighterStyle.setAttribute('style', 'display:none')
    126     }
    127 
    128     // Cache in localStorage for when the page next loads.
    129     localStorage[highlighterStyle.id + 'Value'] = highlighterStyle.value;
    130   });
    131 
    132   // Populate the code panes.
    133   function populateViaXHR(elementId, requestPath) {
    134     var xhr = new XMLHttpRequest();
    135     xhr.onreadystatechange = function() {
    136       if (xhr.readyState != 4)
    137         return;
    138       if (xhr.status != 200) {
    139         alert('XHR error to ' + requestPath);
    140         return;
    141       }
    142       document.getElementById(elementId).innerHTML = xhr.responseText;
    143     };
    144     xhr.open('GET', requestPath, true);
    145     xhr.send();
    146   }
    147 
    148   var targetName = window.location.hash;
    149   targetName = targetName.substring('#'.length);
    150   targetName = targetName.split('.', 1)[0]
    151 
    152   if (targetName !== '') {
    153     var basePath = window.location.pathname;
    154     var query = 'highlighter=' + highlighterName + '&' +
    155                 'style=' + highlighterStyleName;
    156     populateViaXHR('h_pane',  basePath + '/' + targetName + '.h?'  + query);
    157     populateViaXHR('cc_pane', basePath + '/' + targetName + '.cc?' + query);
    158   }
    159 }
    160 
    161 // Initial load: set the values of highlighter and highlighterStyles from
    162 // localStorage.
    163 (function() {
    164 var cachedValue = localStorage.highlightersValue;
    165 if (cachedValue)
    166   document.getElementById('highlighters').value = cachedValue;
    167 
    168 forEachHighlighterStyle(function(highlighterStyle) {
    169   var cachedValue = localStorage[highlighterStyle.id + 'Value'];
    170   if (cachedValue)
    171     highlighterStyle.value = cachedValue;
    172 });
    173 })();
    174 
    175 window.addEventListener('hashchange', updateEverything, false);
    176 updateEverything();
    177 </script>''')
    178 
    179   def _LoadModel(self, basedir, name):
    180     """Loads and returns the model for the |name| API from either its JSON or
    181     IDL file, e.g.
    182         name=contextMenus will be loaded from |basedir|/context_menus.json,
    183         name=alarms will be loaded from |basedir|/alarms.idl.
    184     """
    185     loaders = {
    186       'json': json_schema.Load,
    187       'idl': idl_schema.Load
    188     }
    189     # APIs are referred to like "webRequest" but that's in a file
    190     # "web_request.json" so we need to unixify the name.
    191     unix_name = model.UnixName(name)
    192     for loader_ext, loader_fn in loaders.items():
    193       file_path = '%s/%s.%s' % (basedir, unix_name, loader_ext)
    194       if os.path.exists(file_path):
    195         # For historical reasons these files contain a singleton list with the
    196         # model, so just return that single object.
    197         return (loader_fn(file_path)[0], file_path)
    198     raise ValueError('File for model "%s" not found' % name)
    199 
    200   def _ShowCompiledFile(self, parsed_url, head, body):
    201     """Show the compiled version of a json or idl file given the path to the
    202     compiled file.
    203     """
    204     api_model = model.Model()
    205 
    206     request_path = self._GetRequestPath(parsed_url)
    207     (file_root, file_ext) = os.path.splitext(request_path)
    208     (filedir, filename) = os.path.split(file_root)
    209 
    210     try:
    211       # Get main file.
    212       (api_def, file_path) = self._LoadModel(filedir, filename)
    213       namespace = api_model.AddNamespace(api_def, file_path)
    214       type_generator = cpp_type_generator.CppTypeGenerator(
    215            api_model,
    216            schema_loader.SchemaLoader(filedir),
    217            namespace)
    218 
    219       # Get the model's dependencies.
    220       for dependency in api_def.get('dependencies', []):
    221         # Dependencies can contain : in which case they don't refer to APIs,
    222         # rather, permissions or manifest keys.
    223         if ':' in dependency:
    224           continue
    225         (api_def, file_path) = self._LoadModel(filedir, dependency)
    226         referenced_namespace = api_model.AddNamespace(api_def, file_path)
    227         if referenced_namespace:
    228           type_generator.AddNamespace(referenced_namespace,
    229               cpp_util.Classname(referenced_namespace.name).lower())
    230 
    231       # Generate code
    232       cpp_namespace = 'generated_api_schemas'
    233       if file_ext == '.h':
    234         cpp_code = (h_generator.HGenerator(type_generator, cpp_namespace)
    235             .Generate(namespace).Render())
    236       elif file_ext == '.cc':
    237         cpp_code = (cc_generator.CCGenerator(type_generator, cpp_namespace)
    238             .Generate(namespace).Render())
    239       else:
    240         self.send_error(404, "File not found: %s" % request_path)
    241         return
    242 
    243       # Do highlighting on the generated code
    244       (highlighter_param, style_param) = self._GetHighlighterParams(parsed_url)
    245       head.Append('<style>' +
    246           self.server.highlighters[highlighter_param].GetCSS(style_param) +
    247           '</style>')
    248       body.Append(self.server.highlighters[highlighter_param]
    249           .GetCodeElement(cpp_code, style_param))
    250     except IOError:
    251       self.send_error(404, "File not found: %s" % request_path)
    252       return
    253     except (TypeError, KeyError, AttributeError,
    254         AssertionError, NotImplementedError) as error:
    255       body.Append('<pre>')
    256       body.Append('compiler error: %s' % error)
    257       body.Append('Check server log for more details')
    258       body.Append('</pre>')
    259       raise
    260 
    261   def _GetHighlighterParams(self, parsed_url):
    262     """Get the highlighting parameters from a parsed url.
    263     """
    264     query_dict = urlparse.parse_qs(parsed_url.query)
    265     return (query_dict.get('highlighter', ['pygments'])[0],
    266         query_dict.get('style', ['colorful'])[0])
    267 
    268   def _RenderNavPane(self, path):
    269     """Renders an HTML nav pane.
    270 
    271     This consists of a select element to set highlight style, and a list of all
    272     files at |path| with the appropriate onclick handlers to open either
    273     subdirectories or JSON files.
    274     """
    275     html = code.Code()
    276 
    277     # Highlighter chooser.
    278     html.Append('<select id="highlighters" onChange="updateEverything()">')
    279     for name, highlighter in self.server.highlighters.items():
    280       html.Append('<option value="%s">%s</option>' %
    281           (name, highlighter.DisplayName()))
    282     html.Append('</select>')
    283 
    284     html.Append('<br/>')
    285 
    286     # Style for each highlighter.
    287     # The correct highlighting will be shown by Javascript.
    288     for name, highlighter in self.server.highlighters.items():
    289       styles = sorted(highlighter.GetStyles())
    290       if not styles:
    291         continue
    292 
    293       html.Append('<select class="highlighter_styles" id="%s_styles" '
    294                   'onChange="updateEverything()">' % name)
    295       for style in styles:
    296         html.Append('<option>%s</option>' % style)
    297       html.Append('</select>')
    298 
    299     html.Append('<br/>')
    300 
    301     # The files, with appropriate handlers.
    302     html.Append('<ul>')
    303 
    304     # Make path point to a non-empty directory. This can happen if a URL like
    305     # http://localhost:8000 is navigated to.
    306     if path == '':
    307       path = os.curdir
    308 
    309     # Firstly, a .. link if this isn't the root.
    310     if not os.path.samefile(os.curdir, path):
    311       normpath = os.path.normpath(os.path.join(path, os.pardir))
    312       html.Append('<li><a href="/%s">%s/</a>' % (normpath, os.pardir))
    313 
    314     # Each file under path/
    315     for filename in sorted(os.listdir(path)):
    316       full_path = os.path.join(path, filename)
    317       (file_root, file_ext) = os.path.splitext(full_path)
    318       if os.path.isdir(full_path) and not full_path.endswith('.xcodeproj'):
    319         html.Append('<li><a href="/%s/">%s/</a>' % (full_path, filename))
    320       elif file_ext in ['.json', '.idl']:
    321         # cc/h panes will automatically update via the hash change event.
    322         html.Append('<li><a href="#%s">%s</a>' %
    323             (filename, filename))
    324 
    325     html.Append('</ul>')
    326 
    327     return html.Render()
    328 
    329 
    330 class PreviewHTTPServer(HTTPServer, object):
    331   def __init__(self, server_address, handler, highlighters):
    332     super(PreviewHTTPServer, self).__init__(server_address, handler)
    333     self.highlighters = highlighters
    334 
    335 
    336 if __name__ == '__main__':
    337   parser = optparse.OptionParser(
    338       description='Runs a server to preview the json_schema_compiler output.',
    339       usage='usage: %prog [option]...')
    340   parser.add_option('-p', '--port', default='8000',
    341       help='port to run the server on')
    342 
    343   (opts, argv) = parser.parse_args()
    344 
    345   try:
    346     print('Starting previewserver on port %s' % opts.port)
    347     print('The extension documentation can be found at:')
    348     print('')
    349     print('  http://localhost:%s/chrome/common/extensions/api' % opts.port)
    350     print('')
    351 
    352     highlighters = {
    353       'hilite': hilite_me_highlighter.HiliteMeHighlighter(),
    354       'none': none_highlighter.NoneHighlighter()
    355     }
    356     try:
    357       highlighters['pygments'] = pygments_highlighter.PygmentsHighlighter()
    358     except ImportError as e:
    359       pass
    360 
    361     server = PreviewHTTPServer(('', int(opts.port)),
    362                                CompilerHandler,
    363                                highlighters)
    364     server.serve_forever()
    365   except KeyboardInterrupt:
    366     server.socket.close()
    367