Overhaul JSON Schema Compiler to support a number of features required to

chrome/common/extensions/docs/server2/api_data_source.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 compiled_file_system as compiled_fs
 from file_system import FileNotFoundError
 import third_party.json_schema_compiler.json_parse as json_parse
 import third_party.json_schema_compiler.model as model
 import third_party.json_schema_compiler.idl_schema as idl_schema
 import third_party.json_schema_compiler.idl_parser as idl_parser
 
 # Increment this version when there are changes to the data stored in any of
 # the caches used by APIDataSource. This would include changes to model.py in
 # JSON schema compiler! This allows the cache to be invalidated without having
 # to flush memcache on the production server.
-_VERSION = 12
+_VERSION = 13
 
 def _RemoveNoDocs(item):
   if json_parse.IsDict(item):
     if item.get('nodoc', False):
       return True
     to_remove = []
     for key, value in item.items():
       if _RemoveNoDocs(value):
         to_remove.append(key)
     for k in to_remove:
@@ skipping 41 matching lines @@
     if self._disable_refs:
       type_name = link.split('.', 1)[-1]
       return { 'href': '#type-%s' % type_name, 'text': link, 'name': link }
     return self._ref_resolver.SafeGetLink(link, namespace=self._namespace.name)
 
   def ToDict(self):
     if self._namespace is None:
       return {}
     return {
       'name': self._namespace.name,
-      'types':  [self._GenerateType(t) for t in self._namespace.types.values()
-                 if t.type_ != model.PropertyType.ADDITIONAL_PROPERTIES],
+      'types': self._GenerateTypes(self._namespace.types.values()),
       'functions': self._GenerateFunctions(self._namespace.functions),
       'events': self._GenerateEvents(self._namespace.events),
       'properties': self._GenerateProperties(self._namespace.properties)
     }
 
+  def _GenerateTypes(self, types):
+    return [self._GenerateType(t) for t in types]
+
   def _GenerateType(self, type_):
     type_dict = {
       'name': type_.simple_name,
       'description': self._FormatDescription(type_.description),
       'properties': self._GenerateProperties(type_.properties),
       'functions': self._GenerateFunctions(type_.functions),
       'events': self._GenerateEvents(type_.events),
       'id': _CreateId(type_, 'type')
     }
     self._RenderTypeInformation(type_, type_dict)
@@ skipping 62 matching lines @@
       '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'] = True
     return callback_dict
 
   def _GenerateProperties(self, properties):
-    return [self._GenerateProperty(v) for v in properties.values()
-            if v.type_ != model.PropertyType.ADDITIONAL_PROPERTIES]
+    return [self._GenerateProperty(v) for v in properties.values()]
 
   def _GenerateProperty(self, property_):
+    type_ = property_.type_
+
     # Make sure we generate property info for arrays, too.
     # TODO(kalman): what about choices?
-    if property_.type_ == model.PropertyType.ARRAY:
-      properties = property_.item_type.properties
+    if type_.property_type == model.PropertyType.ARRAY:
+      properties = type_.item_type.properties
     else:
-      properties = property_.properties
+      properties = type_.properties
 
     property_dict = {
       'name': property_.simple_name,
       'optional': property_.optional,
       'description': self._FormatDescription(property_.description),
-      'properties': self._GenerateProperties(properties),
-      'functions': self._GenerateFunctions(property_.functions),
+      'properties': self._GenerateProperties(type_.properties),
+      'functions': self._GenerateFunctions(type_.functions),
       'parameters': [],
       'returns': None,
       'id': _CreateId(property_, 'property')
     }
-    for param in property_.params:
-      property_dict['parameters'].append(self._GenerateProperty(param))
-    if property_.returns:
-      property_dict['returns'] = self._GenerateProperty(property_.returns)
+
+    if type_.property_type == model.PropertyType.FUNCTION:
+      function = type_.function
+      for param in function.params:
+        property_dict['parameters'].append(self._GenerateProperty(param))
+      if function.returns:
+        property_dict['returns'] = self._GenerateProperty(function.returns)
+
     if (property_.parent is not None and
         not isinstance(property_.parent, model.Namespace)):
       property_dict['parent_name'] = property_.parent.simple_name
-    if property_.has_value:
-      if isinstance(property_.value, int):
-        property_dict['value'] = _FormatValue(property_.value)
+
+    value = property_.value
+    if value is not None:
+      if isinstance(value, int):
+        property_dict['value'] = _FormatValue(value)
       else:
-        property_dict['value'] = property_.value
+        property_dict['value'] = value
     else:
-      self._RenderTypeInformation(property_, property_dict)
+      self._RenderTypeInformation(type_, property_dict)
+
     return property_dict
 
   def _GenerateCallbackProperty(self, callback):
     property_dict = {
       'name': callback.simple_name,
       'description': self._FormatDescription(callback.description),
       'optional': callback.optional,
       'id': _CreateId(callback, 'property'),
       'simple_type': 'function',
     }
     if (callback.parent is not None and
         not isinstance(callback.parent, model.Namespace)):
       property_dict['parent_name'] = callback.parent.simple_name
     return property_dict
 
-  def _RenderTypeInformation(self, property_, dst_dict):
-    if property_.type_ == model.PropertyType.CHOICES:
-      dst_dict['choices'] = [self._GenerateProperty(c)
-                             for c in property_.choices.values()]
+  def _RenderTypeInformation(self, type_, dst_dict):
+    if type_.property_type == model.PropertyType.CHOICES:
+      dst_dict['choices'] = self._GenerateTypes(type_.choices)
       # 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.REF:
-      dst_dict['link'] = self._GetLink(property_.ref_type)
-    elif property_.type_ == model.PropertyType.ARRAY:
-      dst_dict['array'] = self._GenerateProperty(property_.item_type)
-    elif property_.type_ == model.PropertyType.ENUM:
+    elif type_.property_type == model.PropertyType.REF:
+      dst_dict['link'] = self._GetLink(type_.ref_type)
+    elif type_.property_type == model.PropertyType.ARRAY:
+      dst_dict['array'] = self._GenerateType(type_.item_type)
+    elif type_.property_type == model.PropertyType.ENUM:
       dst_dict['enum_values'] = []
-      for enum_value in property_.enum_values:
+      for enum_value in type_.enum_values:
         dst_dict['enum_values'].append({'name': enum_value})
       if len(dst_dict['enum_values']) > 0:
         dst_dict['enum_values'][-1]['last'] = True
-    elif property_.instance_of is not None:
-      dst_dict['simple_type'] = property_.instance_of.lower()
+    elif type_.instance_of is not None:
+      dst_dict['simple_type'] = type_.instance_of.lower()
     else:
-      dst_dict['simple_type'] = property_.type_.name.lower()
+      dst_dict['simple_type'] = type_.property_type.name.lower()
 
 class _LazySamplesGetter(object):
   """This class is needed so that an extensions API page does not have to fetch
   the apps samples page and vice versa.
   """
   def __init__(self, api_name, samples):
     self._api_name = api_name
     self._samples = samples
 
   def get(self, key):
@@ skipping 190 matching lines @@
     if self._disable_refs:
       cache, ext = (
           (self._idl_cache_no_refs, '.idl') if (unix_name in idl_names) else
           (self._json_cache_no_refs, '.json'))
     else:
       cache, ext = ((self._idl_cache, '.idl') if (unix_name in idl_names) else
                     (self._json_cache, '.json'))
     return self._GenerateHandlebarContext(
         cache.GetFromFile('%s/%s%s' % (self._base_path, unix_name, ext)),
         path)