LIBLINKSUFFIX = 'bar')
def RDirs(pathlist, fs=env.fs):
- return fs.Rsearchall(pathlist,
- clazz=SCons.Node.FS.Dir,
- must_exist=0,
- cwd=fs.Dir('xx'))
+ return fs.Rfindalldirs(pathlist, fs.Dir('xx'))
env['RDirs'] = RDirs
flags = env.subst_list('$_LIBFLAGS', 1)[0]
result = self.__checkClass(e, fsclass)
return result
- def __transformPath(self, name, directory):
+ def _transformPath(self, name, directory):
"""Take care of setting up the correct top-level directory,
usually in preparation for a call to doLookup().
else:
if directory and not isinstance(directory, Dir):
directory = self.Dir(directory)
- name, directory = self.__transformPath(name, directory)
+ name, directory = self._transformPath(name, directory)
return self._doLookup(klass, name, directory, create)
def File(self, name, directory = None, create = 1):
d = self.Dir(d)
self.Top.addRepository(d)
- def do_Rsearch(self, path, dir, func, clazz=_classEntry):
- """Search for something in a Repository. Returns the first
- one found in the list, or None if there isn't one.
- __cacheable__
- """
- d, name = os.path.split(path)
- norm_name = _my_normcase(name)
- if d:
- dir = dir.Dir(d)
- try:
- node = dir.entries[norm_name]
- except KeyError:
- node = dir.node_on_disk(name, clazz)
- else:
- node = func(node)
- if node:
- dir = node.get_dir()
- if node:
- return node, dir
- fname = '.'
- while dir:
- for rep in dir.getRepositories():
- rdir = rep.Dir(fname)
- try:
- node = rdir.entries[norm_name]
- except KeyError:
- node = rdir.node_on_disk(name, clazz)
- else:
- node = func(node)
- if node:
- return node, dir
- fname = dir.name + os.sep + fname
- dir = dir.get_dir()
- return None, None
-
- def Rsearch(self, path, clazz=_classEntry, cwd=None):
- if isinstance(path, SCons.Node.Node):
- return path
- def func(node, clazz=clazz):
- if node.exists() and \
- (isinstance(node, clazz) or isinstance(node, Entry) \
- or not node.is_derived()):
- return node
- return None
- path, dir = self.__transformPath(path, cwd)
- return self.do_Rsearch(path, dir, func, clazz)[0]
-
- def Rsearchall(self, pathlist, must_exist=1, clazz=_classEntry, cwd=None):
- """Search for a list of somethings in the Repository list.
- __cacheable__
- """
- result = []
+ def Rfindalldirs(self, pathlist, cwd):
+ """__cacheable__"""
if SCons.Util.is_String(pathlist):
pathlist = string.split(pathlist, os.pathsep)
if not SCons.Util.is_List(pathlist):
pathlist = [pathlist]
-
- if must_exist:
- select = lambda x, clazz=clazz: isinstance(x, clazz) and x.exists()
- else:
- select = lambda x, clazz=clazz: isinstance(x, clazz)
-
+ result = []
for path in filter(None, pathlist):
if isinstance(path, SCons.Node.Node):
result.append(path)
continue
-
- path, dir = self.__transformPath(path, cwd)
- d, name = os.path.split(path)
- norm_name = _my_normcase(name)
- if d:
- dir = dir.Dir(d)
- try:
- node = dir.entries[norm_name]
- except KeyError:
- # If there's no Node on disk, we'll filter
- # out the returned None below.
- if must_exist:
- n = dir.node_on_disk(name, clazz)
- else:
- n = self._doLookup(clazz, name, dir)
- dir.srcdir_duplicate(name, clazz)
- result.append(n)
- else:
- if not must_exist or node.exists():
- result.append(node)
- fname = '.'
- while dir:
- for rep in dir.getRepositories():
- rdir = rep.Dir(fname)
- try:
- node = rdir.entries[norm_name]
- except KeyError:
- # If there's no Node on disk, we'll filter
- # out the returned None below.
- if must_exist:
- n = rdir.node_on_disk(name, clazz)
- else:
- n = self._doLookup(clazz, name, rdir)
- rdir.srcdir_duplicate(name, clazz)
- result.append(n)
- else:
- if (not must_exist or node.exists()) and \
- (isinstance(node, Dir) or not node.is_derived()):
- result.append(node)
- fname = dir.name + os.sep + fname
- dir = dir.get_dir()
-
- return filter(None, result)
+ path, dir = self._transformPath(path, cwd)
+ dir = dir.Dir(path)
+ result.extend(dir.get_all_rdirs())
+ return result
def CacheDir(self, path):
self.CachePath = path
srcdir.build_dirs.append(self)
def getRepositories(self):
- """Returns a list of repositories for this directory."""
+ """Returns a list of repositories for this directory.
+ __cacheable__"""
if self.srcdir and not self.duplicate:
- try:
- return self._srcreps
- except AttributeError:
- self._srcreps = self.fs.Rsearchall(self.srcdir.path,
- clazz=Dir,
- must_exist=0,
- cwd=self.fs.Top) \
- + self.repositories
- return self._srcreps
+ return self.srcdir.get_all_rdirs() + self.repositories
return self.repositories
+ def get_all_rdirs(self):
+ """__cacheable__"""
+ result = [self]
+ fname = '.'
+ dir = self
+ while dir:
+ for rep in dir.getRepositories():
+ result.append(rep.Dir(fname))
+ fname = dir.name + os.sep + fname
+ dir = dir.get_dir()
+ return result
+
def addRepository(self, dir):
- if not dir in self.repositories and dir != self:
+ if dir != self and not dir in self.repositories:
self.repositories.append(dir)
self.__clearRepositoryCache()
def rdir(self):
"__cacheable__"
- rdir = self
if not self.exists():
- n = self.fs.Rsearch(self.path, clazz=Dir, cwd=self.fs.Top)
- if n:
- rdir = n
- return rdir
+ norm_name = _my_normcase(self.name)
+ for dir in self.dir.get_all_rdirs():
+ try: node = dir.entries[norm_name]
+ except KeyError: node = dir.dir_on_disk(self.name)
+ if node and node.exists() and \
+ (isinstance(dir, Dir) or isinstance(dir, Entry)):
+ return node
+ return self
def sconsign(self):
"""Return the .sconsign file info for this directory,
return result
- def srcdir_duplicate(self, name, clazz):
+ def srcdir_duplicate(self, name):
for dir in self.srcdir_list():
if dir.entry_exists_on_disk(name):
- srcnode = self.fs._doLookup(clazz, name, dir)
+ srcnode = dir.File(name)
if self.duplicate:
- node = self.fs._doLookup(clazz, name, self)
+ node = self.File(name)
node.do_duplicate(srcnode)
return node
else:
def srcdir_find_file(self, filename):
"""__cacheable__"""
- fs = self.fs
- do_Rsearch = fs.do_Rsearch
-
def func(node):
if (isinstance(node, File) or isinstance(node, Entry)) and \
(node.is_derived() or node.is_pseudo_derived() or node.exists()):
return node
return None
- node, d = do_Rsearch(filename, self, func, File)
- if node:
- return node, d
+ norm_name = _my_normcase(filename)
- for dir in self.srcdir_list():
- node, d = do_Rsearch(filename, dir, func, File)
+ for rdir in self.get_all_rdirs():
+ try: node = rdir.entries[norm_name]
+ except KeyError: node = rdir.file_on_disk(filename)
+ else: node = func(node)
if node:
- return File(filename, self, fs), d
+ return node, self
+
+ for srcdir in self.srcdir_list():
+ for rdir in srcdir.get_all_rdirs():
+ try: node = rdir.entries[norm_name]
+ except KeyError: node = rdir.file_on_disk(filename)
+ else: node = func(node)
+ if node:
+ return File(filename, self, self.fs), srcdir
+
return None, None
- def node_on_disk(self, name, clazz):
+ def dir_on_disk(self, name):
+ if self.entry_exists_on_disk(name):
+ try: return self.Dir(name)
+ except TypeError: pass
+ return None
+
+ def file_on_disk(self, name):
if self.entry_exists_on_disk(name) or \
self.sccs_on_disk(name) or \
self.rcs_on_disk(name):
- try:
- return self.fs._doLookup(clazz, name, self)
- except TypeError:
- pass
- return self.srcdir_duplicate(name, clazz)
+ try: return self.File(name)
+ except TypeError: pass
+ return self.srcdir_duplicate(name)
class RootDir(Dir):
"""A class for the root directory of a file system.
def RDirs(self, pathlist):
"""Search for a list of directories in the Repository list."""
- return self.fs.Rsearchall(pathlist, clazz=Dir, must_exist=0,
- cwd=self.cwd)
+ return self.fs.Rfindalldirs(pathlist, self.cwd)
def _morph(self):
"""Turn a file system node into a File object. __cache_reset__"""
def rfile(self):
"__cacheable__"
- rfile = self
if not self.exists():
- n = self.fs.Rsearch(self.path, clazz=File,
- cwd=self.fs.Top)
- if n:
- rfile = n
- return rfile
+ norm_name = _my_normcase(self.name)
+ for dir in self.dir.get_all_rdirs():
+ try: node = dir.entries[norm_name]
+ except KeyError: node = dir.file_on_disk(self.name)
+ if node and node.exists() and \
+ (isinstance(node, File) or isinstance(node, Entry) \
+ or not node.is_derived()):
+ return node
+ return self
def rstr(self):
return str(self.rfile())
src0 = self.fs.Dir('src0')
self.fs.BuildDir(bld0, src0, duplicate=0)
- n = bld0.srcdir_duplicate('does_not_exist', SCons.Node.FS.File)
+ n = bld0.srcdir_duplicate('does_not_exist')
assert n is None, n
assert not os.path.exists(test.workpath('bld0', 'does_not_exist'))
- n = bld0.srcdir_duplicate('exists', SCons.Node.FS.File)
+ n = bld0.srcdir_duplicate('exists')
assert str(n) == os.path.normpath('src0/exists'), str(n)
assert not os.path.exists(test.workpath('bld0', 'exists'))
src1 = self.fs.Dir('src1')
self.fs.BuildDir(bld1, src1, duplicate=1)
- n = bld1.srcdir_duplicate('does_not_exist', SCons.Node.FS.File)
+ n = bld1.srcdir_duplicate('does_not_exist')
assert n is None, n
assert not os.path.exists(test.workpath('bld1', 'does_not_exist'))
- n = bld1.srcdir_duplicate('exists', SCons.Node.FS.File)
+ n = bld1.srcdir_duplicate('exists')
assert str(n) == os.path.normpath('bld1/exists'), str(n)
assert os.path.exists(test.workpath('bld1', 'exists'))
n = bld1.srcdir_find_file('on-disk-e2')
check(n, ['bld1/on-disk-e2', 'bld1'])
+ def test_dir_on_disk(self):
+ """Test the Dir.dir_on_disk() method"""
+ self.test.subdir('sub', ['sub', 'exists'])
+ self.test.write(['sub', 'file'], "self/file\n")
+ sub = self.fs.Dir('sub')
+
+ r = sub.dir_on_disk('does_not_exist')
+ assert not r, r
+
+ r = sub.dir_on_disk('exists')
+ assert r, r
+
+ r = sub.dir_on_disk('file')
+ assert not r, r
+
+ def test_file_on_disk(self):
+ """Test the Dir.file_on_disk() method"""
+ self.test.subdir('sub', ['sub', 'dir'])
+ self.test.write(['sub', 'exists'], "self/exists\n")
+ sub = self.fs.Dir('sub')
+
+ r = sub.file_on_disk('does_not_exist')
+ assert not r, r
+
+ r = sub.file_on_disk('exists')
+ assert r, r
+
+ r = sub.file_on_disk('dir')
+ assert not r, r
+
class EntryTestCase(unittest.TestCase):
def runTest(self):
"""Test methods specific to the Entry sub-class.
r = map(lambda x, np=os.path.normpath: np(str(x)), rep)
assert r == expect, r
+ def test_get_all_rdirs(self):
+ """Test the Dir.get_all_rdirs() method"""
+ self.fs.Repository('foo')
+ self.fs.Repository(os.path.join('foo', 'bar'))
+ self.fs.Repository('bar/foo')
+ self.fs.Repository('bar')
+
+ expect = [
+ '.',
+ self.rep1,
+ self.rep2,
+ self.rep3,
+ 'foo',
+ os.path.join('foo', 'bar'),
+ os.path.join('bar', 'foo'),
+ 'bar'
+ ]
+
+ rep = self.fs.Dir('#').get_all_rdirs()
+ r = map(lambda x, np=os.path.normpath: np(str(x)), rep)
+ assert r == expect, r
+
def test_rdir(self):
"""Test the Dir.rdir() method"""
return_true = lambda: 1
r = e2.rfile()
assert r is re2, r
- def test_Rsearches(self):
- """Test the Rsearch() methods"""
+ def test_Rfindalldirs(self):
+ """Test the Rfindalldirs() methods"""
fs = self.fs
test = self.test
- test.write([self.rep1, 'f2'], "")
- test.subdir([self.rep2, 'f3'])
- test.write([self.rep3, 'f3'], "")
-
- r = fs.Rsearch('f1')
- assert r is None, r
-
- r = fs.Rsearch('f2')
- assert r, r
-
- f3 = fs.File('f3')
- r = fs.Rsearch(f3)
- assert r is f3, r
-
- def test_Rsearchall(self):
- """Test the Rsearchall() methods"""
- fs = self.fs
- test = self.test
-
- list = fs.Rsearchall(fs.Dir('d1'))
- assert len(list) == 1, list
- assert list[0].path == 'd1', list[0].path
-
- list = fs.Rsearchall([fs.Dir('d1')])
- assert len(list) == 1, list
- assert list[0].path == 'd1', list[0].path
-
- list = fs.Rsearchall('d2')
- assert list == [], list
-
- list = fs.Rsearchall('#d2')
- assert list == [], list
-
- fs.File('d2').built() # Clear exists cache
- test.subdir(['work', 'd2'])
-
- list = fs.Rsearchall('d2')
- assert map(str, list) == ['d2'], list
-
- fs.File('../rep2/d2').built() # Clear exists cache
- test.subdir(['rep2', 'd2'])
-
- list = fs.Rsearchall('d2')
- assert map(str, list) == ['d2', test.workpath('rep2', 'd2')], list
-
- fs.File('../rep1/d2').built() # Clear exists cache
- test.subdir(['rep1', 'd2'])
-
- list = fs.Rsearchall('d2')
- assert map(str, list) == ['d2',
- test.workpath('rep1', 'd2'),
- test.workpath('rep2', 'd2')], list
-
- list = fs.Rsearchall(['d3', 'd4'])
- assert list == [], list
-
- fs.File('d3').built() # Clear exists cache
- test.subdir(['work', 'd3'])
-
- list = map(str, fs.Rsearchall(['d3', 'd4']))
- assert list == ['d3'], list
-
- fs.File('../rep3/d4').built() # Clear exists cache
- test.subdir(['rep3', 'd4'])
+ d1 = fs.Dir('d1')
+ d2 = fs.Dir('d2')
+ rep1_d1 = fs.Dir(test.workpath('rep1', 'd1'))
+ rep2_d1 = fs.Dir(test.workpath('rep2', 'd1'))
+ rep3_d1 = fs.Dir(test.workpath('rep3', 'd1'))
+ sub = fs.Dir('sub')
+ sub_d1 = sub.Dir('d1')
+ rep1_sub_d1 = fs.Dir(test.workpath('rep1', 'sub', 'd1'))
+ rep2_sub_d1 = fs.Dir(test.workpath('rep2', 'sub', 'd1'))
+ rep3_sub_d1 = fs.Dir(test.workpath('rep3', 'sub', 'd1'))
- list = map(str, fs.Rsearchall(['d3', 'd4']))
- assert list == ['d3', test.workpath('rep3', 'd4')], list
+ r = fs.Rfindalldirs(d1, fs.Top)
+ assert r == [d1], map(str, r)
- list = map(str, fs.Rsearchall(string.join(['d3', 'd4'], os.pathsep)))
- assert list == ['d3', test.workpath('rep3', 'd4')], list
+ r = fs.Rfindalldirs([d1, d2], fs.Top)
+ assert r == [d1, d2], map(str, r)
- work_d4 = fs.File(os.path.join('work', 'd4'))
+ r = fs.Rfindalldirs('d1', fs.Top)
+ assert r == [d1, rep1_d1, rep2_d1, rep3_d1], map(str, r)
- list = map(str, fs.Rsearchall(['d3', work_d4]))
- assert list == ['d3', str(work_d4)], list
+ r = fs.Rfindalldirs('#d1', fs.Top)
+ assert r == [d1, rep1_d1, rep2_d1, rep3_d1], map(str, r)
- list = fs.Rsearchall('')
- assert list == [], list
+ r = fs.Rfindalldirs('d1', sub)
+ assert r == [sub_d1, rep1_sub_d1, rep2_sub_d1, rep3_sub_d1], map(str, r)
- list = fs.Rsearchall([None])
- assert list == [], list
+ r = fs.Rfindalldirs('#d1', sub)
+ assert r == [d1, rep1_d1, rep2_d1, rep3_d1], map(str, r)
- list = fs.Rsearchall([''])
- assert list == [], list
+ r = fs.Rfindalldirs(['d1', d2], fs.Top)
+ assert r == [d1, rep1_d1, rep2_d1, rep3_d1, d2], map(str, r)
def test_rexists(self):
"""Test the Entry.rexists() method"""
return factory or self.fs.File
def Dir(self, filename):
- return self.fs.Dir(test.workpath(filename))
+ return self.fs.Dir(filename)
def File(self, filename):
- return self.fs.File(test.workpath(filename))
+ return self.fs.File(filename)
if os.path.normcase('foo') == os.path.normcase('FOO'):
my_normpath = os.path.normcase
env.fs.chdir(env.Dir(''))
path = s.path(env, dir)
deps2 = s(env.File('#fa.cpp'), env, path)
- headers1 = ['include/fa.h', 'include/fb.h']
- headers2 = ['subdir/include/fa.h', 'subdir/include/fb.h']
+ headers1 = map(test.workpath, ['include/fa.h', 'include/fb.h'])
+ headers2 = ['include/fa.h', 'include/fb.h']
deps_match(self, deps1, headers1)
deps_match(self, deps2, headers2)
return factory or self.fs.File
def Dir(self, filename):
- return self.fs.Dir(test.workpath(filename))
+ return self.fs.Dir(filename)
def File(self, filename):
- return self.fs.File(test.workpath(filename))
+ return self.fs.File(filename)
def deps_match(self, deps, headers):
scanned = map(os.path.normpath, map(str, deps))
env.fs.chdir(env.Dir(''))
path = s.path(env, dir)
deps2 = s(env.File('#fff4.f'), env, path)
- headers1 = ['include/f4.f']
- headers2 = ['subdir/include/f4.f']
+ headers1 = map(test.workpath, ['include/f4.f'])
+ headers2 = ['include/f4.f']
deps_match(self, deps1, headers1)
deps_match(self, deps2, headers2)
test.write('include/fff4.f', test.read('fff4.f'))
deps = s(env.File('#include/fff4.f'), env, path)
env.fs.chdir(env.Dir(''))
- deps_match(self, deps, ['include/f4.f'])
+ deps_match(self, deps, ['f4.f'])
test.unlink('include/fff4.f')
class FortranScannerTestCase13(unittest.TestCase):
return factory or self.fs.File
def Dir(self, filename):
- return self.fs.Dir(test.workpath(filename))
+ return self.fs.Dir(filename)
def File(self, filename):
- return self.fs.File(test.workpath(filename))
+ return self.fs.File(filename)
global my_normpath
my_normpath = os.path.normpath
env.fs.chdir(env.Dir(''))
path = s.path(env, dir)
deps2 = s(env.File('#t4.idl'), env, path)
- headers1 = ['include/fa.idl', 'include/fb.idl']
- headers2 = ['subdir/include/fa.idl', 'subdir/include/fb.idl']
+ headers1 = map(test.workpath, ['include/fa.idl', 'include/fb.idl'])
+ headers2 = ['include/fa.idl', 'include/fb.idl']
deps_match(self, deps1, headers1)
deps_match(self, deps2, headers2)
test.write('include/t4.idl', test.read('t4.idl'))
deps = s(env.File('#include/t4.idl'), env, path)
env.fs.chdir(env.Dir(''))
- deps_match(self, deps, [ 'include/fa.idl', 'include/fb.idl' ])
+ deps_match(self, deps, [ 'fa.idl', 'fb.idl' ])
test.unlink('include/t4.idl')
class IDLScannerTestCase10(unittest.TestCase):
self.search_result = search_result
def File(self, name):
return DummyNode(name)
- def Rsearchall(self, nodes, must_exist=0, clazz=None, cwd=dir):
- return self.search_result + nodes
+ def Rfindalldirs(self, pathlist, cwd):
+ return self.search_result + pathlist
class DummyEnvironment(UserDict.UserDict):
def __init__(self, dict=None, **kw):
return ()
path = env.subst_path(path, target=target, source=source)
- path_tuple = tuple(env.fs.Rsearchall(path,
- must_exist = 0, #kwq!
- clazz = SCons.Node.FS.Dir,
- cwd = dir))
+ path_tuple = tuple(env.fs.Rfindalldirs(path, dir))
return Binder(path_tuple)
class Base:
projects / scons.git / commitdiff