If the action argument is not one of the above,
None is returned.
+.SS Miscellaneous Action Functions
+
+.B scons
+supplies a number of functions
+that arrange for various common
+file and directory manipulations
+to be performed.
+These are similar in concept to "tasks" in the
+Ant build tool,
+although the implementation is slightly different.
+These functions do not actually
+perform the specified action
+at the time the function is called,
+but instead return an Action object
+that can be executed at the
+appropriate time.
+(In Object-Oriented terminology,
+these are actually
+Action
+.I Factory
+functions
+that return Action objects.)
+
+In practice,
+there are two natural ways
+that these
+Action Functions
+are intended to be used.
+
+First,
+if you need
+to perform the action
+at the time the SConscript
+file is being read,
+you can use the
+.B Execute
+global function to do so:
+.ES
+Execute(Touch('file'))
+.EE
+
+Second,
+you can use these functions
+to supply Actions in a list
+for use by the
+.B Command
+method.
+This can allow you to
+perform more complicated
+sequences of file manipulation
+without relying
+on platform-specific
+external commands:
+that
+.ES
+env = Environment(TMPBUILD = '/tmp/builddir')
+env.Command('foo.out', 'foo.in',
+ [Mkdir('$TMPBUILD'),
+ Copy('${SOURCE.dir}', '$TMPBUILD')
+ "cd $TMPBUILD && make",
+ Delete('$TMPBUILD')])
+.EE
+
+.TP
+.RI Chmod( dest ", " mode )
+Returns an Action object that
+changes the permissions on the specified
+.I dest
+file or directory to the specified
+.IR mode .
+Examples:
+
+.ES
+Execute(Chmod('file', 0755))
+
+env.Command('foo.out', 'foo.in',
+ [Copy('$TARGET', '$SOURCE'),
+ Chmod('$TARGET', 0755)])
+.EE
+
+.TP
+.RI Copy( dest ", " src )
+Returns an Action object
+that will copy the
+.I src
+source file or directory to the
+.I dest
+destination file or directory.
+Examples:
+
+.ES
+Execute(Copy('foo.output', 'foo.input'))
+
+env.Command('bar.out', 'bar.in',
+ Copy('$TARGET', '$SOURCE'))
+.EE
+
+.TP
+.RI Delete( entry )
+Returns an Action that
+deletes the specified
+.IR entry ,
+which may be a file or a directory tree.
+If a directory is specified,
+the entire directory tree
+will be removed.
+Examples:
+
+.ES
+Execute(Delete('/tmp/buildroot'))
+
+env.Command('foo.out', 'foo.in',
+ [Delete('${TARGET.dir}'),
+ MyBuildAction])
+.EE
+
+.TP
+.RI Mkdir( dir )
+Returns an Action
+that creates the specified
+directory
+.I dir .
+Examples:
+
+.ES
+Execute(Mkdir('/tmp/outputdir'))
+
+env.Command('foo.out', 'foo.in',
+ [Mkdir('/tmp/builddir',
+ Copy('$SOURCE', '/tmp/builddir')
+ "cd /tmp/builddir && ])
+
+.EE
+
+.TP
+.RI Move( dest ", " src )
+Returns an Action
+that moves the specified
+.I src
+file or directory to
+the specified
+.I dest
+file or directory.
+Examples:
+
+.ES
+Execute(Move('file.destination', 'file.source'))
+
+env.Command('output_file', 'input_file',
+ [MyBuildAction,
+ Move('$TARGET', 'file_created_by_MyBuildAction')])
+.EE
+
+.TP
+.RI Touch( file )
+Returns an Action
+that updates the modification time
+on the specified
+.IR file .
+Examples:
+
+.ES
+Execute(Touch('file_to_be_touched'))
+
+env.Command('marker', 'input_file',
+ [MyBuildAction,
+ Touch('$TARGET')])
+.EE
+
.SS Variable Substitution
Before executing a command,
build_str + \
term
- def up_to_date(self, options = None, arguments = None, **kw):
+ def up_to_date(self, options = None, arguments = None, read_str = "", **kw):
s = ""
for arg in string.split(arguments):
s = s + "scons: `%s' is up to date.\n" % arg
if options:
arguments = options + " " + arguments
kw['arguments'] = arguments
- kw['stdout'] = self.wrap_stdout(build_str = s)
+ kw['stdout'] = self.wrap_stdout(read_str = read_str, build_str = s)
apply(self.run, [], kw)
def not_up_to_date(self, options = None, arguments = None, **kw):
Environments are the same object, not if their underlying dictionaries
are equivalent.
+ - Add a --debug=explain option that reports the reason(s) why SCons
+ thinks it must rebuild something.
+
+ - Add support for functions that return platform-independent Actions
+ to Chmod(), Copy(), Delete(), Mkdir(), Move() and Touch() files
+ and/or directories. Like any other Actions, the returned Action
+ object may be executed directly using the Execute() global function
+ or env.Execute() environment method, or may be used as a Builder
+ action or in an env.Command() action list.
+
From Gary Oberbrunner:
- Add a --debug=presub option to print actions prior to substitution.
pre-substitution representations, and *then* execute an action
without worrying about the specific Actions involved.
+There is a related independent ActionCaller class that looks like a
+regular Action, and which serves as a wrapper for arbitrary functions
+that we want to let the user specify the arguments to now, but actually
+execute later (when an out-of-date check determines that it's needed to
+be executed, for example). Objects of this class are returned by an
+ActionFactory class that provides a __call__() method as a convenient
+way for wrapping up the functions.
+
"""
#
"""
try:
# "self.execfunction" is a function.
- code = self.execfunction.func_code.co_code
+ contents = str(self.execfunction.func_code.co_code)
except AttributeError:
# "self.execfunction" is a callable object.
- code = self.execfunction.__call__.im_func.func_code.co_code
- return str(code) + env.subst(string.join(map(lambda v: '${'+v+'}',
+ try:
+ contents = str(self.execfunction.__call__.im_func.func_code.co_code)
+ except AttributeError:
+ try:
+ # See if execfunction will do the heavy lifting for us.
+ gc = self.execfunction.get_contents
+ except AttributeError:
+ # This is weird, just do the best we can.
+ contents = str(self.execfunction)
+ else:
+ contents = gc(target, source, env, dict)
+ return contents + env.subst(string.join(map(lambda v: '${'+v+'}',
self.varlist)))
class ListAction(ActionBase):
x.get_contents(t, s, e, d),
self.list),
"")
+
+class ActionCaller:
+ """A class for delaying calling an Action function with specific
+ (positional and keyword) arguments until the Action is actually
+ executed.
+
+ This class looks to the rest of the world like a normal Action object,
+ but what it's really doing is hanging on to the arguments until we
+ have a target, source and env to use for the expansion.
+ """
+ def __init__(self, parent, args, kw):
+ self.parent = parent
+ self.args = args
+ self.kw = kw
+ def get_contents(self, target, source, env, dict=None):
+ actfunc = self.parent.actfunc
+ try:
+ # "self.actfunc" is a function.
+ contents = str(actfunc.func_code.co_code)
+ except AttributeError:
+ # "self.actfunc" is a callable object.
+ try:
+ contents = str(actfunc.__call__.im_func.func_code.co_code)
+ except AttributeError:
+ # No __call__() method, so it might be a builtin
+ # or something like that. Do the best we can.
+ contents = str(actfunc)
+ return contents
+ def subst_args(self, target, source, env):
+ return map(lambda x, e=env, t=target, s=source:
+ e.subst(x, 0, t, s),
+ self.args)
+ def subst_kw(self, target, source, env):
+ kw = {}
+ for key in self.kw.keys():
+ kw[key] = env.subst(self.kw[key], 0, target, source)
+ return kw
+ def __call__(self, target, source, env):
+ args = self.subst_args(target, source, env)
+ kw = self.subst_kw(target, source, env)
+ return apply(self.parent.actfunc, args, kw)
+ def strfunction(self, target, source, env):
+ args = self.subst_args(target, source, env)
+ kw = self.subst_kw(target, source, env)
+ return apply(self.parent.strfunc, args, kw)
+
+class ActionFactory:
+ """A factory class that will wrap up an arbitrary function
+ as an SCons-executable Action object.
+
+ The real heavy lifting here is done by the ActionCaller class.
+ We just collect the (positional and keyword) arguments that we're
+ called with and give them to the ActionCaller object we create,
+ so it can hang onto them until it needs them.
+ """
+ def __init__(self, actfunc, strfunc):
+ self.actfunc = actfunc
+ self.strfunc = strfunc
+ def __call__(self, *args, **kw):
+ ac = ActionCaller(self, args, kw)
+ return Action(ac, strfunction=ac.strfunction)
c = a.get_contents(target=[], source=[], env=Environment(XYZ = 'foo'))
assert c == "\177\036\000\177\037\000d\000\000Sfoo", repr(c)
+ class Foo:
+ def get_contents(self, target, source, env, dict=None):
+ return 'xyzzy'
+ a = SCons.Action.FunctionAction(Foo())
+ c = a.get_contents(target=[], source=[], env=Environment())
+ assert c == 'xyzzy', repr(c)
+
class ListActionTestCase(unittest.TestCase):
def test___init__(self):
c = a.get_contents(target=[], source=[], env=env, dict={})
assert c == "This is a test", c
+class ActionCallerTestCase(unittest.TestCase):
+ def test___init__(self):
+ """Test creation of an ActionCaller"""
+ ac = SCons.Action.ActionCaller(1, [2, 3], {'FOO' : 4, 'BAR' : 5})
+ assert ac.parent == 1, ac.parent
+ assert ac.args == [2, 3], ac.args
+ assert ac.kw == {'FOO' : 4, 'BAR' : 5}, ac.kw
+
+ def test_get_contents(self):
+ """Test fetching the contents of an ActionCaller"""
+ def actfunc():
+ pass
+ def strfunc():
+ pass
+
+ af = SCons.Action.ActionFactory(actfunc, strfunc)
+ ac = SCons.Action.ActionCaller(af, [], {})
+ c = ac.get_contents([], [], Environment())
+ assert c == "\177\005\005\177\006\005d\000\000S", repr(c)
+
+ class ActFunc:
+ def __call__(self):
+ pass
+
+ af = SCons.Action.ActionFactory(ActFunc(), strfunc)
+ ac = SCons.Action.ActionCaller(af, [], {})
+ c = ac.get_contents([], [], Environment())
+ assert c == "\177\020\005\177\021\005d\000\000S", repr(c)
+
+ af = SCons.Action.ActionFactory(str, strfunc)
+ ac = SCons.Action.ActionCaller(af, [], {})
+ c = ac.get_contents([], [], Environment())
+ assert c == "<built-in function str>" or \
+ c == "<type 'str'>", repr(c)
+
+ def test___call__(self):
+ """Test calling an ActionCaller"""
+ actfunc_args = []
+ def actfunc(a1, a2, a3, args=actfunc_args):
+ args.extend([a1, a2, a3])
+ def strfunc(a1, a2, a3):
+ pass
+
+ af = SCons.Action.ActionFactory(actfunc, strfunc)
+ ac = SCons.Action.ActionCaller(af, [1, '$FOO', 3], {})
+ ac([], [], Environment(FOO = 2))
+ assert actfunc_args == [1, '2', 3], actfunc_args
+
+ del actfunc_args[:]
+ ac = SCons.Action.ActionCaller(af, [], {'a3' : 6, 'a2' : '$BAR', 'a1' : 4})
+ ac([], [], Environment(BAR = 5))
+ assert actfunc_args == [4, '5', 6], actfunc_args
+
+ def test_strfunction(self):
+ """Test calling the ActionCaller strfunction() method"""
+ strfunc_args = []
+ def actfunc(a1, a2, a3):
+ pass
+ def strfunc(a1, a2, a3, args=strfunc_args):
+ args.extend([a1, a2, a3])
+
+ af = SCons.Action.ActionFactory(actfunc, strfunc)
+ ac = SCons.Action.ActionCaller(af, [1, '$FOO', 3], {})
+ ac.strfunction([], [], Environment(FOO = 2))
+ assert strfunc_args == [1, '2', 3], strfunc_args
+
+ del strfunc_args[:]
+ ac = SCons.Action.ActionCaller(af, [], {'a3' : 6, 'a2' : '$BAR', 'a1' : 4})
+ ac.strfunction([], [], Environment(BAR = 5))
+ assert strfunc_args == [4, '5', 6], strfunc_args
+
+class ActionFactoryTestCase(unittest.TestCase):
+ def test___init__(self):
+ """Test creation of an ActionFactory"""
+ def actfunc():
+ pass
+ def strfunc():
+ pass
+ ac = SCons.Action.ActionFactory(actfunc, strfunc)
+ assert ac.actfunc is actfunc, ac.actfunc
+ assert ac.strfunc is strfunc, ac.strfunc
+
+ def test___call__(self):
+ """Test calling whatever's returned from an ActionFactory"""
+ actfunc_args = []
+ strfunc_args = []
+ def actfunc(a1, a2, a3, args=actfunc_args):
+ args.extend([a1, a2, a3])
+ def strfunc(a1, a2, a3, args=strfunc_args):
+ args.extend([a1, a2, a3])
+ af = SCons.Action.ActionFactory(actfunc, strfunc)
+ af(3, 6, 9)([], [], Environment())
+ assert actfunc_args == [3, 6, 9], actfunc_args
+ assert strfunc_args == [3, 6, 9], strfunc_args
+
if __name__ == "__main__":
suite = unittest.TestSuite()
CommandGeneratorActionTestCase,
FunctionActionTestCase,
ListActionTestCase,
- LazyActionTestCase ]
+ LazyActionTestCase,
+ ActionCallerTestCase,
+ ActionFactoryTestCase ]
for tclass in tclasses:
names = unittest.getTestCaseNames(tclass, 'test_')
suite.addTests(map(tclass, names))
import shutil
import stat
import string
+import time
import types
import SCons.Action
prefix = '$PDFPREFIX',
suffix = '$PDFSUFFIX')
+# Common tasks that we allow users to perform in platform-independent
+# ways by creating ActionFactory instances.
+ActionFactory = SCons.Action.ActionFactory
+
+Chmod = ActionFactory(os.chmod,
+ lambda dest, mode: 'Chmod("%s", 0%o)' % (dest, mode))
+
+def Copy(dest, src):
+ def _copy_func(target, source, env, dest=dest, src=src):
+ dest = str(env.arg2nodes(dest, env.fs.Entry)[0])
+ src = str(env.arg2nodes(src, env.fs.Entry)[0])
+ shutil.copytree(src, dest, 1)
+ def _copy_str(target, source, env, dest=dest, src=src):
+ dest = str(env.arg2nodes(dest, env.fs.Entry)[0])
+ src = str(env.arg2nodes(src, env.fs.Entry)[0])
+ return 'Copy("%s", "%s")' % (dest, src)
+ return SCons.Action.Action(_copy_func, strfunction=_copy_str)
+
+def copy_func(dest, src):
+ if os.path.isfile(src):
+ return shutil.copy(src, dest)
+ else:
+ return shutil.copytree(src, dest, 1)
+
+Copy = ActionFactory(copy_func,
+ lambda dest, src: 'Copy("%s", "%s")' % (dest, src))
+
+def delete_func(entry):
+ if os.path.isfile(entry):
+ return os.unlink(entry)
+ else:
+ return shutil.rmtree(entry, 1)
+
+Delete = ActionFactory(delete_func,
+ lambda entry: 'Delete("%s")' % entry)
+
+Mkdir = ActionFactory(os.makedirs,
+ lambda dir: 'Mkdir("%s")' % dir)
+
+Move = ActionFactory(lambda dest, src: os.rename(src, dest),
+ lambda dest, src: 'Move("%s", "%s")' % (dest, src))
+
+def touch_func(file):
+ mtime = int(time.time())
+ if os.path.exists(file):
+ atime = os.path.getatime(file)
+ else:
+ open(file, 'w')
+ atime = mtime
+ return os.utime(file, (atime, mtime))
+
+Touch = ActionFactory(touch_func,
+ lambda file: 'Touch("%s")' % file)
+
+# Internal utility functions
def copyFunc(dest, source, env):
"""Install a source file into a destination by copying it (and its
permission/mode bits)."""
'Tool' : SCons.Tool.Tool,
'WhereIs' : SCons.Util.WhereIs,
+ # Action factories.
+ 'Chmod' : SCons.Defaults.Chmod,
+ 'Copy' : SCons.Defaults.Copy,
+ 'Delete' : SCons.Defaults.Delete,
+ 'Mkdir' : SCons.Defaults.Mkdir,
+ 'Move' : SCons.Defaults.Move,
+ 'Touch' : SCons.Defaults.Touch,
+
# Other variables we provide.
'ARGUMENTS' : Arguments,
'BUILD_TARGETS' : BuildTargets,
--- /dev/null
+#!/usr/bin/env python
+#
+# __COPYRIGHT__
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
+
+"""
+Verify that the Chmod() Action works.
+"""
+
+import os
+import os.path
+import stat
+
+import TestSCons
+
+test = TestSCons.TestSCons()
+
+test.write('SConstruct', """
+Execute(Chmod('f1', 0777))
+Execute(Chmod('d2', 0777))
+def cat(env, source, target):
+ target = str(target[0])
+ source = map(str, source)
+ f = open(target, "wb")
+ for src in source:
+ f.write(open(src, "rb").read())
+ f.close()
+Cat = Action(cat)
+env = Environment()
+env.Command('bar.out', 'bar.in', [Cat,
+ Chmod("f3", 0755),
+ Chmod("d4", 0755)])
+env = Environment(FILE = 'f5')
+env.Command('f6.out', 'f6.in', [Chmod('$FILE', 0775), Cat])
+env.Command('f7.out', 'f7.in', [Cat,
+ Chmod('Chmod-$SOURCE', 0775),
+ Chmod('${TARGET}-Chmod', 0775)])
+""")
+
+test.write('f1', "f1\n")
+test.subdir('d2')
+test.write(['d2', 'file'], "d2/file\n")
+test.write('bar.in', "bar.in\n")
+test.write('f3', "f3\n")
+test.subdir('d4')
+test.write(['d4', 'file'], "d4/file\n")
+test.write('f5', "f5\n")
+test.write('f6.in', "f6.in\n")
+test.write('f7.in', "f7.in\n")
+test.write('Chmod-f7.in', "Chmod-f7.in\n")
+test.write('f7.out-Chmod', "f7.out-Chmod\n")
+
+os.chmod(test.workpath('f1'), 0700)
+os.chmod(test.workpath('d2'), 0700)
+os.chmod(test.workpath('f3'), 0700)
+os.chmod(test.workpath('d4'), 0700)
+os.chmod(test.workpath('f5'), 0700)
+os.chmod(test.workpath('Chmod-f7.in'), 0700)
+os.chmod(test.workpath('f7.out-Chmod'), 0700)
+
+expect = test.wrap_stdout(read_str = 'Chmod("f1", 0777)\nChmod("d2", 0777)\n',
+ build_str = """\
+cat("bar.out", "bar.in")
+Chmod("f3", 0755)
+Chmod("d4", 0755)
+Chmod("f5", 0775)
+cat("f6.out", "f6.in")
+cat("f7.out", "f7.in")
+Chmod("Chmod-f7.in", 0775)
+Chmod("f7.out-Chmod", 0775)
+""")
+test.run(options = '-n', arguments = '.', stdout = expect)
+
+s = stat.S_IMODE(os.stat(test.workpath('f1'))[stat.ST_MODE])
+test.fail_test(s != 0700)
+s = stat.S_IMODE(os.stat(test.workpath('d2'))[stat.ST_MODE])
+test.fail_test(s != 0700)
+test.must_not_exist('bar.out')
+s = stat.S_IMODE(os.stat(test.workpath('f3'))[stat.ST_MODE])
+test.fail_test(s != 0700)
+s = stat.S_IMODE(os.stat(test.workpath('d4'))[stat.ST_MODE])
+test.fail_test(s != 0700)
+s = stat.S_IMODE(os.stat(test.workpath('f5'))[stat.ST_MODE])
+test.fail_test(s != 0700)
+test.must_not_exist('f6.out')
+test.must_not_exist('f7.out')
+s = stat.S_IMODE(os.stat(test.workpath('Chmod-f7.in'))[stat.ST_MODE])
+test.fail_test(s != 0700)
+s = stat.S_IMODE(os.stat(test.workpath('f7.out-Chmod'))[stat.ST_MODE])
+test.fail_test(s != 0700)
+
+test.run()
+
+s = stat.S_IMODE(os.stat(test.workpath('f1'))[stat.ST_MODE])
+test.fail_test(s != 0777)
+s = stat.S_IMODE(os.stat(test.workpath('d2'))[stat.ST_MODE])
+test.fail_test(s != 0777)
+test.must_match('bar.out', "bar.in\n")
+s = stat.S_IMODE(os.stat(test.workpath('f3'))[stat.ST_MODE])
+test.fail_test(s != 0755)
+s = stat.S_IMODE(os.stat(test.workpath('d4'))[stat.ST_MODE])
+test.fail_test(s != 0755)
+s = stat.S_IMODE(os.stat(test.workpath('f5'))[stat.ST_MODE])
+test.fail_test(s != 0775)
+test.must_match('f6.out', "f6.in\n")
+test.must_match('f7.out', "f7.in\n")
+s = stat.S_IMODE(os.stat(test.workpath('Chmod-f7.in'))[stat.ST_MODE])
+test.fail_test(s != 0775)
+s = stat.S_IMODE(os.stat(test.workpath('f7.out-Chmod'))[stat.ST_MODE])
+test.fail_test(s != 0775)
+
+test.pass_test()
--- /dev/null
+#!/usr/bin/env python
+#
+# __COPYRIGHT__
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
+
+"""
+Verify that the Delete() Action works.
+"""
+
+import os.path
+
+import TestSCons
+
+test = TestSCons.TestSCons()
+
+test.write('SConstruct', """
+Execute(Copy('f1.out', 'f1.in'))
+Execute(Copy('d2.out', 'd2.in'))
+Execute(Copy('d3.out', 'f3.in'))
+def cat(env, source, target):
+ target = str(target[0])
+ source = map(str, source)
+ f = open(target, "wb")
+ for src in source:
+ f.write(open(src, "rb").read())
+ f.close()
+Cat = Action(cat)
+env = Environment()
+env.Command('bar.out', 'bar.in', [Cat,
+ Copy("f4.out", "f4.in"),
+ Copy("d5.out", "d5.in"),
+ Copy("d6.out", "f6.in")])
+env = Environment(OUTPUT = 'f7.out', INPUT = 'f7.in')
+env.Command('f8.out', 'f8.in', [Copy('$OUTPUT', '$INPUT'), Cat])
+env.Command('f9.out', 'f9.in', [Cat, Copy('${TARGET}-Copy', '$SOURCE')])
+""")
+
+test.write('f1.in', "f1.in\n")
+test.subdir('d2.in')
+test.write(['d2.in', 'file'], "d2.in/file\n")
+test.write('f3.in', "f3.in\n")
+test.subdir('d3.out')
+test.write('bar.in', "bar.in\n")
+test.write('f4.in', "f4.in\n")
+test.subdir('d5.in')
+test.write(['d5.in', 'file'], "d5.in/file\n")
+test.write('f6.in', "f6.in\n")
+test.subdir('d6.out')
+test.write('f7.in', "f7.in\n")
+test.write('f8.in', "f8.in\n")
+test.write('f9.in', "f9.in\n")
+
+expect = test.wrap_stdout(read_str = """\
+Copy("f1.out", "f1.in")
+Copy("d2.out", "d2.in")
+Copy("d3.out", "f3.in")
+""",
+ build_str = """\
+cat("bar.out", "bar.in")
+Copy("f4.out", "f4.in")
+Copy("d5.out", "d5.in")
+Copy("d6.out", "f6.in")
+Copy("f7.out", "f7.in")
+cat("f8.out", "f8.in")
+cat("f9.out", "f9.in")
+Copy("f9.out-Copy", "f9.in")
+""")
+test.run(options = '-n', arguments = '.', stdout = expect)
+
+test.must_not_exist('f1.out')
+test.must_not_exist('d2.out')
+test.must_not_exist(os.path.join('d3.out', 'f3.in'))
+test.must_not_exist('f4.out')
+test.must_not_exist('d5.out')
+test.must_not_exist(os.path.join('d6.out', 'f6.in'))
+test.must_not_exist('f7.out')
+test.must_not_exist('f8.out')
+test.must_not_exist('f9.out')
+test.must_not_exist('f9.out-Copy')
+
+test.run()
+
+test.must_match('f1.out', "f1.in\n")
+test.must_match(['d2.out', 'file'], "d2.in/file\n")
+test.must_match(['d3.out', 'f3.in'], "f3.in\n")
+test.must_match('f4.out', "f4.in\n")
+test.must_match(['d5.out', 'file'], "d5.in/file\n")
+test.must_match(['d6.out', 'f6.in'], "f6.in\n")
+test.must_match('f7.out', "f7.in\n")
+test.must_match('f8.out', "f8.in\n")
+test.must_match('f9.out', "f9.in\n")
+test.must_match('f9.out-Copy', "f9.in\n")
+
+test.pass_test()
--- /dev/null
+#!/usr/bin/env python
+#
+# __COPYRIGHT__
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
+
+"""
+Verify that the Delete() Action works.
+"""
+
+import os.path
+
+import TestSCons
+
+test = TestSCons.TestSCons()
+
+test.write('SConstruct', """
+Execute(Delete('f1'))
+Execute(Delete('d2'))
+def cat(env, source, target):
+ target = str(target[0])
+ source = map(str, source)
+ f = open(target, "wb")
+ for src in source:
+ f.write(open(src, "rb").read())
+ f.close()
+Cat = Action(cat)
+env = Environment()
+env.Command('f3.out', 'f3.in', [Cat, Delete("f4"), Delete("d5")])
+env = Environment(FILE='f6', DIR='d7')
+env.Command('f8.out', 'f8.in', [Delete("$FILE"), Delete("$DIR"), Cat])
+env.Command('f9.out', 'f9.in', [Cat,
+ Delete("Delete-$SOURCE"),
+ Delete("$TARGET-Delete")])
+""")
+
+test.write('f1', "f1\n")
+test.subdir('d2')
+test.write(['d2', 'file'], "d2/file\n")
+test.write('f3.in', "f3.in\n")
+test.write('f4', "f4\n")
+test.subdir('d5')
+test.write(['d5', 'file'], "d5/file\n")
+test.write('f6', "f6\n")
+test.subdir('d7')
+test.write(['d7', 'file'], "d7/file\n")
+test.write('f8.in', "f8.in\n")
+test.write('f9.in', "f9.in\n")
+test.write('Delete-f9.in', "Delete-f9.in\n")
+test.write('f9.out-Delete', "f9.out-Delete\n")
+
+expect = test.wrap_stdout(read_str = """\
+Delete("f1")
+Delete("d2")
+""",
+ build_str = """\
+cat("f3.out", "f3.in")
+Delete("f4")
+Delete("d5")
+Delete("f6")
+Delete("d7")
+cat("f8.out", "f8.in")
+cat("f9.out", "f9.in")
+Delete("Delete-f9.in")
+Delete("f9.out-Delete")
+""")
+test.run(options = '-n', arguments = '.', stdout = expect)
+
+test.must_exist('f1')
+test.must_exist('d2')
+test.must_exist(os.path.join('d2', 'file'))
+test.must_not_exist('f3.out')
+test.must_exist('f4')
+test.must_exist('d5')
+test.must_exist(os.path.join('d5', 'file'))
+test.must_exist('f6')
+test.must_exist('d7')
+test.must_exist(os.path.join('d7', 'file'))
+test.must_not_exist('f8.out')
+test.must_not_exist('f9.out')
+test.must_exist('Delete-f9.in')
+test.must_exist('f9.out-Delete')
+
+test.run()
+
+test.must_not_exist('f1')
+test.must_not_exist('d2')
+test.must_not_exist(os.path.join('d2', 'file'))
+test.must_match('f3.out', "f3.in\n")
+test.must_not_exist('f4')
+test.must_not_exist('d5')
+test.must_not_exist(os.path.join('d5', 'file'))
+test.must_not_exist('f6')
+test.must_not_exist('d7')
+test.must_not_exist(os.path.join('d7', 'file'))
+test.must_match('f8.out', "f8.in\n")
+test.must_match('f9.out', "f9.in\n")
+test.must_not_exist('Delete-f9.in')
+test.must_not_exist('f9.out-Delete')
+
+test.pass_test()
--- /dev/null
+#!/usr/bin/env python
+#
+# __COPYRIGHT__
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
+
+"""
+Verify that the Mkdir() Action works.
+"""
+
+import os.path
+
+import TestSCons
+
+test = TestSCons.TestSCons()
+
+test.write('SConstruct', """
+Execute(Mkdir('d1'))
+def cat(env, source, target):
+ target = str(target[0])
+ source = map(str, source)
+ f = open(target, "wb")
+ for src in source:
+ f.write(open(src, "rb").read())
+ f.close()
+Cat = Action(cat)
+env = Environment()
+env.Command('f2.out', 'f2.in', [Cat, Mkdir("d3")])
+env = Environment(DIR = 'd4')
+env.Command('f5.out', 'f5.in', [Mkdir("$DIR"), Cat])
+env.Command('f6.out', 'f6.in', [Cat,
+ Mkdir("Mkdir-$SOURCE"),
+ Mkdir("$TARGET-Mkdir")])
+""")
+
+test.write('f2.in', "f2.in\n")
+test.write('f5.in', "f5.in\n")
+test.write('f6.in', "f6.in\n")
+
+expect = test.wrap_stdout(read_str = 'Mkdir("d1")\n',
+ build_str = """\
+cat("f2.out", "f2.in")
+Mkdir("d3")
+Mkdir("d4")
+cat("f5.out", "f5.in")
+cat("f6.out", "f6.in")
+Mkdir("Mkdir-f6.in")
+Mkdir("f6.out-Mkdir")
+""")
+test.run(options = '-n', arguments = '.', stdout = expect)
+
+test.must_not_exist('d1')
+test.must_not_exist('f2.out')
+test.must_not_exist('d3')
+test.must_not_exist('d4')
+test.must_not_exist('f5.out')
+test.must_not_exist('f6.out')
+test.must_not_exist('Mkdir-f6.in')
+test.must_not_exist('f6.out-Mkdir')
+
+test.run()
+
+test.must_exist('d1')
+test.must_match('f2.out', "f2.in\n")
+test.must_exist('d3')
+test.must_exist('d4')
+test.must_match('f5.out', "f5.in\n")
+test.must_exist('f6.out')
+test.must_exist('Mkdir-f6.in')
+test.must_exist('f6.out-Mkdir')
+
+test.write(['d1', 'file'], "d1/file\n")
+test.write(['d3', 'file'], "d3/file\n")
+test.write(['Mkdir-f6.in', 'file'], "Mkdir-f6.in/file\n")
+test.write(['f6.out-Mkdir', 'file'], "f6.out-Mkdir/file\n")
+
+test.pass_test()
--- /dev/null
+#!/usr/bin/env python
+#
+# __COPYRIGHT__
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
+
+"""
+Verify that the Move() Action works.
+"""
+
+import TestSCons
+
+test = TestSCons.TestSCons()
+
+test.write('SConstruct', """
+Execute(Move('f1.out', 'f1.in'))
+def cat(env, source, target):
+ target = str(target[0])
+ source = map(str, source)
+ f = open(target, "wb")
+ for src in source:
+ f.write(open(src, "rb").read())
+ f.close()
+Cat = Action(cat)
+env = Environment()
+env.Command('f2.out', 'f2.in', [Cat, Move("f3.out", "f3.in")])
+env = Environment(OUT = 'f4.out', IN = 'f4.in')
+env.Command('f5.out', 'f5.in', [Move("$OUT", "$IN"), Cat])
+env.Command('f6.out', 'f6.in', [Cat, Move("Move-$TARGET", "$SOURCE-Move")])
+""")
+
+test.write('f1.in', "f1.in\n")
+test.write('f2.in', "f2.in\n")
+test.write('f3.in', "f3.in\n")
+test.write('f4.in', "f4.in\n")
+test.write('f5.in', "f5.in\n")
+test.write('f6.in', "f6.in\n")
+test.write('f6.in-Move', "f6.in-Move\n")
+
+expect = test.wrap_stdout(read_str = 'Move("f1.out", "f1.in")\n',
+ build_str = """\
+cat("f2.out", "f2.in")
+Move("f3.out", "f3.in")
+Move("f4.out", "f4.in")
+cat("f5.out", "f5.in")
+cat("f6.out", "f6.in")
+Move("Move-f6.out", "f6.in-Move")
+""")
+test.run(options = '-n', arguments = '.', stdout = expect)
+
+test.must_not_exist('f1.out')
+test.must_not_exist('f2.out')
+test.must_not_exist('f3.out')
+test.must_not_exist('f4.out')
+test.must_not_exist('f5.out')
+test.must_not_exist('f6.out')
+test.must_not_exist('Move-f6.out')
+
+test.run()
+
+test.must_match('f1.out', "f1.in\n")
+test.must_match('f2.out', "f2.in\n")
+test.must_not_exist('f3.in')
+test.must_match('f3.out', "f3.in\n")
+test.must_match('f4.out', "f4.in\n")
+test.must_match('f5.out', "f5.in\n")
+test.must_match('f6.out', "f6.in\n")
+test.must_match('Move-f6.out', "f6.in-Move\n")
+
+test.pass_test()
--- /dev/null
+#!/usr/bin/env python
+#
+# __COPYRIGHT__
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
+
+"""
+Verify that the Touch() Action works.
+"""
+
+import os.path
+
+import TestSCons
+
+test = TestSCons.TestSCons()
+
+test.write('SConstruct', """
+Execute(Touch('f1'))
+def cat(env, source, target):
+ target = str(target[0])
+ source = map(str, source)
+ f = open(target, "wb")
+ for src in source:
+ f.write(open(src, "rb").read())
+ f.close()
+Cat = Action(cat)
+env = Environment()
+env.Command('f2.out', 'f2.in', [Cat, Touch("f3")])
+env = Environment(FILE='f4')
+env.Command('f5.out', 'f5.in', [Touch("$FILE"), Cat])
+env.Command('f6.out', 'f6.in', [Cat,
+ Touch("Touch-$SOURCE"),
+ Touch("$TARGET-Touch")])
+""")
+
+test.write('f1', "f1\n")
+test.write('f2.in', "f2.in\n")
+test.write('f5.in', "f5.in\n")
+test.write('f6.in', "f6.in\n")
+
+oldtime = os.path.getmtime(test.workpath('f1'))
+
+expect = test.wrap_stdout(read_str = 'Touch("f1")\n',
+ build_str = """\
+cat("f2.out", "f2.in")
+Touch("f3")
+Touch("f4")
+cat("f5.out", "f5.in")
+cat("f6.out", "f6.in")
+Touch("Touch-f6.in")
+Touch("f6.out-Touch")
+""")
+test.run(options = '-n', arguments = '.', stdout = expect)
+
+test.sleep(2)
+
+newtime = os.path.getmtime(test.workpath('f1'))
+test.fail_test(oldtime != newtime)
+
+test.must_not_exist(test.workpath('f2.out'))
+test.must_not_exist(test.workpath('f3'))
+test.must_not_exist(test.workpath('f4'))
+test.must_not_exist(test.workpath('f5.out'))
+test.must_not_exist(test.workpath('f6.out'))
+test.must_not_exist(test.workpath('Touch-f6.in'))
+test.must_not_exist(test.workpath('f6.out-Touch'))
+
+test.run()
+
+newtime = os.path.getmtime(test.workpath('f1'))
+test.fail_test(oldtime == newtime)
+
+test.must_match('f2.out', "f2.in\n")
+test.must_exist(test.workpath('f3'))
+test.must_exist(test.workpath('f4'))
+test.must_match('f5.out', "f5.in\n")
+test.must_match('f6.out', "f6.in\n")
+test.must_exist(test.workpath('Touch-f6.in'))
+test.must_exist(test.workpath('f6.out-Touch'))
+
+test.pass_test()
projects / scons.git / commitdiff