Really support strfunction for all Action subclasses by refactoring the interface between Executor and Action, and collecting all the print/execute logic in a single ActionBase.__call__() method.

1 files changed, 143 insertions, 0 deletions

diff --git a/test/strfunction.py b/test/strfunction.py
new file mode 100644
index 0000000..4ed75ee
--- /dev/null
+++ b/test/strfunction.py
@@ -0,0 +1,143 @@
+#!/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__"
+
+"""
+Test how using strfunction() to report different types of
+"""
+
+import TestSCons
+
+python = TestSCons.python
+
+test = TestSCons.TestSCons()
+
+test.write('cat.py', """\
+import sys
+open(sys.argv[2], "wb").write(open(sys.argv[1], "rb").read())
+sys.exit(0)
+""")
+
+test.write('SConstruct', """\
+def strfunction(target, source, env):
+    t = str(target[0])
+    s = str(source[0])
+    return "Building %%s from %%s" %% (t, s)
+def func(target, source, env):
+    t = str(target[0])
+    s = str(source[0])
+    open(t, 'w').write(open(s, 'r').read())
+funcaction = Action(func, strfunction=strfunction)
+cmd = r"%s cat.py $SOURCE $TARGET"
+cmdaction = Action(cmd, strfunction=strfunction)
+list = [ r"%s cat.py $SOURCE .temp", r"%s cat.py .temp $TARGET" ]
+listaction = Action(list, strfunction=strfunction)
+lazy = '$LAZY'
+lazyaction = Action(lazy, strfunction=strfunction)
+dict = {
+    '.cmd'      : cmd,
+    '.cmdstr'   : cmdaction,
+    '.func'     : func,
+    '.funcstr'  : funcaction,
+    '.list'     : list,
+    '.liststr'  : listaction,
+    '.lazy'     : lazy,
+    '.lazystr'  : lazyaction,
+}
+env = Environment(BUILDERS = {
+                        'Cmd'           : Builder(action=cmd),
+                        'CmdStr'        : Builder(action=cmdaction),
+                        'Func'          : Builder(action=func),
+                        'FuncStr'       : Builder(action=funcaction),
+                        'Lazy'          : Builder(action=lazy),
+                        'LazyStr'       : Builder(action=lazyaction),
+                        'List'          : Builder(action=list),
+                        'ListStr'       : Builder(action=listaction),
+
+                        'Dict'          : Builder(action=dict),
+                  },
+                  LAZY = r"%s cat.py $SOURCE $TARGET")
+env.Cmd('cmd.out', 'cmd.in')
+env.CmdStr('cmdstr.out', 'cmdstr.in')
+env.Func('func.out', 'func.in')
+env.FuncStr('funcstr.out', 'funcstr.in')
+env.Lazy('lazy.out', 'lazy.in')
+env.LazyStr('lazystr.out', 'lazystr.in')
+env.List('list.out', 'list.in')
+env.ListStr('liststr.out', 'liststr.in')
+
+env.Dict('dict1.out', 'dict1.cmd')
+env.Dict('dict2.out', 'dict2.cmdstr')
+env.Dict('dict3.out', 'dict3.func')
+env.Dict('dict4.out', 'dict4.funcstr')
+env.Dict('dict5.out', 'dict5.lazy')
+env.Dict('dict6.out', 'dict6.lazystr')
+env.Dict('dict7.out', 'dict7.list')
+env.Dict('dict8.out', 'dict8.liststr')
+""" % (python, python, python, python))
+
+test.write('func.in',   	"func.in\n")
+test.write('funcstr.in',	"funcstr.in\n")
+test.write('cmd.in',    	"cmd.in\n")
+test.write('cmdstr.in', 	"cmdstr.in\n")
+test.write('lazy.in',   	"lazy.in\n")
+test.write('lazystr.in',	"lazystr.in\n")
+test.write('list.in',   	"list.in\n")
+test.write('liststr.in',	"liststr.in\n")
+
+test.write('dict1.cmd',         "dict1.cmd\n")
+test.write('dict2.cmdstr',      "dict2.cmdstr\n")
+test.write('dict3.func',        "dict3.func\n")
+test.write('dict4.funcstr',     "dict4.funcstr\n")
+test.write('dict5.lazy',        "dict4.lazy\n")
+test.write('dict6.lazystr',     "dict6.lazystr\n")
+test.write('dict7.list',        "dict7.list\n")
+test.write('dict8.liststr',     "dict8.liststr\n")
+
+test.run(arguments = '.', stdout=test.wrap_stdout("""\
+%s cat.py cmd.in cmd.out
+Building cmdstr.out from cmdstr.in
+%s cat.py dict1.cmd dict1.out
+Building dict2.out from dict2.cmdstr
+func("dict3.out", "dict3.func")
+Building dict4.out from dict4.funcstr
+%s cat.py dict5.lazy dict5.out
+Building dict6.out from dict6.lazystr
+%s cat.py dict7.list .temp
+%s cat.py .temp dict7.out
+Building dict8.out from dict8.liststr
+func("func.out", "func.in")
+Building funcstr.out from funcstr.in
+%s cat.py lazy.in lazy.out
+Building lazystr.out from lazystr.in
+%s cat.py list.in .temp
+%s cat.py .temp list.out
+Building liststr.out from liststr.in
+Building liststr.out from liststr.in
+""") % (python, python, python, python, python, python, python, python))
+# XXX The duplication of "Buiding liststr.out" above is WRONG!
+# A follow-on fix should take care of this.
+
+test.pass_test()