Extension Docs Server Version 2: Various fixes.

chrome/common/extensions/docs/server2/handlebar_dict_generator.py

 # 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 copy
 import logging
 import os
 
 import third_party.json_schema_compiler.model as model
 
@@ skipping 51 matching lines @@
         'properties': self._GenerateProperties(self._namespace.properties)
       }
     except Exception as e:
       logging.info(e)
 
   def _GenerateType(self, type_):
     type_dict = {
       'name': type_.name,
       'description': type_.description,
       'properties': self._GenerateProperties(type_.properties),
-      'functions': self._GenerateFunctions(type_.functions)
+      'functions': self._GenerateFunctions(type_.functions),
+      'events': map(self._GenerateEvent, type_.events.values())

[not at google - send to devlin, 2012/07/20 02:04:54]

types have events? whoa.

[chebert, 2012/07/21 19:40:31]

ChromeSetting is the only type where I have seen this. (types.html)

On 2012/07/20 02:04:54, kalman wrote:

     }
     self._RenderTypeInformation(type_, type_dict)
     return type_dict
 
   def _GenerateFunctions(self, functions):
     return map(self._GenerateFunction, functions.values())
 
   def _GenerateFunction(self, function):
     function_dict = {
       'name': function.name,
@@ skipping 14 matching lines @@
       'name': event.name,
       'description': event.description,
       'parameters': map(self._GenerateProperty, event.params)
     }
     if len(event_dict['parameters']) > 0:
       event_dict['parameters'][-1]['last'] = True
     return event_dict
 
   def _GenerateCallback(self, callback):
     if not callback:
-      return {}
+      return None
     callback_dict = {
       'name': 'callback',
       'description': callback.description,
       'simple_type': {'simple_type': 'function'},
       'optional': callback.optional,
       'parameters': []
     }
     for param in callback.params:
       callback_dict['parameters'].append(self._GenerateProperty(param))
     if (len(callback_dict['parameters']) > 0):
@@ skipping 21 matching lines @@
     return property_dict
 
   def _RenderTypeInformation(self, property_, dst_dict):
     if property_.type_ == model.PropertyType.CHOICES:
       dst_dict['choices'] = map(self._GenerateProperty,
                                 property_.choices.values())
       # We keep track of which is last for knowing when to add "or" between
       # choices in templates.
       if len(dst_dict['choices']) > 0:
         dst_dict['choices'][-1]['last'] = True
+    elif property_.type_ == model.PropertyType.ADDITIONAL_PROPERTIES:
+      dst_dict['additional_properties'] = True
     elif property_.type_ == model.PropertyType.REF:
       dst_dict['link'] = _GetLinkToRefType(self._namespace.name,
                                         property_.ref_type)
     elif property_.type_ == model.PropertyType.ARRAY:
       dst_dict['array'] = self._GenerateProperty(property_.item_type)
     elif property_.type_ == model.PropertyType.ENUM:
       dst_dict['enum_values'] = []
       for enum_value in property_.enum_values:
         dst_dict['enum_values'].append({'name': enum_value})
       if len(dst_dict['enum_values']) > 0:
         dst_dict['enum_values'][-1]['last'] = True
     else:
       dst_dict['simple_type'] = {'simple_type': property_.type_.name.lower()}