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)
+    if '.' not in link:
+      link = self._namespace.name + '.' + link
+    return { 'ref': link, 'text': link, 'name': link }

[not at google - send to devlin, 2014/03/28 21:48:22]

Do you know what the difference between "text" and "name" is? We should only
make the "ref" part namespaced. If the tabs API references the "Tab" type, we'd
want that to render as $(ref:tabs.Tab Tab) not $(ref:tabs.Tab tabs.Tab).

 
   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))