d75276eb3b35fb8ab9eeb794e3592363fef6d459
[WebKit.git] / Tools / Scripts / webkitpy / common / system / filesystem.py
1 # Copyright (C) 2010 Google Inc. All rights reserved.
2 #
3 # Redistribution and use in source and binary forms, with or without
4 # modification, are permitted provided that the following conditions are
5 # met:
6 #
7 #     * Redistributions of source code must retain the above copyright
8 # notice, this list of conditions and the following disclaimer.
9 #     * Redistributions in binary form must reproduce the above
10 # copyright notice, this list of conditions and the following disclaimer
11 # in the documentation and/or other materials provided with the
12 # distribution.
13 #     * Neither the name of Google Inc. nor the names of its
14 # contributors may be used to endorse or promote products derived from
15 # this software without specific prior written permission.
16 #
17 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
29 """Wrapper object for the file system / source tree."""
30
31 from __future__ import with_statement
32
33 import codecs
34 import errno
35 import exceptions
36 import glob
37 import os
38 import shutil
39 import tempfile
40 import time
41
42 class FileSystem(object):
43     """FileSystem interface for webkitpy.
44
45     Unless otherwise noted, all paths are allowed to be either absolute
46     or relative."""
47     def __init__(self):
48         self.sep = os.sep
49
50     def abspath(self, path):
51         return os.path.abspath(path)
52
53     def basename(self, path):
54         """Wraps os.path.basename()."""
55         return os.path.basename(path)
56
57     def copyfile(self, source, destination):
58         """Copies the contents of the file at the given path to the destination
59         path."""
60         shutil.copyfile(source, destination)
61
62     def dirname(self, path):
63         """Wraps os.path.dirname()."""
64         return os.path.dirname(path)
65
66     def exists(self, path):
67         """Return whether the path exists in the filesystem."""
68         return os.path.exists(path)
69
70     def files_under(self, path, dirs_to_skip=[], file_filter=None):
71         """Return the list of all files under the given path in topdown order.
72
73         Args:
74             dirs_to_skip: a list of directories to skip over during the
75                 traversal (e.g., .svn, resources, etc.)
76             file_filter: if not None, the filter will be invoked
77                 with the filesystem object and the dirname and basename of
78                 each file found. The file is included in the result if the
79                 callback returns True.
80         """
81         def filter_all(fs, dirpath, basename):
82             return True
83
84         file_filter = file_filter or filter_all
85         files = []
86         if self.isfile(path):
87             if file_filter(self, self.dirname(path), self.basename(path)):
88                 files.append(path)
89             return files
90
91         if self.basename(path) in dirs_to_skip:
92             return []
93
94         for (dirpath, dirnames, filenames) in os.walk(path):
95             for d in dirs_to_skip:
96                 if d in dirnames:
97                     dirnames.remove(d)
98
99             for filename in filenames:
100                 if file_filter(self, dirpath, filename):
101                     files.append(self.join(dirpath, filename))
102         return files
103
104     def glob(self, path):
105         """Wraps glob.glob()."""
106         return glob.glob(path)
107
108     def isabs(self, path):
109         """Return whether the path is an absolute path."""
110         return os.path.isabs(path)
111
112     def isfile(self, path):
113         """Return whether the path refers to a file."""
114         return os.path.isfile(path)
115
116     def isdir(self, path):
117         """Return whether the path refers to a directory."""
118         return os.path.isdir(path)
119
120     def join(self, *comps):
121         """Return the path formed by joining the components."""
122         return os.path.join(*comps)
123
124     def listdir(self, path):
125         """Return the contents of the directory pointed to by path."""
126         return os.listdir(path)
127
128     def mkdtemp(self, **kwargs):
129         """Create and return a uniquely named directory.
130
131         This is like tempfile.mkdtemp, but if used in a with statement
132         the directory will self-delete at the end of the block (if the
133         directory is empty; non-empty directories raise errors). The
134         directory can be safely deleted inside the block as well, if so
135         desired.
136
137         Note that the object returned is not a string and does not support all of the string
138         methods. If you need a string, coerce the object to a string and go from there.
139         """
140         class TemporaryDirectory(object):
141             def __init__(self, **kwargs):
142                 self._kwargs = kwargs
143                 self._directory_path = tempfile.mkdtemp(**self._kwargs)
144
145             def __str__(self):
146                 return self._directory_path
147
148             def __enter__(self):
149                 return self._directory_path
150
151             def __exit__(self, type, value, traceback):
152                 # Only self-delete if necessary.
153
154                 # FIXME: Should we delete non-empty directories?
155                 if os.path.exists(self._directory_path):
156                     os.rmdir(self._directory_path)
157
158         return TemporaryDirectory(**kwargs)
159
160     def maybe_make_directory(self, *path):
161         """Create the specified directory if it doesn't already exist."""
162         try:
163             os.makedirs(self.join(*path))
164         except OSError, e:
165             if e.errno != errno.EEXIST:
166                 raise
167
168     def move(self, src, dest):
169         shutil.move(src, dest)
170
171     def mtime(self, path):
172         return os.stat(path).st_mtime
173
174     def normpath(self, path):
175         """Wraps os.path.normpath()."""
176         return os.path.normpath(path)
177
178     def open_binary_tempfile(self, suffix):
179         """Create, open, and return a binary temp file. Returns a tuple of the file and the name."""
180         temp_fd, temp_name = tempfile.mkstemp(suffix)
181         f = os.fdopen(temp_fd, 'wb')
182         return f, temp_name
183
184     def open_text_file_for_writing(self, path, append=False):
185         """Returns a file handle suitable for writing to."""
186         mode = 'w'
187         if append:
188             mode = 'wa'
189         return codecs.open(path, mode, 'utf8')
190
191     def read_binary_file(self, path):
192         """Return the contents of the file at the given path as a byte string."""
193         with file(path, 'rb') as f:
194             return f.read()
195
196     def read_text_file(self, path):
197         """Return the contents of the file at the given path as a Unicode string.
198
199         The file is read assuming it is a UTF-8 encoded file with no BOM."""
200         with codecs.open(path, 'r', 'utf8') as f:
201             return f.read()
202
203     class _WindowsError(exceptions.OSError):
204         """Fake exception for Linux and Mac."""
205         pass
206
207     def remove(self, path, osremove=os.remove):
208         """On Windows, if a process was recently killed and it held on to a
209         file, the OS will hold on to the file for a short while.  This makes
210         attempts to delete the file fail.  To work around that, this method
211         will retry for a few seconds until Windows is done with the file."""
212         try:
213             exceptions.WindowsError
214         except AttributeError:
215             exceptions.WindowsError = FileSystem._WindowsError
216
217         retry_timeout_sec = 3.0
218         sleep_interval = 0.1
219         while True:
220             try:
221                 osremove(path)
222                 return True
223             except exceptions.WindowsError, e:
224                 time.sleep(sleep_interval)
225                 retry_timeout_sec -= sleep_interval
226                 if retry_timeout_sec < 0:
227                     raise e
228
229     def rmtree(self, path):
230         """Delete the directory rooted at path, empty or no."""
231         shutil.rmtree(path, ignore_errors=True)
232
233     def read_binary_file(self, path):
234         """Return the contents of the file at the given path as a byte string."""
235         with file(path, 'rb') as f:
236             return f.read()
237
238     def read_text_file(self, path):
239         """Return the contents of the file at the given path as a Unicode string.
240
241         The file is read assuming it is a UTF-8 encoded file with no BOM."""
242         with codecs.open(path, 'r', 'utf8') as f:
243             return f.read()
244
245     def splitext(self, path):
246         """Return (dirname + os.sep + basename, '.' + ext)"""
247         return os.path.splitext(path)
248
249     def write_binary_file(self, path, contents):
250         """Write the contents to the file at the given location."""
251         with file(path, 'wb') as f:
252             f.write(contents)
253
254     def write_text_file(self, path, contents):
255         """Write the contents to the file at the given location.
256
257         The file is written encoded as UTF-8 with no BOM."""
258         with codecs.open(path, 'w', 'utf8') as f:
259             f.write(contents)