Docserver: Display API features that are available to content scripts

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

 # Copyright 2013 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 posixpath
 
 from compiled_file_system import SingleFile, Unicode
-from docs_server_utils import StringIdentity
+from docs_server_utils import StringIdentity, MarkLast, MarkFirst
 from extensions_paths import API_PATHS
-from features_bundle import HasParentFeature
+from features_bundle import HasParentFeature, GetParentFeature
 from file_system import FileNotFoundError
 from future import Collect, Future
+from operator import itemgetter
 from platform_util import PlatformToExtensionType
 from schema_util import ProcessSchema
 from third_party.json_schema_compiler.json_schema import DeleteNodes
 from third_party.json_schema_compiler.model import Namespace, UnixName
 
 
+class ContentScriptAPI(object):
+  '''Represents an API available to content scripts.
+  '''
+  def __init__(self, name):
+    self.name = name
+    self.restrictedTo = []

[not at google - send to devlin, 2014/07/10 17:31:27]

I'd rather "nothing restricted" be modelled as None, not empty-list, if you can
manage it in a clean way.

+
+  def get(self, key):

[not at google - send to devlin, 2014/07/10 17:31:27]

exposing a "get" method is an implementation detail of the data sources, not of
the model.

and note that you can easily do all of this stuff by accessing the __dict__
property of these things. like,

content_script_apis = [csa.__dict__
                       for csa in api_models.GetContentScriptAPIs()]

and sort, MarkFirst/Last however you want.

[ahernandez, 2014/07/14 18:11:18]

If this doesn't have a get() method, how can handlebar get the right data? I'm
not sure where else I could expose a get() method.

[not at google - send to devlin, 2014/07/15 16:26:38]

__dict__ returns a dict all of the properties of that method, right? and all
dicts have a get() method?

+    if key == 'name':
+      return self.name
+    if key == 'restrictedTo':
+      return self.restrictedTo
+    raise AssertionError('%s: No such attribute' % key)
+
+  def __eq__(self, o):
+    return self.name == o.name and self.restrictedTo == o.restrictedTo
+
+
 class APIModels(object):
   '''Tracks APIs and their Models.
   '''
 
   def __init__(self,
                features_bundle,
                compiled_fs_factory,
                file_system,
+               object_store_creator,
                platform):
     self._features_bundle = features_bundle
     self._platform = PlatformToExtensionType(platform)
     self._model_cache = compiled_fs_factory.Create(
         file_system, self._CreateAPIModel, APIModels, category=self._platform)
+    self._object_store = object_store_creator.Create(APIModels)
 
   @SingleFile
   @Unicode
   def _CreateAPIModel(self, path, data):
     def does_not_include_platform(node):
       return ('extension_types' in node and
               node['extension_types'] != 'all' and
               self._platform not in node['extension_types'])
 
     schema = ProcessSchema(path, data, inline=True)[0]
@@ skipping 48 matching lines @@
     def resolve():
       for future in futures:
         try:
           return future.Get()
         # Either the file wasn't found or there was no schema for the file
         except (FileNotFoundError, ValueError): pass
       # Propagate the first error if neither were found.
       futures[0].Get()
     return Future(callback=resolve)
 
+  def GetContentScriptAPIs(self):
+    '''Creates a dict of APIs and nodes supported by content scripts in
+    this format:
+
+      {
+        'extension': <ContentScriptAPI object>,
+        ...
+      }
+
+    where a ContentScriptAPI object's restrictedTo attribute items look like:
+
+      {
+        'parent': 'extension',
+        'node': 'sendMessage'
+      }
+    '''
+    content_script_apis_future = self._object_store.Get('content_script_apis')
+    api_features_future = self._features_bundle.GetAPIFeatures()
+    def resolve():
+      content_script_apis = content_script_apis_future.Get()
+      if content_script_apis is not None:
+        return content_script_apis
+
+      api_features = api_features_future.Get()
+      content_script_apis = {}
+      for feature in api_features.itervalues():
+        if 'content_script' not in feature.get('contexts', ()):
+          continue
+        parent = GetParentFeature(feature['name'], feature, api_features)
+        # If it has no parent, then the API is fully supported.
+        if parent is None:
+          content_script_apis[feature['name']] = ContentScriptAPI(
+              feature['name'])
+        else:
+          # Creates a dict for the individual node.
+          node = {'parent': parent, 'node': feature['name'][len(parent) + 1:]}
+          # Initializes the supportedNodes list if it doesn't exist yet.
+          if parent not in content_script_apis:
+            content_script_apis[parent] = ContentScriptAPI(parent)
+          content_script_apis[parent].restrictedTo.append(node)
+
+      # Sort all of the supportedNodes.

[not at google - send to devlin, 2014/07/10 17:31:27]

see comment at top of file.

+      for content_script_api in content_script_apis.itervalues():
+        restricted_nodes = content_script_api.restrictedTo
+        if restricted_nodes:
+          restricted_nodes.sort(key=itemgetter('node'))
+          MarkFirst(restricted_nodes)
+          MarkLast(restricted_nodes)
+
+      self._object_store.Set('content_script_apis', content_script_apis)
+      return content_script_apis
+    return Future(callback=resolve)
+
   def Cron(self):
     futures = [self.GetModel(name) for name in self.GetNames()]
     return Collect(futures, except_pass=(FileNotFoundError, ValueError))
 
   def IterModels(self):
     future_models = [(name, self.GetModel(name)) for name in self.GetNames()]
     for name, future_model in future_models:
       try:
         model = future_model.Get()
       except FileNotFoundError:
         continue
       if model:
         yield name, model