Docserver: Add FileSystem.Exists method and start sanity checking path format

chrome/common/extensions/docs/server2/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 posixpath
+
 from future import Gettable, Future
+from path_util import IsDirectory, SplitParent, ToDirectory
 
 
 class _BaseFileSystemException(Exception):
   def __init__(self, message):
     Exception.__init__(self, message)
 
   @classmethod
   def RaiseInFuture(cls, message):
     def boom(): raise cls(message)
     return Future(delegate=Gettable(boom))
@@ skipping 54 matching lines @@
     '''
     raise NotImplementedError(self.__class__)
 
   def ReadSingle(self, path):
     '''Reads a single file from the FileSystem. Returns a Future with the same
     rules as Read().
     '''
     read_single = self.Read([path])
     return Future(delegate=Gettable(lambda: read_single.Get()[path]))
 
+  def Exists(self, path):
+    '''Returns a Future to the existence of |path|; True if |path| exists,
+    False is not. This method will not throw a FileNotFoundError unlike

[Yoyo Zhou, 2014/02/04 00:27:20]

s/is/if/

[not at google - send to devlin, 2014/02/04 16:14:40]

Done.

+    the Read* methods, however it may still throw a FileSystemError.
+
+    There are several ways to implement this method via the interface but this
+    method exists to do so in a canonical and most efficient way for caching.
+    '''
+    if path in ('', '/'):
+      # There is always a root directory.
+      return Future(value=True)
+
+    parent, base = SplitParent(path)
+    list_future = self.ReadSingle(ToDirectory(parent))
+    def resolve():
+      try:
+        return base in list_future.Get()
+      except FileNotFoundError:
+        return False
+    return Future(delegate=Gettable(resolve))
+
   def Refresh(self):
     '''Asynchronously refreshes the content of the FileSystem, returning a
     future to its completion.
     '''
     raise NotImplementedError(self.__class__)
 
   # TODO(cduvall): Allow Stat to take a list of paths like Read.
   def Stat(self, path):
     '''Returns a |StatInfo| object containing the version of |path|. If |path|
     is a directory, |StatInfo| will have the versions of all the children of
     the directory in |StatInfo.child_versions|.
 
     If the path cannot be found, raises a FileNotFoundError.
     For any other failure, raises a FileSystemError.
     '''
     raise NotImplementedError(self.__class__)
 
   def GetIdentity(self):
     '''The identity of the file system, exposed for caching classes to
     namespace their caches. this will usually depend on the configuration of
     that file system - e.g. a LocalFileSystem with a base path of /var is
     different to that of a SubversionFileSystem with a base path of /bar, is
     different to a LocalFileSystem with a base path of /usr.
     '''
     raise NotImplementedError(self.__class__)
 
   def Walk(self, root):
     '''Recursively walk the directories in a file system, starting with root.
-    Emulates os.walk from the standard os module.
 
-    If the root cannot be found, raises a FileNotFoundError.
+    Behaviour is very similar to os.walk from the standard os module, yielding

[Yoyo Zhou, 2014/02/04 00:27:20]

nice spelling =)

[not at google - send to devlin, 2014/02/04 16:14:40]

are you referring to my favourite way of spelling behaviour?

+    (base, files, dirs) recursively, where |base| is the base path of |files|

[Yoyo Zhou, 2014/02/04 00:30:03]

Seems like this is actually base, dirs, files.

[not at google - send to devlin, 2014/02/04 16:14:40]

yes. Thank you.

+    and |dirs| is relative to |root|, and |files| and |dirs| are the files and

[Yoyo Zhou, 2014/02/04 00:27:20]

delete 'is'

[not at google - send to devlin, 2014/02/04 16:14:40]

Done.

+    dirs in |base| respectively.

[Yoyo Zhou, 2014/02/04 00:27:20]

Clarify that files and dirs are lists.

[not at google - send to devlin, 2014/02/04 16:14:40]

Done.

+
+    Note that directories will always end with a '/', files never will.
+
+    If |root| cannot be found, raises a FileNotFoundError.
     For any other failure, raises a FileSystemError.
     '''
-    basepath = root.rstrip('/') + '/'
+    root = ToDirectory(root)  # TODO(kalman): assert IsDirectory(root)
+    basepath = root
 
     def walk(root):
-      if not root.endswith('/'):
-        root += '/'
-
+      assert IsDirectory(root), root
       dirs, files = [], []
 
       for f in self.ReadSingle(root).Get():
         if f.endswith('/'):
           dirs.append(f)
         else:
           files.append(f)
 
       yield root[len(basepath):].rstrip('/'), dirs, files
 
       for d in dirs:
         for walkinfo in walk(root + d):
           yield walkinfo
 
     for walkinfo in walk(root):
       yield walkinfo
 
   def __repr__(self):
     return '<%s>' % type(self).__name__
 
   def __str__(self):
     return repr(self)