Extensions Docs Server: Support APIs with properties

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 16 matching lines @@
     text = '.'.join(terms[1:])
     href = terms[0] + '.html' + '#type-' + text
   else:
     href = namespace_name + '.html' + '#type-' +ref_type
     text = ref_type
   return ({
     "href": href,
     "text": text
   })
 
+def _FormatValue(value):
+  s = str(value)
+  return ('<code>%s</code>' %

[not at google - send to devlin, 2012/07/09 11:01:20]

All HTML should be the concern of the templates, not of this code. I.e. it's
fine to layout a string with commas, but include it in the dict as a string then
surround it in <code></code> as appropriate in the templates.

[cduvall, 2012/07/09 17:50:40]

Done.

+          ','.join([s[max(0, i - 3):i] for i in range(len(s), 0, -3)][::-1]))

[not at google - send to devlin, 2012/07/09 11:01:20]

wow this is voodoo...

+
 class HandlebarDictGenerator(object):
   """Uses a Model from the JSON Schema Compiler and generates a dict that
   a Handlebar template can use for a data source.
   """
   def __init__(self, json):
     clean_json = copy.deepcopy(json)
     _RemoveNoDocs(clean_json)
     try:
       self._namespace = model.Namespace(clean_json, clean_json['namespace'])
     except Exception as e:
       logging.info(e)
 
   def Generate(self):
     try:
       return {
         'name': self._namespace.name,
         'types': self._GenerateTypes(self._namespace.types),
-        'functions': self._GenerateFunctions(self._namespace.functions)
+        'functions': self._GenerateFunctions(self._namespace.functions),
+        'properties': self._GenerateProperties(self._namespace.properties)
       }
     except Exception as e:
       logging.info(e)
 
   def _GenerateTypes(self, types):
     types_list = []
     for type_name in types:
       types_list.append(self._GenerateType(types[type_name]))
     return types_list
 
@@ skipping 26 matching lines @@
       function_dict['parameters'].append(function_dict['callback'])
     if len(function_dict['parameters']) > 0:
       function_dict['parameters'][-1]['last_item'] = True
     return function_dict
 
   def _GenerateCallback(self, callback):
     if not callback:
       return {}
     callback_dict = {
       'name': 'callback',
+      'description': callback.description,
       'simple_type': {'type': 'function'},
       'optional': callback.optional,
       'parameters': []
     }
     for param in callback.params:
       callback_dict['parameters'].append(self._GenerateProperty(param))
     if (len(callback_dict['parameters']) > 0):
       callback_dict['parameters'][-1]['last_parameter'] = True
     return callback_dict
 
   def _GenerateProperties(self, properties):
     properties_list = []
     for property_name in properties:
       properties_list.append(self._GenerateProperty(properties[property_name]))
     return properties_list
 
   def _GenerateProperty(self, property_):
     property_dict = {
       'name': property_.name,
       'optional': property_.optional,
       'description': property_.description,
-      'properties': self._GenerateProperties(property_.properties)
+      'properties': self._GenerateProperties(property_.properties),
+      'functions': self._GenerateFunctions(property_.functions)
     }
     self._RenderTypeInformation(property_, property_dict)
+    self._RenderValue(property_.value, property_dict)
     return property_dict
 
+  def _RenderValue(self, value, dst_dict):
+    if 'simple_type' in dst_dict and isinstance(value, int):
+      dst_dict['simple_type']['type'] = _FormatValue(value)

[not at google - send to devlin, 2012/07/09 11:01:20]

I think just incorporate this into _RenderTypeInformation using the "has_value"
property. I think that things with a value don't have types; or at least, don't
have types that we care about.

[cduvall, 2012/07/09 17:50:40]

Done.

+
   def _RenderTypeInformation(self, property_, dst_dict):
     dst_dict['type'] = property_.type_.name.lower()
     if property_.type_ == model.PropertyType.CHOICES:

[not at google - send to devlin, 2012/07/09 11:01:20]

here:

if property_.has_value:
  if isinstance(property_.value, int):
    ...
  else:
    ...
elif property_.type_ == model.PropertyType.CHOICES

[cduvall, 2012/07/09 17:50:40]

Done.

       dst_dict['choices'] = []
       for choice_name in property_.choices:
         dst_dict['choices'].append(self._GenerateProperty(
             property_.choices[choice_name]))
       # 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_choice'] = 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)
     else:
       dst_dict['simple_type'] = {'type': dst_dict['type']}