Add support for a toolpath for Environments.

6 files changed, 205 insertions, 16 deletions

diff --git a/doc/man/scons.1 b/doc/man/scons.1
index 4dcf3b9..7014cf3 100644
--- a/doc/man/scons.1
+++ b/doc/man/scons.1
@@ -873,6 +873,19 @@ may specified as an optional keyword argument:
 env = Environment(tools = ['msvc', 'lex'])
 .EE
 
+Non-built-in tools may be specified using the toolpath argument:
+
+.ES
+env = Environment(tools = ['foo'], toolpath = ['tools'])
+.EE
+
+This looks for a tool specification in tools/foo.py.  foo.py should
+have two functions: generate(env) and exists(env).  generate()
+modifies the passed in environment and exists() should return a true
+value if the tool is available.  Tools in the toolpath are used before
+any of the built-in ones.  For example, adding gcc.py to the toolpath
+would override the built-in gcc tool.
+
 The elements of the tools list may also
 be functions or callable objects,
 in which case the Environment() method
@@ -2293,8 +2306,8 @@ env2 = env.Copy()
 env3 = env.Copy(CCFLAGS = '-g')
 .EE
 .IP
-Additionally, a list of tools may be specified, as in the Environment
-constructor:
+Additionally, a list of tools and a toolpath may be specified, as in
+the Environment constructor:
 
 .ES
 def MyTool(env): env['FOO'] = 'bar'
@@ -3498,7 +3511,7 @@ The default is "build".
 
 '\"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
 .TP
-.RI Tool( string )
+.RI Tool( string, toolpath=[] )
 Returns a callable object
 that can be used to initialize
 a construction environment using the
@@ -3518,15 +3531,18 @@ env = Environment(tools = [ Tool('msvc') ])
 env = Environment()
 t = Tool('msvc')
 t(env)  # adds 'msvc' to the TOOLS variable
+u = Tool('opengl', toolpath = ['tools'])
+u(env)  # adds 'opengl' to the TOOLS variable
 .EE
 .TP
-.RI env.Tool( string )
+.RI env.Tool( string [, toolpath] )
 Applies the callable object for the specified tool
 .I string
 to the environment through which the method was called.
 
 .ES
 env.Tool('gcc')
+env.Tool('opengl', toolpath = ['build/tools'])
 .EE
 
 '\"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
diff --git a/src/CHANGES.txt b/src/CHANGES.txt
index 1043b50..2b598ae 100644
--- a/src/CHANGES.txt
+++ b/src/CHANGES.txt
@@ -25,6 +25,9 @@ RELEASE 0.95 - XXX
 
   - Fix a problem with the msvc tool with Python versions prior to 2.3.
 
+  - Add support for a "toolpath" Tool() and Environment keyword that
+    allows Tool modules to be found in specified local directories.
+
   From Chris Burghart:
 
   - Fix the ability to save/restore a PackageOption to a file.
diff --git a/src/engine/SCons/Environment.py b/src/engine/SCons/Environment.py
index 26be483..6afa69f 100644
--- a/src/engine/SCons/Environment.py
+++ b/src/engine/SCons/Environment.py
@@ -109,12 +109,13 @@ def our_deepcopy(x):
        copy = x
    return copy
 
-def apply_tools(env, tools):
+def apply_tools(env, tools, toolpath):
     if tools:
         for tool in tools:
             if SCons.Util.is_String(tool):
-                tool = SCons.Tool.Tool(tool)
-            tool(env)
+                env.Tool(tool, toolpath)
+            else:
+                tool(env)
 
 class BuilderWrapper:
     """Wrapper class that associates an environment with a Builder at
@@ -207,6 +208,7 @@ class Base:
     def __init__(self,
                  platform=None,
                  tools=None,
+                 toolpath=[],
                  options=None,
                  **kw):
         self.fs = SCons.Node.FS.default_fs
@@ -238,7 +240,7 @@ class Base:
             tools = self._dict.get('TOOLS', None)
             if tools is None:
                 tools = ['default']
-        apply_tools(self, tools)
+        apply_tools(self, tools, toolpath)
 
         # Reapply the passed in variables after calling the tools,
         # since they should overide anything set by the tools:
@@ -461,7 +463,7 @@ class Base:
 
         self._dict[envname][name] = nv
 
-    def Copy(self, tools=None, **kw):
+    def Copy(self, tools=None, toolpath=[], **kw):
         """Return a copy of a construction Environment.  The
         copy is like a Python "deep copy"--that is, independent
         copies are made recursively of each objects--except that
@@ -477,7 +479,7 @@ class Base:
         except KeyError:
             pass
         
-        apply_tools(clone, tools)
+        apply_tools(clone, tools, toolpath)
 
         # Apply passed-in variables after the new tools.
         apply(clone.Replace, (), kw)
@@ -666,9 +668,9 @@ class Base:
             name = name[:-len(old_suffix)]
         return os.path.join(dir, new_prefix+name+new_suffix)
 
-    def Tool(self, tool):
+    def Tool(self, tool, toolpath=[]):
         tool = self.subst(tool)
-        return SCons.Tool.Tool(tool)(self)
+        return SCons.Tool.Tool(tool, map(self.subst, toolpath))(self)
 
     def WhereIs(self, prog, path=None, pathext=None):
         """Find prog in the path.  
diff --git a/src/engine/SCons/EnvironmentTests.py b/src/engine/SCons/EnvironmentTests.py
index e6fd5c9..5fee3dd 100644
--- a/src/engine/SCons/EnvironmentTests.py
+++ b/src/engine/SCons/EnvironmentTests.py
@@ -1162,7 +1162,9 @@ class EnvironmentTestCase(unittest.TestCase):
             exc_caught = 1
         assert exc_caught, "did not catch expected UserError"
 
-        env.Tool('cc')
+        # Use a non-existent toolpath directory just to make sure we
+        # can call Tool() with the keyword argument.
+        env.Tool('cc', toolpath=['/no/such/directory'])
         assert env['CC'] == 'cc', env['CC']
 
         env.Tool('$LINK')
diff --git a/src/engine/SCons/Tool/__init__.py b/src/engine/SCons/Tool/__init__.py
index a58ac6d..34e9e0d 100644
--- a/src/engine/SCons/Tool/__init__.py
+++ b/src/engine/SCons/Tool/__init__.py
@@ -55,9 +55,23 @@ class ToolSpec:
     def __str__(self):
         return self.name
     
-def Tool(name):
-    """Select a canned Tool specification.
-    """
+def Tool(name, toolpath=[]):
+    "Select a canned Tool specification, optionally searching in toolpath."
+
+    try:
+        file, path, desc = imp.find_module(name, toolpath)
+        try:
+            module = imp.load_module(name, file, path, desc)
+            spec = ToolSpec(name)
+            spec.generate = module.generate
+            spec.exists = module.exists
+            return spec
+        finally:
+            if file:
+                file.close()
+    except ImportError, e:
+        pass
+    
     full_name = 'SCons.Tool.' + name
     if not sys.modules.has_key(full_name):
         try:
diff --git a/test/toolpath.py b/test/toolpath.py
new file mode 100644
index 0000000..da9f585
--- /dev/null
+++ b/test/toolpath.py
@@ -0,0 +1,152 @@
+#!/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__"
+
+import os.path
+import sys
+import time
+import TestSCons
+
+test = TestSCons.TestSCons()
+
+test.write('SConstruct', """
+def foo(env):
+    env['TOOL_FOO'] = 1
+    
+env1 = Environment(tools=[foo, 'bar'], toolpath=['tools'])
+print "env1['TOOL_FOO'] =", env1.get('TOOL_FOO')
+print "env1['TOOL_BAR'] =", env1.get('TOOL_BAR')
+
+# pick a built-in tool with pretty simple behavior
+env2 = Environment(tools=['SCCS'])
+print "env2['SCCS'] =", env2.get('SCCS')
+print "env2['TOOL_SCCS1'] =", env2.get('TOOL_SCCS1')
+print "env2['TOOL_SCCS2'] =", env2.get('TOOL_SCCS2')
+
+env3 = Environment(tools=['SCCS'], toolpath=['.'])
+print "env3['SCCS'] =", env3.get('SCCS')
+print "env3['TOOL_SCCS1'] =", env3.get('TOOL_SCCS1')
+print "env3['TOOL_SCCS2'] =", env3.get('TOOL_SCCS2')
+
+env4 = Environment(tools=['SCCS'], toolpath=['tools'])
+print "env4['SCCS'] =", env4.get('SCCS')
+print "env4['TOOL_SCCS1'] =", env4.get('TOOL_SCCS1')
+print "env4['TOOL_SCCS2'] =", env4.get('TOOL_SCCS2')
+
+env5 = Environment(tools=['SCCS'], toolpath=['tools', '.'])
+print "env5['SCCS'] =", env5.get('SCCS')
+print "env5['TOOL_SCCS1'] =", env5.get('TOOL_SCCS1')
+print "env5['TOOL_SCCS2'] =", env5.get('TOOL_SCCS2')
+
+env6 = Environment(tools=['SCCS'], toolpath=['.', 'tools'])
+print "env6['SCCS'] =", env6.get('SCCS')
+print "env6['TOOL_SCCS1'] =", env6.get('TOOL_SCCS1')
+print "env6['TOOL_SCCS2'] =", env6.get('TOOL_SCCS2')
+
+env7 = Environment(TOOLPATH="tools", tools=['SCCS'], toolpath=['$TOOLPATH'])
+print "env7['SCCS'] =", env7.get('SCCS')
+print "env7['TOOL_SCCS1'] =", env7.get('TOOL_SCCS1')
+print "env7['TOOL_SCCS2'] =", env7.get('TOOL_SCCS2')
+
+env8 = Environment(tools=[])
+env8.Tool('SCCS', toolpath=['tools'])
+print "env8['SCCS'] =", env8.get('SCCS')
+print "env8['TOOL_SCCS1'] =", env8.get('TOOL_SCCS1')
+print "env8['TOOL_SCCS2'] =", env8.get('TOOL_SCCS2')
+
+env9 = Environment(tools=[])
+Tool('SCCS', toolpath=['tools'])(env9)
+print "env9['SCCS'] =", env9.get('SCCS')
+print "env9['TOOL_SCCS1'] =", env9.get('TOOL_SCCS1')
+print "env9['TOOL_SCCS2'] =", env9.get('TOOL_SCCS2')
+
+env0 = Environment(TOOLPATH='tools', tools=[])
+env0.Tool('SCCS', toolpath=['$TOOLPATH'])
+print "env0['SCCS'] =", env0.get('SCCS')
+print "env0['TOOL_SCCS1'] =", env0.get('TOOL_SCCS1')
+print "env0['TOOL_SCCS2'] =", env0.get('TOOL_SCCS2')
+""")
+
+test.write('SCCS.py', r"""\
+def generate(env):
+    env['TOOL_SCCS1'] = 1
+def exists(env):
+    return 1
+""")
+
+test.subdir('tools')
+
+test.write(['tools', 'SCCS.py'], r"""\
+def generate(env):
+    env['TOOL_SCCS2'] = 1
+def exists(env):
+    return 1
+""")
+
+test.write(['tools', 'bar.py'], r"""\
+def generate(env):
+    env['TOOL_BAR'] = 1
+def exists(env):
+    return 1
+""")
+
+test.run(arguments = '.', stdout = """\
+scons: Reading SConscript files ...
+env1['TOOL_FOO'] = 1
+env1['TOOL_BAR'] = 1
+env2['SCCS'] = sccs
+env2['TOOL_SCCS1'] = None
+env2['TOOL_SCCS2'] = None
+env3['SCCS'] = None
+env3['TOOL_SCCS1'] = 1
+env3['TOOL_SCCS2'] = None
+env4['SCCS'] = None
+env4['TOOL_SCCS1'] = None
+env4['TOOL_SCCS2'] = 1
+env5['SCCS'] = None
+env5['TOOL_SCCS1'] = None
+env5['TOOL_SCCS2'] = 1
+env6['SCCS'] = None
+env6['TOOL_SCCS1'] = 1
+env6['TOOL_SCCS2'] = None
+env7['SCCS'] = None
+env7['TOOL_SCCS1'] = None
+env7['TOOL_SCCS2'] = 1
+env8['SCCS'] = None
+env8['TOOL_SCCS1'] = None
+env8['TOOL_SCCS2'] = 1
+env9['SCCS'] = None
+env9['TOOL_SCCS1'] = None
+env9['TOOL_SCCS2'] = 1
+env0['SCCS'] = None
+env0['TOOL_SCCS1'] = None
+env0['TOOL_SCCS2'] = 1
+scons: done reading SConscript files.
+scons: Building targets ...
+scons: `.' is up to date.
+scons: done building targets.
+""")
+
+test.pass_test()