Add file permissions to filesystem_mock

third_party/WebKit/Tools/Scripts/webkitpy/common/system/filesystem_mock.py

 # Copyright (C) 2009 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #    * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #    * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 21 matching lines @@
 import os
 import re
 
 from webkitpy.common.system import path
 
 
 class MockFileSystem(object):
     sep = '/'
     pardir = '..'
 
-    def __init__(self, files=None, dirs=None, cwd='/'):
+    def __init__(self, files=None, dirs=None, cwd='/', permissions=None):
         """Initializes a "mock" filesystem that can be used to completely
         stub out a filesystem.
 
         Args:
             files: a dict of filenames -> file contents. A file contents
                 value of None is used to indicate that the file should
                 not exist.
         """
         self.files = files or {}
+        self.permissions = permissions or {}
         self.written_files = {}
         self.last_tmpdir = None
         self.current_tmpno = 0
         self.cwd = cwd
         self.dirs = set(dirs or [])
         self.dirs.add(cwd)
         for f in self.files:
+            while f not in self.permissions:
+                self.permissions[f] = False
+        for f in self.files:

[qyearsley, 2016/06/15 21:54:25]

Depending on how is_executable is implemented, this may be unnecessary.

For example, if is_executable is:

    def is_executable(self, path):
        return self.permissions.get(path, False)

In this case, self.permissions is just a dict of paths to True for all paths
where the file is executable -- which behaves just the same as a set. In Python,
sets are also a basic type (like lists, tuples and dicts), so you could also do
this:

    def __init__(...):
        ...
        self.executable_files = set()
        ...

    def is_executable(path):
        return path in self.executable_files

             d = self.dirname(f)
             while not d in self.dirs:
                 self.dirs.add(d)
                 d = self.dirname(d)
-
     def clear_written_files(self):
         # This function can be used to track what is written between steps in a test.
         self.written_files = {}
 
     def _raise_not_found(self, path):
         raise IOError(errno.ENOENT, path, os.strerror(errno.ENOENT))
 
     def _split(self, path):
         # This is not quite a full implementation of os.path.split
         # http://docs.python.org/library/os.path.html#os.path.split
         if self.sep in path:
             return path.rsplit(self.sep, 1)
         return ('', path)
 
+    def chmod(self, file_path, mode):

[qyearsley, 2016/06/15 21:54:25]

In the MockFileSystem class, we still want to have is_exectuable and
make_executable (and not chmod), since the API of the mock class should look
just like that of the real class.

+        # To be used to fix http://crbug.com/574461

[qyearsley, 2016/06/15 21:54:25]

This kind of thing might be more useful to put in the CL description, to answer
the question: "why is this CL being uploaded now?" If this is committed and then
later the way code is used changes, then the comment would be out of sync with
reality. (This would be "comment rot").

+        self.permissions[file_path] = True
+        mode = mode

[qyearsley, 2016/06/15 21:54:25]

Note, this statement does nothing.

+
     def abspath(self, path):
         if os.path.isabs(path):
             return self.normpath(path)
         return self.abspath(self.join(self.cwd, path))
 
     def realpath(self, path):
         return self.abspath(path)
 
     def basename(self, path):
         return self._split(path)[1]
@@ skipping 402 matching lines @@
         return self.data.readline(length)
 
     def __iter__(self):
         return self.data.__iter__()
 
     def next(self):
         return self.data.next()
 
     def seek(self, offset, whence=os.SEEK_SET):
         self.data.seek(offset, whence)