Commits

Anonymous committed c1c51ff

Implement the Depends() method.

Comments (0)

Files changed (9)

 file_template =
 [
 	{
-		pattern = [ "src/scons/*__init__.py" ];
+		pattern = [ "src/engine/*__init__.py" ];
 		body = "${read_file ${source template/__init__.py abs}}";
 	},
 	{
-		pattern = [ "src/scons/*Tests.py" ];
+		pattern = [ "src/engine/*Tests.py" ];
 		body = "${read_file ${source template/Tests.py abs}}";
 	},
 	{
-		pattern = [ "src/scons/*.py" ];
+		pattern = [ "src/engine/*.py" ];
 		body = "${read_file ${source template/file.py abs}}";
 	},
 	{

src/engine/MANIFEST

 SCons/Sig/__init__.py
 SCons/Sig/MD5.py
 SCons/Sig/TimeStamp.py
+SCons/Util.py
 setup.py

src/engine/SCons/Environment.py

 import copy
 import re
 import types
+import SCons.Util
 
 
 
 
 
 _cv = re.compile(r'%([_a-zA-Z]\w*|{[_a-zA-Z]\w*})')
-_self = None
 
 
 
 	"""
 	self.Dictionary.update(copy.deepcopy(kw))
 
+    def	Depends(self, target, dependency):
+	"""Explicity specify that 'target's depend on 'dependency'."""
+	tlist = SCons.Util.scons_str2nodes(target)
+	dlist = SCons.Util.scons_str2nodes(dependency)
+	for t in tlist:
+	    t.add_dependency(dlist)
+
+	if len(tlist) == 1:
+	    tlist = tlist[0]
+	return tlist
+
     def subst(self, string):
 	"""Recursively interpolates construction variables from the
 	Environment into the specified string, returning the expanded
 	may be surrounded by curly braces to separate the name from
 	trailing characters.
 	"""
-	global _self
-	_self = self	# XXX NOT THREAD SAFE, BUT HOW ELSE DO WE DO THIS?
-	def repl(m):
+	def repl(m, _self=self):
 	    key = m.group(1)
 	    if key[:1] == '{' and key[-1:] == '}':
 		key = key[1:-1]

src/engine/SCons/EnvironmentTests.py

 	env2 = Environment(AAA = 'a', BBB = 'bbb', CCC = 'c')
 	assert env1 != env2
 
+    def test_Depends(self):
+	"""Test the explicit Depends method."""
+	env = Environment()
+	t = env.Depends(target='EnvironmentTest.py', dependency='Environment.py')
+	assert t.__class__.__name__ == 'File'
+	assert t.path == 'EnvironmentTest.py'
+	assert len(t.depends) == 1
+	d = t.depends[0]
+	assert d.__class__.__name__ == 'File'
+	assert d.path == 'Environment.py'
+
     def test_subst(self):
 	"""Test substituting construction variables within strings
 	

src/engine/SCons/Node/FS.py

     """
 
     def __init__(self, name, directory = None):
+        Node.__init__(self)
+
         self.entries = PathDict()
         self.entries['.'] = self
 
     """
 
     def __init__(self, name, directory):
+        Node.__init__(self)
+
         self.abspath = os.path.join(directory.abspath, name)
         if str(directory.path) == '.':
             self.path = name

src/engine/SCons/Node/FSTests.py

         built_it = None
         assert not built_it
         d1.path = "d"           # XXX FAKE SUBCLASS ATTRIBUTE
-        d1.sources = "d"        # XXX FAKE SUBCLASS ATTRIBUTE
+        d1.add_source(["d"])    # XXX FAKE SUBCLASS ATTRIBUTE
         d1.builder_set(Builder())
         d1.build()
         assert built_it
         built_it = None
         assert not built_it
         f1.path = "f"           # XXX FAKE SUBCLASS ATTRIBUTE
-        f1.sources = "f"        # XXX FAKE SUBCLASS ATTRIBUTE
+        f1.add_source(["f"])    # XXX FAKE SUBCLASS ATTRIBUTE
         f1.builder_set(Builder())
         f1.build()
         assert built_it

src/engine/SCons/Node/__init__.py

     """The base Node class, for entities that we know how to
     build, or use to build other Nodes.
     """
+
+    def __init__(self):
+	self.depends = []
+	self.sources = []
+	self.env = None
+
     def build(self):
 	self.builder.execute(target = self.path, source = self.sources)
 
     def get_signature(self):
         return self.signature
 
+    def add_dependency(self, depend):
+	"""Adds dependencies. The depends argument must be a list."""
+	self.depends.extend(depend)
+
+    def add_source(self, source):
+	"""Adds sources. The source argument must be a list."""
+	self.sources.extend(source)

src/engine/SCons/Util.py

+"""SCons.Util
+
+Various utility functions go here.
+
+"""
+
+__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
+
+
+import types
+import string
+import SCons.Node.FS
+
+def scons_str2nodes(arg, fs=SCons.Node.FS.default_fs):
+    """This function converts a string or list into a list of Node instances.
+    It follows the rules outlined in the SCons design document by accepting
+    any of the following inputs:
+	- A single string containing names separated by spaces. These will be
+	  split apart at the spaces.
+	- A single Node instance,
+	- A list containingg either strings or Node instances. Any strings
+	  in the list are not split at spaces.
+    In all cases, the function returns a list of Node instances."""
+
+    narg = arg
+    if type(arg) is types.StringType:
+	narg = string.split(arg)
+    elif type(arg) is not types.ListType:
+	narg = [arg]
+
+    nodes = []
+    for v in narg:
+	if type(v) is types.StringType:
+	    nodes.append(fs.File(v))
+	elif issubclass(v.__class__, SCons.Node.Node):
+	    nodes.append(v)
+	else:
+	    raise TypeError
+
+    return nodes

src/engine/SCons/UtilTests.py

+__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
+
+import sys
+import unittest
+import SCons.Node.FS
+from SCons.Util import scons_str2nodes
+
+
+class UtilTestCase(unittest.TestCase):
+    def test_str2nodes(self):
+	"""Test the str2nodes function."""
+	nodes = scons_str2nodes("Util.py UtilTests.py")
+	assert len(nodes) == 2
+	assert isinstance(nodes[0], SCons.Node.FS.File)
+	assert isinstance(nodes[1], SCons.Node.FS.File)
+	assert nodes[0].path == "Util.py"
+	assert nodes[1].path == "UtilTests.py"
+
+	nodes = scons_str2nodes("Util.py UtilTests.py", SCons.Node.FS.FS())
+	assert len(nodes) == 2
+	assert isinstance(nodes[0], SCons.Node.FS.File)
+	assert isinstance(nodes[1], SCons.Node.FS.File)
+	assert nodes[0].path == "Util.py"
+	assert nodes[1].path == "UtilTests.py"
+
+	nodes = scons_str2nodes(["Util.py", "UtilTests.py"])
+	assert len(nodes) == 2
+	assert isinstance(nodes[0], SCons.Node.FS.File)
+	assert isinstance(nodes[1], SCons.Node.FS.File)
+	assert nodes[0].path == "Util.py"
+	assert nodes[1].path == "UtilTests.py"
+
+	n1 = SCons.Node.FS.default_fs.File("Util.py")
+	nodes = scons_str2nodes([n1, "UtilTests.py"])
+	assert len(nodes) == 2
+	assert isinstance(nodes[0], SCons.Node.FS.File)
+	assert isinstance(nodes[1], SCons.Node.FS.File)
+	assert nodes[0].path == "Util.py"
+	assert nodes[1].path == "UtilTests.py"
+
+
+if __name__ == "__main__":
+    suite = unittest.makeSuite(UtilTestCase, 'test_')
+    if not unittest.TextTestRunner().run(suite).wasSuccessful():
+	sys.exit(1)