Docserver: refactor Servlet, ObjectStore, and ServerInstance architecture to

chrome/common/extensions/docs/server2/samples_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 hashlib
 import json
 import logging
 import re
 
 from compiled_file_system import CompiledFileSystem
 from file_system import FileNotFoundError
 import third_party.json_schema_compiler.json_comment_eater as json_comment_eater
 import third_party.json_schema_compiler.model as model
 import url_constants
 
 DEFAULT_ICON_PATH = '/images/sample-default-icon.png'
 
 class SamplesDataSource(object):
-  """Constructs a list of samples and their respective files and api calls.
-  """
+  '''Constructs a list of samples and their respective files and api calls.
+  '''
   class Factory(object):
-    """A factory to create SamplesDataSource instances bound to individual
+    '''A factory to create SamplesDataSource instances bound to individual
     Requests.
-    """
+    '''
     def __init__(self,
                  channel,
-                 extensions_file_system,
-                 apps_file_system,
+                 host_file_system,
+                 compiled_host_fs_factory,
+                 app_samples_file_system,
+                 compiled_app_samples_fs_factory,
                  ref_resolver_factory,
-                 object_store_creator_factory,
                  extension_samples_path):
-      self._svn_file_system = extensions_file_system
-      self._github_file_system = apps_file_system
+      self._host_file_system = host_file_system
+      self._app_samples_file_system = app_samples_file_system
       self._static_path = '/%s/static' % channel
       self._ref_resolver = ref_resolver_factory.Create()
       self._extension_samples_path = extension_samples_path
-      def create_compiled_fs(fs, fn, category):
-        return CompiledFileSystem.Factory(
-            fs,
-            object_store_creator_factory).Create(fn,
-                                                 SamplesDataSource,
-                                                 category=category)
-      self._extensions_cache = create_compiled_fs(extensions_file_system,
-                                                  self._MakeSamplesList,
-                                                  'extensions')
-      self._apps_cache = create_compiled_fs(apps_file_system,
-                                            lambda *args: self._MakeSamplesList(
-                                                *args, is_apps=True),
-                                            'apps')
+      self._extensions_cache = compiled_host_fs_factory.Create(
+          self._MakeSamplesList,
+          SamplesDataSource,
+          category='extensions')
+      self._apps_cache = compiled_app_samples_fs_factory.Create(
+          lambda *args: self._MakeSamplesList(*args, is_apps=True),
+          SamplesDataSource,
+          category='apps')
 
     def Create(self, request):
-      """Returns a new SamplesDataSource bound to |request|.
-      """
+      '''Returns a new SamplesDataSource bound to |request|.
+      '''
       return SamplesDataSource(self._extensions_cache,
                                self._apps_cache,
                                self._extension_samples_path,
                                request)
 
     def _GetAPIItems(self, js_file):
       chrome_regex = '(chrome\.[a-zA-Z0-9\.]+)'
       calls = set(re.findall(chrome_regex, js_file))
       # Find APIs that have been assigned into variables.
       assigned_vars = dict(re.findall('var\s*([^\s]+)\s*=\s*%s;' % chrome_regex,
@@ skipping 32 matching lines @@
           logging.error('Error parsing locales files for %s: %s' % (path, e))
         else:
           for path, json_ in locales_json:
             l10n_data['locales'][path[len(locales_path):].split('/')[0]] = json_
       return l10n_data
 
     def _MakeSamplesList(self, base_dir, files, is_apps=False):
       # HACK(kalman): The code here (for legacy reasons) assumes that |files| is
       # prefixed by |base_dir|, so make it true.
       files = ['%s%s' % (base_dir, f) for f in files]
-      file_system = (self._github_file_system if is_apps else
-                     self._svn_file_system)
+      file_system = (self._app_samples_file_system if is_apps else
+                     self._host_file_system)
       samples_list = []
       for filename in sorted(files):
         if filename.rsplit('/')[-1] != 'manifest.json':
           continue
         # This is a little hacky, but it makes a sample page.
         sample_path = filename.rsplit('/', 1)[-2]
         sample_files = [path for path in files
                         if path.startswith(sample_path + '/')]
         js_files = [path for path in sample_files if path.endswith('.js')]
         try:
@@ skipping 71 matching lines @@
     self._request = request
 
   def _GetAcceptedLanguages(self):
     accept_language = self._request.headers.get('Accept-Language', None)
     if accept_language is None:
       return []
     return [lang_with_q.split(';')[0].strip()
             for lang_with_q in accept_language.split(',')]
 
   def FilterSamples(self, key, api_name):
-    """Fetches and filters the list of samples specified by |key|, returning
+    '''Fetches and filters the list of samples specified by |key|, returning
     only the samples that use the API |api_name|. |key| is either 'apps' or
     'extensions'.
-    """
+    '''
     api_search = api_name + '_'
     samples_list = []
     try:
       for sample in self.get(key):
         api_calls_unix = [model.UnixName(call['name'])
                           for call in sample['api_calls']]
         for call in api_calls_unix:
           if call.startswith(api_search):
             samples_list.append(sample)
             break
@@ skipping 36 matching lines @@
         return_list.append(sample_data)
       else:
         return_list.append(dict_)
     return return_list
 
   def get(self, key):
     return {
       'apps': lambda: self._CreateSamplesDict('apps'),
       'extensions': lambda: self._CreateSamplesDict('extensions')
     }.get(key, lambda: {})()