Docserver: Display API features that are available to content scripts

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.
 
 from copy import copy
 import logging
 import os
 import posixpath
 
 from data_source import DataSource
-from docs_server_utils import StringIdentity
+from docs_server_utils import StringIdentity, MarkFirst, MarkLast
 from environment import IsPreviewServer, IsReleaseServer
 from extensions_paths import JSON_TEMPLATES, PRIVATE_TEMPLATES
 from file_system import FileNotFoundError
 from future import Future, Collect
+from operator import itemgetter
 from platform_util import GetPlatforms
 import third_party.json_schema_compiler.json_parse as json_parse
 import third_party.json_schema_compiler.model as model
 from third_party.json_schema_compiler.memoize import memoize
 
 
 # The set of possible categories a node may belong to.
 _NODE_CATEGORIES = ('types', 'functions', 'events', 'properties')
 
 
@@ skipping 233 matching lines @@
   def __repr__(self):
     return '%s > %s' % (self._namespace_name, ' > '.join(self._lookup_path))
 
 
 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,
+               content_script_apis,
                namespace,
                availability_finder,
                json_cache,
                template_cache,
                features_bundle,
                event_byname_future):
+    self._content_script_apis = content_script_apis
     self._availability = availability_finder.GetAPIAvailability(namespace.name)
     self._current_node = _APINodeCursor(availability_finder, namespace.name)
     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_future = event_byname_future
     self._namespace = namespace
@@ skipping 252 matching lines @@
       else:
         dst_dict['simple_type'] = type_.property_type.name
 
   def _GetIntroTableList(self):
     '''Create a generic data structure that can be traversed by the templates
     to create an API intro table.
     '''
     intro_rows = [
       self._GetIntroDescriptionRow(),
       self._GetIntroAvailabilityRow()
-    ] + self._GetIntroDependencyRows()
+    ] + self._GetIntroDependencyRows() + self._GetIntroContentScriptRow()
 
     # Add rows using data from intro_tables.json, overriding any existing rows
     # if they share the same 'title' attribute.
     row_titles = [row['title'] for row in intro_rows]
     for misc_row in self._GetMiscIntroRows():
       if misc_row['title'] in row_titles:
         intro_rows[row_titles.index(misc_row['title'])] = misc_row
       else:
         intro_rows.append(misc_row)
 
     return intro_rows
 
   def _GetAvailabilityTemplate(self, status=None, version=None, scheduled=None):
     '''Returns an object that the templates use to display availability
     information.
     '''
     if status is None:
       availability_info = self._current_node.GetAvailability()
       if availability_info is None:
         return None
       status = availability_info.channel
       version = availability_info.version
     return {
       'partial': self._template_cache.GetFromFile(
           '%sintro_tables/%s_message.html' % (PRIVATE_TEMPLATES, status)).Get(),
       'scheduled': scheduled,
       'version': version
     }
 
+  def _GetIntroContentScriptRow(self):
+    content_script_support = self._content_script_apis.get(self._namespace.name)
+    if content_script_support is None:
+      return []
+    if content_script_support.restrictedTo:

[ahernandez, 2014/07/16 20:35:34]

Should this code be moved into a function somewhere, and if so where? It's
pretty much exactly the same as the sorting logic in api_list_data_source.py.

[not at google - send to devlin, 2014/07/21 17:51:19]

maybe, though I can't think of an appropriate place. it seems arbitrary to try
and share it. maybe keep it in mind in case it turns out there needs to be more
code shared?

perhaps as a small concession you could add a MarkFirstAndLast method to at
least reduce that little redundancy.

+      content_script_support.restrictedTo.sort(key=itemgetter('node'))
+      MarkFirst(content_script_support.restrictedTo)
+      MarkLast(content_script_support.restrictedTo)
+    return [{
+      'title': 'Content Scripts',
+      'content': [{
+        'partial': self._template_cache.GetFromFile(
+            posixpath.join(PRIVATE_TEMPLATES,
+                           'intro_tables',
+                           'content_scripts.html')).Get(),
+        'contentScriptSupport': content_script_support.__dict__
+      }]
+    }]
+
   def _GetIntroDescriptionRow(self):
     ''' Generates the 'Description' row data for an API intro table.
     '''
     return {
       'title': 'Description',
       'content': [
         { 'text': self._namespace.description }
       ]
     }
 
@@ skipping 139 matching lines @@
     from Event in events.json.
     '''
     if platform not in self._event_byname_futures:
       future = self._GetSchemaModel(platform, 'events')
       self._event_byname_futures[platform] = Future(
           callback=lambda: _GetEventByNameFromEvents(future.Get()))
     return self._event_byname_futures[platform]
 
   def _GetSchemaModel(self, platform, api_name):
     object_store_key = '/'.join((platform, api_name))
+    api_models = self._platform_bundle.GetAPIModels(platform)
     jsc_model_future = self._model_cache.Get(object_store_key)
-    model_future = self._platform_bundle.GetAPIModels(platform).GetModel(
-        api_name)
+    model_future = api_models.GetModel(api_name)
+    content_script_apis_future = api_models.GetContentScriptAPIs()
     def resolve():
       jsc_model = jsc_model_future.Get()
       if jsc_model is None:
         jsc_model = _JSCModel(
+            content_script_apis_future.Get(),
             model_future.Get(),
             self._platform_bundle.GetAvailabilityFinder(platform),
             self._json_cache,
             self._template_cache,
             self._platform_bundle.GetFeaturesBundle(platform),
             self._LoadEventByName(platform)).ToDict()
         self._model_cache.Set(object_store_key, jsc_model)
       return jsc_model
     return Future(callback=resolve)
 
@@ skipping 17 matching lines @@
     getter = lambda: 0
     getter.get = lambda api_name: self._GetImpl(platform, api_name).Get()
     return getter
 
   def Cron(self):
     futures = []
     for platform in GetPlatforms():
       futures += [self._GetImpl(platform, name)
           for name in self._platform_bundle.GetAPIModels(platform).GetNames()]
     return Collect(futures, except_pass=FileNotFoundError)