diff options
Diffstat (limited to 'src/engine/SCons/Node/FS.py')
| -rw-r--r-- | src/engine/SCons/Node/FS.py | 283 |
1 files changed, 203 insertions, 80 deletions
diff --git a/src/engine/SCons/Node/FS.py b/src/engine/SCons/Node/FS.py index 2d1c8ea..9cd0607 100644 --- a/src/engine/SCons/Node/FS.py +++ b/src/engine/SCons/Node/FS.py @@ -1,89 +1,188 @@ -"""SCons.Node.FS +"""scons.Node.FS File system nodes. +This initializes a "default_fs" Node with an FS at the current directory +for its own purposes, and for use by scripts or modules looking for the +canonical default. + """ __revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__" - - import os import os.path -import SCons.Node +from SCons.Node import Node +from UserDict import UserDict +import sys + +class PathName: + """This is a string like object with limited capabilities (i.e., + cannot always be used interchangeably with strings). This class + is used by PathDict to manage case-insensitive path names. It preserves + the case of the string with which it was created, but on OS's with + case insensitive paths, it will hash equal to any case of the same + path when placed in a dictionary.""" + try: + convert_path = unicode + except NameError: + convert_path = str + def __init__(self, path_name=''): + self.data = PathName.convert_path(path_name) + self.norm_path = os.path.normcase(self.data) -Top = None -Root = {} + def __hash__(self): + return hash(self.norm_path) + def __cmp__(self, other): + return cmp(self.norm_path, + os.path.normcase(PathName.convert_path(other))) + def __rcmp__(self, other): + return cmp(os.path.normcase(PathName.convert_path(other)), + self.norm_path) + def __str__(self): + return str(self.data) + def __repr__(self): + return repr(self.data) +class PathDict(UserDict): + """This is a dictionary-like class meant to hold items keyed + by path name. The difference between this class and a normal + dictionary is that string or unicode keys will act differently + on OS's that have case-insensitive path names. Specifically + string or unicode keys of different case will be treated as + equal on the OS's. + All keys are implicitly converted to PathName objects before + insertion into the dictionary.""" -def init(path = None): - """Initialize the Node.FS subsystem. + def __init__(self, initdict = {}): + UserDict.__init__(self, initdict) + old_dict = self.data + self.data = {} + for key, val in old_dict.items(): + self.data[PathName(key)] = val - The supplied path is the top of the source tree, where we - expect to find the top-level build file. If no path is - supplied, the current directory is the default. - """ - global Top - if path == None: - path = os.getcwd() - Top = lookup(Dir, path, directory = None) - Top.path = '.' - -def lookup(fsclass, name, directory = Top): - """Look up a file system node for a path name. If the path - name is relative, it will be looked up relative to the - specified directory node, or to the top-level directory - if no node was specified. An initial '#' specifies that - the name will be looked up relative to the top-level directory, - regardless of the specified directory argument. Returns the - existing or newly-created node for the specified path name. - The node returned will be of the specified fsclass (Dir or - File). - """ - global Top - head, tail = os.path.split(name) - if not tail: - drive, path = os.path.splitdrive(head) - if not Root.has_key(drive): - Root[drive] = Dir(head, None) - Root[drive].abspath = head - Root[drive].path = head - return Root[drive] - if tail[0] == '#': - directory = Top - tail = tail[1:] - elif directory is None: - directory = Top - if head: - directory = lookup(Dir, head, directory) - try: - self = directory.entries[tail] - except AttributeError: - # There was no "entries" attribute on the directory, - # which essentially implies that it was a file. - # Return it as a more descriptive exception. - raise TypeError, directory - except KeyError: - # There was to entry for "tail," so create the new - # node and link it in to the existing structure. - self = fsclass(tail, directory) - self.name = tail - if self.path[0:2] == "./": - self.path = self.path[2:] - directory.entries[tail] = self - except: - raise - if self.__class__.__name__ != fsclass.__name__: - # Here, we found an existing node for this path, - # but it was the wrong type (a File when we were - # looking for a Dir, or vice versa). - raise TypeError, self - return self + def __setitem__(self, key, val): + self.data[PathName(key)] = val + + def __getitem__(self, key): + return self.data[PathName(key)] + + def __delitem__(self, key): + del(self.data[PathName(key)]) + + if not hasattr(UserDict, 'setdefault'): + def setdefault(self, key, value): + try: + return self.data[PathName(key)] + except KeyError: + self.data[PathName(key)] = value + return value + +class FS: + def __init__(self, path = None): + """Initialize the Node.FS subsystem. + + The supplied path is the top of the source tree, where we + expect to find the top-level build file. If no path is + supplied, the current directory is the default. + + The path argument must be a valid absolute path. + """ + if path == None: + path = os.getcwd() + self.Root = PathDict() + self.Top = self.__doLookup(Dir, path) + self.Top.path = '.' + + def __doLookup(self, fsclass, name, directory=None): + """This method differs from the File and Dir factory methods in + one important way: the meaning of the directory parameter. + In this method, if directory is None or not supplied, the supplied + name is expected to be an absolute path. If you try to look up a + relative path with directory=None, then an AssertionError will be + raised.""" + head, tail = os.path.split(os.path.normpath(name)) + if not tail: + # We have reached something that looks like a root + # of an absolute path. What we do here is a little + # weird. If we are on a UNIX system, everything is + # well and good, just return the root node. + # + # On DOS/Win32 things are strange, since a path + # starting with a slash is not technically an + # absolute path, but a path relative to the + # current drive. Therefore if we get a path like + # that, we will return the root Node of the + # directory parameter. If the directory parameter is + # None, raise an exception. + drive, tail = os.path.splitdrive(head) + if sys.platform is 'win32' and not drive: + if not directory: + raise OSError, 'No drive letter supplied for absolute path.' + return directory.root() + return self.Root.setdefault(drive, Dir(tail)) + if head: + # Recursively look up our parent directories. + directory = self.__doLookup(Dir, head, directory) + else: + # This path looks like a relative path. No leading slash or drive + # letter. Therefore, we will look up this path relative to the + # supplied top-level directory. + assert directory, "Tried to lookup a node by relative path with no top-level directory supplied." + ret = directory.entries.setdefault(tail, fsclass(tail, directory)) + if not isinstance(ret, fsclass): + raise TypeError, ret + return ret + + def __transformPath(self, name, directory): + """Take care of setting up the correct top-level directory, + usually in preparation for a call to doLookup(). + + If the path name is prepended with a '#', then it is unconditionally + interpreted as replative to the top-level directory of this FS. + + If directory is None, and name is a relative path, + then the same applies. + """ + if name[0] == '#': + directory = self.Top + name = os.path.join(os.path.normpath('./'), name[1:]) + elif not directory: + directory = self.Top + return (name, directory) + + def File(self, name, directory = None): + """Lookup or create a File node with the specified name. If + the name is a relative path (begins with ./, ../, or a file name), + then it is looked up relative to the supplied directory node, + or to the top level directory of the FS (supplied at construction + time) if no directory is supplied. + + This method will raise TypeError if a directory is found at the + specified path. + """ + name, directory = self.__transformPath(name, directory) + return self.__doLookup(File, name, directory) + + def Dir(self, name, directory = None): + """Lookup or create a Dir node with the specified name. If + the name is a relative path (begins with ./, ../, or a file name), + then it is looked up relative to the supplied directory node, + or to the top level directory of the FS (supplied at construction + time) if no directory is supplied. + + This method will raise TypeError if a normal file is found at the + specified path. + """ + name, directory = self.__transformPath(name, directory) + return self.__doLookup(Dir, name, directory) + + # XXX TODO? # Annotate with the creator @@ -94,20 +193,33 @@ def lookup(fsclass, name, directory = Top): # linked_targets # is_accessible -class Dir(SCons.Node.Node): +class Dir(Node): """A class for directories in a file system. """ - def __init__(self, name, directory): - self.entries = {} - self.entries['.'] = self - self.entries['..'] = directory - if not directory is None: - self.abspath = os.path.join(directory.abspath, name, '') - self.path = os.path.join(directory.path, name, '') + def __init__(self, name, directory = None): + self.entries = PathDict() + self.entries['.'] = self + + if directory: + self.entries['..'] = directory + self.abspath = os.path.join(directory.abspath, name, '') + if str(directory.path) == '.': + self.path = os.path.join(name, '') + else: + self.path = os.path.join(directory.path, name, '') + else: + self.abspath = self.path = name + self.entries['..'] = None def up(self): - return self.entries['..'] + return self.entries['..'] + + def root(self): + if not self.entries['..']: + return self + else: + return self.entries['..'].root() # XXX TODO? @@ -130,10 +242,21 @@ class Dir(SCons.Node.Node): # is_under # relpath -class File(SCons.Node.Node): +class File(Node): """A class for files in a file system. """ def __init__(self, name, directory): - self.abspath = os.path.join(directory.abspath, name) - self.path = os.path.join(directory.path, name) + self.abspath = os.path.join(directory.abspath, name) + if str(directory.path) == '.': + self.path = name + else: + self.path = os.path.join(directory.path, name) + self.parent = directory + + def root(self): + return self.parent.root() + + + +default_fs = FS() |