Remove ReferenceResolver dependency in APIDataSource.

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 posixpath
 
 from environment import IsPreviewServer
@@ skipping 50 matching lines @@
 
 
 class _JSCModel(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,
                api_name,
                api_models,
-               ref_resolver,
                disable_refs,
                availability_finder,
                json_cache,
                template_cache,
                features_bundle,
                event_byname_function):
-    self._ref_resolver = ref_resolver
     self._disable_refs = disable_refs
     self._availability_finder = availability_finder
     self._api_availabilities = json_cache.GetFromFile(
         posixpath.join(JSON_TEMPLATES, 'api_availabilities.json'))
     self._intro_tables = json_cache.GetFromFile(
         posixpath.join(JSON_TEMPLATES, 'intro_tables.json'))
     self._api_features = features_bundle.GetAPIFeatures()
     self._template_cache = template_cache
     self._event_byname_function = event_byname_function
     self._namespace = api_models.GetModel(api_name).Get()
 
-  def _FormatDescription(self, description):
-    if self._disable_refs:
-      return description
-    return self._ref_resolver.ResolveAllLinks(description,
-                                              namespace=self._namespace.name)
-
   def _GetLink(self, link):
-    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)
+    ref = link if '.' in link else (self._namespace.name + '.' + link)
+    return { 'ref': ref, 'text': link, 'name': link }
 
   def ToDict(self):
     if self._namespace is None:
       return {}
     chrome_dot_name = 'chrome.%s' % self._namespace.name
     as_dict = {
       'name': self._namespace.name,
       'namespace': self._namespace.documentation_options.get('namespace',
                                                              chrome_dot_name),
       'title': self._namespace.documentation_options.get('title',
@@ skipping 27 matching lines @@
 
   def _IsExperimental(self):
     return self._namespace.name.startswith('experimental')
 
   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),
+      'description': 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)
     return type_dict
 
   def _GenerateFunctions(self, functions):
     return [self._GenerateFunction(f) for f in functions.values()]
 
   def _GenerateFunction(self, function):
     function_dict = {
       'name': function.simple_name,
-      'description': self._FormatDescription(function.description),
+      'description': function.description,
       'callback': self._GenerateCallback(function.callback),
       'parameters': [],
       'returns': None,
       'id': _CreateId(function, 'method')
     }
     self._AddCommonProperties(function_dict, function)
     if function.returns:
       function_dict['returns'] = self._GenerateType(function.returns)
     for param in function.params:
       function_dict['parameters'].append(self._GenerateProperty(param))
     if function.callback is not None:
       # Show the callback as an extra parameter.
       function_dict['parameters'].append(
           self._GenerateCallbackProperty(function.callback))
     if len(function_dict['parameters']) > 0:
       function_dict['parameters'][-1]['last'] = True
     return function_dict
 
   def _GenerateEvents(self, events):
     return [self._GenerateEvent(e) for e in events.values()
             if not e.supports_dom]
 
   def _GenerateDomEvents(self, events):
     return [self._GenerateEvent(e) for e in events.values()
             if e.supports_dom]
 
   def _GenerateEvent(self, event):
     event_dict = {
       'name': event.simple_name,
-      'description': self._FormatDescription(event.description),
+      'description': event.description,
       'filters': [self._GenerateProperty(f) for f in event.filters],
       'conditions': [self._GetLink(condition)
                      for condition in event.conditions],
       'actions': [self._GetLink(action) for action in event.actions],
       'supportsRules': event.supports_rules,
       'supportsListeners': event.supports_listeners,
       'properties': [],
       'id': _CreateId(event, 'event'),
       'byName': {},
     }
@@ skipping 56 matching lines @@
     # Make sure we generate property info for arrays, too.
     # TODO(kalman): what about choices?
     if type_.property_type == model.PropertyType.ARRAY:
       properties = type_.item_type.properties
     else:
       properties = type_.properties
 
     property_dict = {
       'name': property_.simple_name,
       'optional': property_.optional,
-      'description': self._FormatDescription(property_.description),
+      'description': property_.description,
       'properties': self._GenerateProperties(type_.properties),
       'functions': self._GenerateFunctions(type_.functions),
       'parameters': [],
       'returns': None,
       'id': _CreateId(property_, 'property')
     }
     self._AddCommonProperties(property_dict, property_)
 
     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._GenerateType(function.returns)
 
     value = property_.value
     if value is not None:
       if isinstance(value, int):
         property_dict['value'] = _FormatValue(value)
       else:
         property_dict['value'] = value
     else:
       self._RenderTypeInformation(type_, property_dict)
 
     return property_dict
 
   def _GenerateCallbackProperty(self, callback):
     property_dict = {
       'name': callback.simple_name,
-      'description': self._FormatDescription(callback.description),
+      'description': callback.description,
       'optional': callback.optional,
       'is_callback': True,
       'id': _CreateId(callback, 'property'),
       'simple_type': 'function',
     }
     if (callback.parent is not None and
         not isinstance(callback.parent, model.Namespace)):
       property_dict['parentName'] = callback.parent.simple_name
     return property_dict
 
@@ skipping 39 matching lines @@
         intro_rows.append(misc_row)
 
     return intro_rows
 
   def _GetIntroDescriptionRow(self):
     ''' Generates the 'Description' row data for an API intro table.
     '''
     return {
       'title': 'Description',
       'content': [
-        { 'text': self._FormatDescription(self._namespace.description) }
+        { 'text': self._namespace.description }
       ]
     }
 
   def _GetIntroAvailabilityRow(self):
     ''' Generates the 'Availability' row data for an API intro table.
     '''
     if self._IsExperimental():
       status = 'experimental'
       version = None
     else:
@@ skipping 77 matching lines @@
         # If there is a 'partial' argument and it hasn't already been
         # converted to a Handlebar object, transform it to a template.
         if 'partial' in node:
           node['partial'] = self._template_cache.GetFromFile(
               posixpath.join(PRIVATE_TEMPLATES, node['partial'])).Get()
       misc_rows.append({ 'title': category, 'content': content })
     return misc_rows
 
   def _AddCommonProperties(self, target, src):
     if src.deprecated is not None:
-      target['deprecated'] = self._FormatDescription(
-          src.deprecated)
+      target['deprecated'] = src.deprecated
     if (src.parent is not None and
         not isinstance(src.parent, model.Namespace)):
       target['parentName'] = src.parent.simple_name
 
 
 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.
   '''
 
@@ skipping 22 matching lines @@
       self._template_cache = compiled_fs_factory.ForTemplates(file_system)
       self._availability_finder = availability_finder
       self._api_models = api_models
       self._features_bundle = features_bundle
       self._model_cache_refs = object_store_creator.Create(
           APIDataSource, 'model-cache-refs')
       self._model_cache_no_refs = object_store_creator.Create(
           APIDataSource, 'model-cache-no-refs')
 
       # These must be set later via the SetFooDataSourceFactory methods.
-      self._ref_resolver_factory = None
       self._samples_data_source_factory = None
 
       # This caches the result of _LoadEventByName.
       self._event_byname = None
 
     def SetSamplesDataSourceFactory(self, samples_data_source_factory):
       self._samples_data_source_factory = samples_data_source_factory
 
-    def SetReferenceResolverFactory(self, ref_resolver_factory):
-      self._ref_resolver_factory = ref_resolver_factory
-
     def Create(self, request):
       '''Creates an APIDataSource.
       '''
       if self._samples_data_source_factory is None:
         # Only error if there is a request, which means this APIDataSource is
         # actually being used to render a page.
         if request is not None:
           logging.error('SamplesDataSource.Factory was never set in '
                         'APIDataSource.Factory.')
         samples = None
@@ skipping 16 matching lines @@
       return self._model_cache_refs
 
     def _GetSchemaModel(self, api_name, disable_refs):
       jsc_model = self._GetModelCache(disable_refs).Get(api_name).Get()
       if jsc_model is not None:
         return jsc_model
 
       jsc_model = _JSCModel(
           api_name,
           self._api_models,
-          self._ref_resolver_factory.Create() if not disable_refs else None,
           disable_refs,
           self._availability_finder,
           self._json_cache,
           self._template_cache,
           self._features_bundle,
           self._LoadEventByName).ToDict()
 
       self._GetModelCache(disable_refs).Set(api_name, jsc_model)
       return jsc_model
 
   def __init__(self, get_schema_model, samples):
     self._get_schema_model = get_schema_model
     self._samples = samples
 
   def _GenerateHandlebarContext(self, handlebar_dict):
     # Parsing samples on the preview server takes seconds and doesn't add
     # anything. Don't do it.
     if not IsPreviewServer():
       handlebar_dict['samples'] = _LazySamplesGetter(
           handlebar_dict['name'],
           self._samples)
     return handlebar_dict
 
   def get(self, api_name, disable_refs=False):
     return self._GenerateHandlebarContext(
         self._get_schema_model(api_name, disable_refs))