Dynamically generate a heading for Extension Docs API pages

chrome/common/extensions/docs/server2/compiled_file_system.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 os
 
 import object_store
+import logging
 
 APPS                      = 'Apps'
 APPS_FS                   = 'AppsFileSystem'
 CRON                      = 'Cron'
 EXTENSIONS                = 'Extensions'
 EXTENSIONS_FS             = 'ExtensionsFileSystem'
 CRON_FILE_LISTING         = 'Cron.FileListing'
 CRON_GITHUB_INVALIDATION  = 'Cron.GithubInvalidation'
 CRON_INVALIDATION         = 'Cron.Invalidation'
 HANDLEBAR                 = 'Handlebar'
@@ skipping 22 matching lines @@
     """A class to build a CompiledFileSystem.
     """
     def __init__(self, file_system, object_store):
       self._file_system = file_system
       self._object_store = object_store
 
     def Create(self, populate_function, namespace, version=None):
       """Create a CompiledFileSystem that populates the cache by calling
       |populate_function| with (path, data), where |data| is the data that was
       fetched from |path|. The keys to the cache are put in the namespace
-      specified by |namespace|, and optionally adding |version|.  """
+      specified by |namespace|, and optionally adding |version|.
+      """
       return CompiledFileSystem(self._file_system,
                                 populate_function,
                                 self._object_store,
                                 namespace,
                                 version=version)
 
   def __init__(self,
                file_system,
                populate_function,
                object_store,
                namespace,
                version=None):
     self._file_system = file_system
     self._populate_function = populate_function
     self._object_store = object_store
     self._namespace = 'CompiledFileSystem.' + namespace
     if version is not None:
       self._namespace = '%s.%s' % (self._namespace, version)
 
   def _MakeKey(self, key):
-    return self._namespace + '.' + key
+    return '%s.%s' % (self._namespace, key)
 
   def _RecursiveList(self, files):
     all_files = files[:]
     dirs = {}
     for filename in files:
       if filename.endswith('/'):
         all_files.remove(filename)
         dirs.update(self._file_system.Read([filename]).Get())
     for dir_, files in dirs.iteritems():
       all_files.extend(self._RecursiveList([dir_ + f for f in files]))
     return all_files
 
   def GetFromFile(self, path, binary=False):
     """Calls |populate_function| on the contents of the file at |path|.  If
     |binary| is True then the file will be read as binary - but this will only
     apply for the first time the file is fetched; if already cached, |binary|
     will be ignored.
     """
     version = self._file_system.Stat(path).version
     cache_entry = self._object_store.Get(self._MakeKey(path),
                                          object_store.FILE_SYSTEM_CACHE,
                                          time=0).Get()
     if (cache_entry is not None) and (version == cache_entry.version):
       return cache_entry._cache_data
-    cache_data = self._populate_function(
-        path,
-        self._file_system.ReadSingle(path, binary=binary))
-    self._object_store.Set(self._MakeKey(path),
-                           _CacheEntry(cache_data, version),
-                           object_store.FILE_SYSTEM_CACHE,
-                           time=0)
-    return cache_data
+    try:
+      cache_data = self._populate_function(
+          path,
+          self._file_system.ReadSingle(path, binary=binary))
+      self._object_store.Set(self._MakeKey(path),
+                             _CacheEntry(cache_data, version),
+                             object_store.FILE_SYSTEM_CACHE,
+                             time=0)
+      return cache_data
+    except ValueError as e:
+      logging.error('Could not get data for the file at %s: %s' % (path, e))
+      return None
 
   def GetFromFileListing(self, path):
     """Calls |populate_function| on the listing of the files at |path|.
     Assumes that the path given is to a directory.
     """
     if not path.endswith('/'):
       path += '/'
     version = self._file_system.Stat(path).version
     cache_entry = self._object_store.Get(
         self._MakeKey(path),
         object_store.FILE_SYSTEM_CACHE_LISTING,
         time=0).Get()
     if (cache_entry is not None) and (version == cache_entry.version):
         return cache_entry._cache_data
     cache_data = self._populate_function(
         path,
         self._RecursiveList(
             [path + f for f in self._file_system.ReadSingle(path)]))
     self._object_store.Set(self._MakeKey(path),
                            _CacheEntry(cache_data, version),
                            object_store.FILE_SYSTEM_CACHE_LISTING,
                            time=0)
     return cache_data