Move find_file() and find_files() from SCons.Util to SCons.Node.FS.

6 files changed, 75 insertions, 69 deletions

diff --git a/src/engine/SCons/Node/FS.py b/src/engine/SCons/Node/FS.py
index 3167005..f7e1f44 100644
--- a/src/engine/SCons/Node/FS.py
+++ b/src/engine/SCons/Node/FS.py
@@ -573,5 +573,56 @@ class File(Entry):
         else:
             self.__createDir()
 
+
 default_fs = FS()
 
+
+def find_file(filename, paths, node_factory = default_fs.File):
+    """
+    find_file(str, [Dir()]) -> [nodes]
+
+    filename - a filename to find
+    paths - a list of directory path *nodes* to search in
+
+    returns - the node created from the found file.
+
+    Find a node corresponding to either a derived file or a file
+    that exists already.
+
+    Only the first file found is returned, and none is returned
+    if no file is found.
+    """
+    retval = None
+    for dir in paths:
+        try:
+            node = node_factory(filename, dir)
+            # Return true of the node exists or is a derived node.
+            if node.builder or \
+               (isinstance(node, SCons.Node.FS.Entry) and node.cached_exists()):
+                retval = node
+                break
+        except TypeError:
+            # If we find a directory instead of a file, we don't care
+            pass
+
+    return retval
+
+def find_files(filenames, paths, node_factory = default_fs.File):
+    """
+    find_files([str], [Dir()]) -> [nodes]
+
+    filenames - a list of filenames to find
+    paths - a list of directory path *nodes* to search in
+
+    returns - the nodes created from the found files.
+
+    Finds nodes corresponding to either derived files or files
+    that exist already.
+
+    Only the first file found is returned for each filename,
+    and any files that aren't found are ignored.
+    """
+    nodes = map(lambda x, paths=paths, node_factory=node_factory:
+                       find_file(x, paths, node_factory),
+                filenames)
+    return filter(lambda x: x != None, nodes)
diff --git a/src/engine/SCons/Node/FSTests.py b/src/engine/SCons/Node/FSTests.py
index 94f81fd..b132b12 100644
--- a/src/engine/SCons/Node/FSTests.py
+++ b/src/engine/SCons/Node/FSTests.py
@@ -469,10 +469,29 @@ class FSTestCase(unittest.TestCase):
         #XXX test get_prevsiginfo()
 
 
+class find_fileTestCase(unittest.TestCase):
+    def runTest(self):
+        """Testing find_file function"""
+        test = TestCmd(workdir = '')
+        test.write('./foo', 'Some file\n')
+        fs = SCons.Node.FS.FS(test.workpath(""))
+        os.chdir(test.workpath("")) # FS doesn't like the cwd to be something other than it's root
+        node_derived = fs.File(test.workpath('bar/baz'))
+        node_derived.builder_set(1) # Any non-zero value.
+        paths = map(fs.Dir, ['.', './bar'])
+        nodes = [SCons.Node.FS.find_file('foo', paths, fs.File), 
+                 SCons.Node.FS.find_file('baz', paths, fs.File)] 
+        file_names = map(str, nodes)
+        file_names = map(os.path.normpath, file_names)
+        assert os.path.normpath('./foo') in file_names, file_names
+        assert os.path.normpath('./bar/baz') in file_names, file_names
+
+
 
 if __name__ == "__main__":
     suite = unittest.TestSuite()
     suite.addTest(FSTestCase())
     suite.addTest(BuildDirTestCase())
+    suite.addTest(find_fileTestCase())
     if not unittest.TextTestRunner().run(suite).wasSuccessful():
         sys.exit(1)
diff --git a/src/engine/SCons/Scanner/C.py b/src/engine/SCons/Scanner/C.py
index 6b5b6c6..7a9a4ba 100644
--- a/src/engine/SCons/Scanner/C.py
+++ b/src/engine/SCons/Scanner/C.py
@@ -114,10 +114,12 @@ def scan(node, env, args = [SCons.Node.FS.default_fs, ()]):
             
             for include in includes:
                 if include[0] == '"':
-                    n = SCons.Util.find_file(include[1], (source_dir,) + cpppath,
+                    n = SCons.Node.FS.find_file(include[1],
+                                                (source_dir,) + cpppath,
                                                 fs.File)
                 else:
-                    n = SCons.Util.find_file(include[1], cpppath + (source_dir,),
+                    n = SCons.Node.FS.find_file(include[1],
+                                                cpppath + (source_dir,),
                                                 fs.File)
 
                 if not n is None:
diff --git a/src/engine/SCons/Scanner/Prog.py b/src/engine/SCons/Scanner/Prog.py
index d77ca32..d8fb22c 100644
--- a/src/engine/SCons/Scanner/Prog.py
+++ b/src/engine/SCons/Scanner/Prog.py
@@ -66,4 +66,4 @@ def scan(node, env, node_factory):
         suffix=''
 
     libs = map(lambda x, s=suffix, p=prefix: p + x + s, libs)
-    return SCons.Util.find_files(libs, paths, node_factory)
+    return SCons.Node.FS.find_files(libs, paths, node_factory)
diff --git a/src/engine/SCons/Util.py b/src/engine/SCons/Util.py
index 2202abd..d7a0253 100644
--- a/src/engine/SCons/Util.py
+++ b/src/engine/SCons/Util.py
@@ -232,56 +232,6 @@ def scons_subst(strSubst, locals, globals, remove=None):
     cmd_list = scons_subst_list(strSubst, locals, globals, remove)
     return string.join(map(string.join, cmd_list), '\n')
 
-def find_files(filenames, paths,
-	       node_factory = SCons.Node.FS.default_fs.File):
-    """
-    find_files([str], [Dir()]) -> [nodes]
-
-    filenames - a list of filenames to find
-    paths - a list of directory path *nodes* to search in
-
-    returns - the nodes created from the found files.
-
-    Finds nodes corresponding to either derived files or files
-    that exist already.
-
-    Only the first file found is returned for each filename,
-    and any files that aren't found are ignored.
-    """
-    nodes = map(lambda x, paths=paths, node_factory=node_factory: find_file(x, paths, node_factory), filenames)
-    return filter(lambda x: x != None, nodes)
-
-def find_file(filename, paths,
-              node_factory = SCons.Node.FS.default_fs.File):
-    """
-    find_file(str, [Dir()]) -> [nodes]
-
-    filename - a filename to find
-    paths - a list of directory path *nodes* to search in
-
-    returns - the node created from the found file.
-
-    Find a node corresponding to either a derived file or a file
-    that exists already.
-
-    Only the first file found is returned, and none is returned
-    if no file is found.
-    """
-    retval = None
-    for dir in paths:
-        try:
-            node = node_factory(filename, dir)
-            # Return true of the node exists or is a derived node.
-            if node.builder or \
-               (isinstance(node, SCons.Node.FS.Entry) and node.cached_exists()):
-                retval = node
-                break
-        except TypeError:
-            # If we find a directory instead of a file, we don't care
-            pass
-
-    return retval
-
 class VarInterpolator:
     def __init__(self, dest, src, prefix, suffix):
         self.dest = dest
diff --git a/src/engine/SCons/UtilTests.py b/src/engine/SCons/UtilTests.py
index bcb93d0..aa58c8e 100644
--- a/src/engine/SCons/UtilTests.py
+++ b/src/engine/SCons/UtilTests.py
@@ -188,22 +188,6 @@ class UtilTestCase(unittest.TestCase):
         assert cmd_list[1][0] == 'after', cmd_list[1][0]
         assert cmd_list[0][2] == cvt('../foo/ack.cbefore'), cmd_list[0][2]
 
-    def test_find_file(self):
-        """Testing find_file function."""
-        test = TestCmd.TestCmd(workdir = '')
-        test.write('./foo', 'Some file\n')
-        fs = SCons.Node.FS.FS(test.workpath(""))
-        os.chdir(test.workpath("")) # FS doesn't like the cwd to be something other than it's root
-        node_derived = fs.File(test.workpath('bar/baz'))
-        node_derived.builder_set(1) # Any non-zero value.
-        paths = map(fs.Dir, ['.', './bar'])
-        nodes = [find_file('foo', paths, fs.File), 
-                 find_file('baz', paths, fs.File)] 
-        file_names = map(str, nodes)
-        file_names = map(os.path.normpath, file_names)
-        assert os.path.normpath('./foo') in file_names, file_names
-        assert os.path.normpath('./bar/baz') in file_names, file_names
-
     def test_autogenerate(dict):
         """Test autogenerating variables in a dictionary."""
         dict = {'LIBS'          : [ 'foo', 'bar', 'baz' ],