Adding in new software construction toolkit version.

site_scons/site_tools/component_builders.py

 #!/usr/bin/python2.4
 # Copyright 2008, Google Inc.
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
@@ skipping 19 matching lines @@
 
 """Software construction toolkit builders for SCons."""
 
 
 import SCons
 
 
 __component_list = {}
 
 
-def _InitializeComponentBuilders(self):
+def _InitializeComponentBuilders(env):
   """Re-initializes component builders module.
 
   Args:
-    self: Parent environment.
+    env: Environment context
   """
-  self = self     # Silence gpylint
+  env = env     # Silence gpylint
 
   __component_list.clear()
 
 
 def _RetrieveComponents(component_name, filter_components=None):
   """Get the list of all components required by the specified component.
 
   Args:
     component_name: Name of the base component.
     filter_components: List of components NOT to include.
@@ skipping 123 matching lines @@
   )
 
   # Add an empty alias for the package and add it to the right groups
   a = env.Alias(package_name, [])
   for group in env['COMPONENT_PACKAGE_GROUPS']:
     SCons.Script.Alias(group, a)
 
   # Store list of components for this program
   env._StoreComponents(package_name)
 
+  # Let component_targets know this target is available in the current mode
+  env.SetTargetProperty(package_name, TARGET_PATH=dest_dir)
+
   # Set up deferred call to replicate resources
   env.Defer(ComponentPackageDeferred)
 
   # Return the alias, since it's the only node we have
   return a
 
 #------------------------------------------------------------------------------
 
 
 def ComponentObject(self, *args, **kwargs):
@@ skipping 60 matching lines @@
     if o.suffix in env['COMPONENT_LIBRARY_LINK_SUFFIXES']:
       need_for_link.append(o)
     if o.suffix in env['COMPONENT_LIBRARY_DEBUG_SUFFIXES']:
       need_for_debug.append(o)
     if o.suffix == env['SHLIBSUFFIX']:
       need_for_run.append(o)
   all_outputs = lib_outputs
 
   # Install library in intermediate directory, so other libs and programs can
   # link against it
-  all_outputs += env.Replicate('$COMPONENT_LIBRARY_DIR', need_for_link)
+  all_outputs += env.Replicate('$LIB_DIR', need_for_link)
 
   # Publish output
   env.Publish(lib_name, 'run', need_for_run)
   env.Publish(lib_name, 'debug', need_for_debug)
 
   # Add an alias to build and copy the library, and add it to the right groups
   a = self.Alias(lib_name, all_outputs)
   for group in env['COMPONENT_LIBRARY_GROUPS']:
     SCons.Script.Alias(group, a)
 
   # Store list of components for this library
   env._StoreComponents(lib_name)
 
+  # Let component_targets know this target is available in the current mode.
+  env.SetTargetProperty(lib_name, TARGET_PATH=lib_outputs[0])
+
   # If library should publish itself, publish as if it was a program
   if env.get('COMPONENT_LIBRARY_PUBLISH'):
     env['PROGRAM_BASENAME'] = lib_name
     env.Defer(ComponentProgramDeferred)
 
   # Return the library outputs
   return lib_outputs
 
 #------------------------------------------------------------------------------
 
@@ skipping 42 matching lines @@
     # Run the test.  Note that we need to refer to the file by name, so that
     # SCons will recreate the file node after we've deleted it; if we used the
     # env.File() we created in the if statement above, SCons would still think
     # it exists and not rerun the test.
     test_out = env.CommandOutput(test_out_name, test_program)
 
     # Running the test requires the test and its libs copied to the tests dir
     env.Depends(test_out, all_outputs)
     env.ComponentTestOutput('run_' + prog_name, test_out)
 
+    # Add target properties
+    env.SetTargetProperty(
+        prog_name,
+        # The copy of the program we care about is the one in the tests dir
+        EXE='$TESTS_DIR/$PROGRAM_NAME',
+        RUN_TARGET='run_' + prog_name,
+        RUN_CMDLINE='$COMPONENT_TEST_CMDLINE',
+        RUN_DIR='$TESTS_DIR',
+        TARGET_PATH='$TESTS_DIR/$PROGRAM_NAME',
+    )
+
 
 def ComponentTestProgram(self, prog_name, *args, **kwargs):
   """Pseudo-builder for test program to handle platform-dependent type.
 
   Args:
     self: Environment in which we were called.
     prog_name: Test program name.
     args: Positional arguments.
     kwargs: Keyword arguments.
 
@@ skipping 19 matching lines @@
   env.Publish(prog_name, 'debug', out_nodes[1:])
 
   # Add an alias to build the program to the right groups
   a = env.Alias(prog_name, out_nodes)
   for group in env['COMPONENT_TEST_PROGRAM_GROUPS']:
     SCons.Script.Alias(group, a)
 
   # Store list of components for this program
   env._StoreComponents(prog_name)
 
+  # Let component_targets know this target is available in the current mode
+  env.SetTargetProperty(prog_name, TARGET_PATH=out_nodes[0])
+
   # Set up deferred call to replicate resources and run test
   env.Defer(ComponentTestProgramDeferred)
 
   # Return the output node
   return out_nodes
 
 #------------------------------------------------------------------------------
 
 
 def ComponentProgramDeferred(env):
@@ skipping 44 matching lines @@
   env.Publish(prog_name, 'debug', out_nodes[1:])
 
   # Add an alias to build the program to the right groups
   a = env.Alias(prog_name, out_nodes)
   for group in env['COMPONENT_PROGRAM_GROUPS']:
     SCons.Script.Alias(group, a)
 
   # Store list of components for this program
   env._StoreComponents(prog_name)
 
+  # Let component_targets know this target is available in the current mode
+  env.SetTargetProperty(prog_name)
+
   # Set up deferred call to replicate resources
   env.Defer(ComponentProgramDeferred)
 
   # Return the output nodes
   return out_nodes
 
 #------------------------------------------------------------------------------
 
 
 def ComponentTestOutput(self, test_name, nodes):
@@ skipping 19 matching lines @@
       groups = ['run_all_tests']
       if self.get('COMPONENT_TEST_SIZE'):
         groups.append(self.subst('run_${COMPONENT_TEST_SIZE}_tests'))
     else:
       # Disabled tests only go in their group
       groups = ['run_disabled_tests']
 
   for group in groups:
     SCons.Script.Alias(group, a)
 
+  # Let component_targets know this target is available in the current mode
+  self.SetTargetProperty(test_name, TARGET_PATH=nodes[0])
+
   # Return the output node
   return a
 
 #------------------------------------------------------------------------------
 
 
 def generate(env):
   # NOTE: SCons requires the use of this name, which fails gpylint.
   """SCons entry point for this tool."""
 
   env.Replace(
-      COMPONENT_LIBRARY_DIR='$TARGET_ROOT/lib',
+      LIB_DIR='$TARGET_ROOT/lib',
+      # TODO(rspangler): Remove legacy COMPONENT_LIBRARY_DIR, once all users
+      # have transitioned to LIB_DIR
+      COMPONENT_LIBRARY_DIR='$LIB_DIR',
       STAGING_DIR='$TARGET_ROOT/staging',
       TESTS_DIR='$TARGET_ROOT/tests',
       TEST_OUTPUT_DIR='$TARGET_ROOT/test_output',
       # Default command line for a test is just the name of the file.
       # TODO(rspangler): Why doesn't the following work:
       # COMPONENT_TEST_CMDLINE='${SOURCE.abspath}',
       # (it generates a SCons error)
       COMPONENT_TEST_CMDLINE='${PROGRAM_NAME}',
       # Default test size is large
       COMPONENT_TEST_SIZE='large',
       # Default timeouts for component tests
-      COMPONENT_TEST_TIMEOUT={'large':900, 'medium':450, 'small':180},
+      COMPONENT_TEST_TIMEOUT={'large': 900, 'medium': 450, 'small': 180},
       # Tests are enabled by default
       COMPONENT_TEST_ENABLED=True,
       # Static linking is a sensible default
       COMPONENT_STATIC=True,
       # Don't publish libraries to the staging dir by themselves by default.
       COMPONENT_LIBRARY_PUBLISH=False,
   )
   env.Append(
-      LIBPATH=['$COMPONENT_LIBRARY_DIR'],
-      RPATH=['$COMPONENT_LIBRARY_DIR'],
+      LIBPATH=['$LIB_DIR'],
+      RPATH=['$LIB_DIR'],
 
       # Default alias groups for component builders
       COMPONENT_PACKAGE_GROUPS=['all_packages'],
       COMPONENT_LIBRARY_GROUPS=['all_libraries'],
       COMPONENT_PROGRAM_GROUPS=['all_programs'],
       COMPONENT_TEST_PROGRAM_GROUPS=['all_test_programs'],
 
       # Additional components whose resources should be copied into program
       # directories, in addition to those from LIBS and the program itself.
       LIBS=[],
@@ skipping 18 matching lines @@
 
   # Add command line option for retest
   SCons.Script.AddOption(
       '--retest',
       dest='component_test_retest',
       action='store_true',
       help='force all tests to rerun')
   SCons.Script.Help('  --retest                    '
                     'Rerun specified tests, ignoring cached results.\n')
 
+  # Defer per-environment initialization, but do before building SConscripts
+  env.Defer(_InitializeComponentBuilders)
+  env.Defer('BuildEnvironmentSConscripts', after=_InitializeComponentBuilders)
+
   # Add our pseudo-builder methods
-  env.AddMethod(_InitializeComponentBuilders)
   env.AddMethod(_StoreComponents)
   env.AddMethod(ComponentPackage)
   env.AddMethod(ComponentObject)
   env.AddMethod(ComponentLibrary)
   env.AddMethod(ComponentProgram)
   env.AddMethod(ComponentTestProgram)
   env.AddMethod(ComponentTestOutput)
 
   # Add our target groups
   AddTargetGroup('all_libraries', 'libraries can be built')
   AddTargetGroup('all_programs', 'programs can be built')
   AddTargetGroup('all_test_programs', 'tests can be built')
   AddTargetGroup('all_packages', 'packages can be built')
   AddTargetGroup('run_all_tests', 'tests can be run')
   AddTargetGroup('run_disabled_tests', 'tests are disabled')
   AddTargetGroup('run_small_tests', 'small tests can be run')
   AddTargetGroup('run_medium_tests', 'medium tests can be run')
   AddTargetGroup('run_large_tests', 'large tests can be run')