Extensions Docs Server: Server code for showing properties of properties

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

Index: chrome/common/extensions/docs/server2/handlebar_dict_generator.py
diff --git a/chrome/common/extensions/docs/server2/handlebar_dict_generator.py b/chrome/common/extensions/docs/server2/handlebar_dict_generator.py
index 5d52f2ca8a0af6b31da50ca230ba1125559538b5..7c12d1e1cfd454786fe128684192b1f848940d1d 100644
--- a/chrome/common/extensions/docs/server2/handlebar_dict_generator.py
+++ b/chrome/common/extensions/docs/server2/handlebar_dict_generator.py
@@ -21,6 +21,11 @@ def _RemoveNoDocs(item):
         item.remove(i)
   return False
 
+def _CreateId(name, parent, prefix):

[not at google - send to devlin, 2012/10/03 01:07:26]

It would be a bit nicer to have parent be an optional parameter for
self-documentation, even though sometimes when you call this you don't know
whether there's a parent or not.

Actually... if you pass in the model object itself, it can figure out the parent
from that? Though see comment below about the "simple_name" stuff. That goes for
everywhere in this file where you've added a "parent" parameter to functions.

[cduvall, 2012/10/05 01:13:26]

Done.

+  if parent:

[not at google - send to devlin, 2012/10/03 01:07:26]

"is not None" or whatever?

[cduvall, 2012/10/05 01:13:26]

Done.

+    return '-'.join([prefix, parent, name])
+  return '-'.join([prefix, name])
+
 def _FormatValue(value):
   """Inserts commas every three digits for integer values. It is magic.
   """
@@ -69,33 +74,38 @@ class HandlebarDictGenerator(object):
       return {}
     return {
       'name': self._namespace.name,
-      'types': map(self._GenerateType, self._namespace.types.values()),
-      'functions': self._GenerateFunctions(self._namespace.functions),
-      'events': map(self._GenerateEvent, self._namespace.events.values()),
-      'properties': self._GenerateProperties(self._namespace.properties)
+      'types':  [self._GenerateType(t) for t in self._namespace.types.values()
+                 if t.type_ != model.PropertyType.ADDITIONAL_PROPERTIES],
+      'functions': self._GenerateFunctions(self._namespace.functions, None),
+      'events': self._GenerateEvents(self._namespace.events, None),
+      'properties': self._GenerateProperties(self._namespace.properties, None)
     }
 
   def _GenerateType(self, type_):
+    name = self._StripPrefix(type_.name)
     type_dict = {
-      'name': self._StripPrefix(type_.name),
+      'name': name,
       'description': self._FormatDescription(type_.description),
-      'properties': self._GenerateProperties(type_.properties),
-      'functions': self._GenerateFunctions(type_.functions),
-      'events': map(self._GenerateEvent, type_.events.values())
+      'properties': self._GenerateProperties(type_.properties, name),
+      'functions': self._GenerateFunctions(type_.functions, name),
+      'events': self._GenerateEvents(type_.events, name),
+      'id': _CreateId(name, None, 'type')
     }
     self._RenderTypeInformation(type_, type_dict)
     return type_dict
 
-  def _GenerateFunctions(self, functions):
-    return map(self._GenerateFunction, functions.values())
+  def _GenerateFunctions(self, functions, parent):

[not at google - send to devlin, 2012/10/03 01:07:26]

Again, make parent explicitly optional, though you might not actually need it.

[cduvall, 2012/10/05 01:13:26]

Done.

+    return [self._GenerateFunction(f, parent) for f in functions.values()]
 
-  def _GenerateFunction(self, function):
+  def _GenerateFunction(self, function, parent):
     function_dict = {
       'name': function.name,
       'description': self._FormatDescription(function.description),
       'callback': self._GenerateCallback(function.callback),
       'parameters': [],
-      'returns': None
+      'returns': None,
+      'parent': parent,
+      'id': _CreateId(function.name, parent, 'method')
     }
     if function.returns:
       function_dict['returns'] = self._GenerateProperty(function.returns)
@@ -107,9 +117,13 @@ class HandlebarDictGenerator(object):
       function_dict['parameters'][-1]['last'] = True
     return function_dict
 
-  def _GenerateEvent(self, event):
+  def _GenerateEvents(self, events, parent):
+    return [self._GenerateEvent(e, parent) for e in events.values()]
+
+  def _GenerateEvent(self, event, parent):
+    name = self._StripPrefix(event.name)
     event_dict = {
-      'name': self._StripPrefix(event.name),
+      'name': name,
       'description': self._FormatDescription(event.description),
       'parameters': map(self._GenerateProperty, event.params),
       'callback': self._GenerateCallback(event.callback),
@@ -118,7 +132,9 @@ class HandlebarDictGenerator(object):
       'actions': [GetLinkToRefType(self._namespace.name, a)
                      for a in event.actions],
       'filters': map(self._GenerateProperty, event.filters),
-      'supportsRules': event.supports_rules
+      'supportsRules': event.supports_rules,
+      'parent': parent,
+      'id': _CreateId(name, parent, 'event')
     }
     if event_dict['callback']:
       event_dict['parameters'].append(event_dict['callback'])
@@ -142,16 +158,20 @@ class HandlebarDictGenerator(object):
       callback_dict['parameters'][-1]['last'] = True
     return callback_dict
 
-  def _GenerateProperties(self, properties):
-    return map(self._GenerateProperty, properties.values())
+  def _GenerateProperties(self, properties, parent):
+    return [self._GenerateProperty(v, parent) for v in properties.values()
+            if v.type_ != model.PropertyType.ADDITIONAL_PROPERTIES]
 
-  def _GenerateProperty(self, property_):
+  def _GenerateProperty(self, property_, parent=None):
+    name = self._StripPrefix(property_.name)
     property_dict = {
-      'name': self._StripPrefix(property_.name),
+      'name': name,
       'optional': property_.optional,
       'description': self._FormatDescription(property_.description),
-      'properties': self._GenerateProperties(property_.properties),
-      'functions': self._GenerateFunctions(property_.functions)
+      'properties': self._GenerateProperties(property_.properties, name),
+      'functions': self._GenerateFunctions(property_.functions, name),

[not at google - send to devlin, 2012/10/03 01:07:26]

It's confusing to me that "parent" is actually "name of parent". Could you just
pass the parent in directly, and let the template code that uses it fish out the
name? It would mean pushing the _StripName logic into the JSON schema compiler
model, but that should be easy enough, right? It's possible to figure out the
namespace of an object and strip out the prefix. You could call it "simple_name"
or something (matches the Java reflection API).

[cduvall, 2012/10/05 01:13:26]

Done. I named this 'parent_name' instead, and added the 'simple_name' property
to the JSON schema compiler. This removed the need to pass parents around at all
to the functions.

+      'parent': parent,
+      'id': _CreateId(name, parent, 'property')
     }
     if property_.has_value:
       if isinstance(property_.value, int):
@@ -170,13 +190,11 @@ class HandlebarDictGenerator(object):
       # 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)
+      dst_dict['array'] = self._GenerateProperty(property_.item_type, None)
     elif property_.type_ == model.PropertyType.ENUM:
       dst_dict['enum_values'] = []
       for enum_value in property_.enum_values: