Docserver: Pull knowledge of host file systems into a single

chrome/common/extensions/docs/server2/patched_file_system.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.
 
 from copy import deepcopy
 
 from file_system import FileSystem, StatInfo, FileNotFoundError
 from future import Future
 
 class _AsyncFetchFuture(object):
@@ skipping 20 matching lines @@
         self._patched_file_system._GetDirectoryListingFromPatch(path))
     if original_listing is None:
       if len(added) == 0:
         raise FileNotFoundError('Directory %s not found in the patch.' % path)
       return added
     return list((set(original_listing) | set(added)) - set(deleted))
 
 class PatchedFileSystem(FileSystem):
   ''' Class to fetch resources with a patch applied.
   '''
-  def __init__(self, host_file_system, patcher):
-    self._host_file_system = host_file_system
+  def __init__(self, file_system, patcher):
+    self._file_system = file_system

[Jeffrey Yasskin, 2013/10/08 17:46:05]

I think I'd rather "base_file_system", since it's not the file system being
exposed by this class. I agree that "host" doesn't mean anything to me.

[not at google - send to devlin, 2013/10/08 18:27:37]

Good point. "Base" is a useful prefix. "Host" means nothing in this context.

     self._patcher = patcher
 
   def Read(self, paths, binary=False):
     patched_files = set()
     added, deleted, modified = self._patcher.GetPatchedFiles()
     if set(paths) & set(deleted):
       raise FileNotFoundError('Files are removed from the patch.')
     patched_files |= (set(added) | set(modified))
     dir_paths = set(path for path in paths if path.endswith('/'))
     file_paths = set(paths) - dir_paths
     patched_paths = file_paths & patched_files
     unpatched_paths = file_paths - patched_files
     return Future(delegate=_AsyncFetchFuture(
-        self._host_file_system.Read(unpatched_paths, binary),
-        self._patcher.Apply(patched_paths, self._host_file_system, binary),
+        self._file_system.Read(unpatched_paths, binary),
+        self._patcher.Apply(patched_paths, self._file_system, binary),
         self._TryReadDirectory(dir_paths, binary),
         self))
 
   ''' Given the list of patched files, it's not possible to determine whether
-  a directory to read exists in self._host_file_system. So try reading each one
+  a directory to read exists in self._file_system. So try reading each one
   and handle FileNotFoundError.
   '''
   def _TryReadDirectory(self, paths, binary):
     value = {}
     for path in paths:
       assert path.endswith('/')
       try:
-        value[path] = self._host_file_system.ReadSingle(path, binary)
+        value[path] = self._file_system.ReadSingle(path, binary)
       except FileNotFoundError:
         value[path] = None
     return value
 
   def _GetDirectoryListingFromPatch(self, path):
     assert path.endswith('/')
     def _FindChildrenInPath(files, path):
       result = []
       for f in files:
         if f.startswith(path):
@@ skipping 38 matching lines @@
     version = self._patcher.GetVersion()
     assert version is not None
     version = 'patched_%s' % version
 
     directory, filename = path.rsplit('/', 1)
     added, deleted, modified = self._GetDirectoryListingFromPatch(
         directory + '/')
 
     if len(added) > 0:
       # There are new files added. It's possible (if |directory| is new) that
-      # self._host_file_system.Stat will throw an exception.
+      # self._file_system.Stat will throw an exception.
       try:
         stat_info = self._PatchStat(
-            self._host_file_system.Stat(directory + '/'),
+            self._file_system.Stat(directory + '/'),
             version,
             added,
             deleted,
             modified)
       except FileNotFoundError:
         stat_info = StatInfo(
             version,
             dict((child, version) for child in added + modified))
     elif len(deleted) + len(modified) > 0:
       # No files were added.
-      stat_info = self._PatchStat(self._host_file_system.Stat(directory + '/'),
+      stat_info = self._PatchStat(self._file_system.Stat(directory + '/'),
                                   version,
                                   added,
                                   deleted,
                                   modified)
     else:
       # No changes are made in this directory.
-      return self._host_file_system.Stat(path)
+      return self._file_system.Stat(path)
 
     if stat_info.child_versions is not None:
       if filename:
         if filename in stat_info.child_versions:
           stat_info = StatInfo(stat_info.child_versions[filename])
         else:
           raise FileNotFoundError('%s was not in child versions' % filename)
     return stat_info
 
   def GetIdentity(self):
     return '%s(%s,%s)' % (self.__class__.__name__,
-                          self._host_file_system.GetIdentity(),
+                          self._file_system.GetIdentity(),
                           self._patcher.GetIdentity())