Add an option to prune unwanted targets

pylib/gyp/input.py

 # Copyright (c) 2012 Google Inc. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 from compiler.ast import Const
 from compiler.ast import Dict
 from compiler.ast import Discard
 from compiler.ast import List
 from compiler.ast import Module
 from compiler.ast import Node
@@ skipping 2544 matching lines @@
   for index in xrange(0, len(the_list)):
     item = the_list[index]
     if isinstance(item, int):
       the_list[index] = str(item)
     elif isinstance(item, dict):
       TurnIntIntoStrInDict(item)
     elif isinstance(item, list):
       TurnIntIntoStrInList(item)
 
 
+def PruneUnwantedTargets(targets, flat_list, dependency_nodes, root_targets):
+  """Return only the targets that are deep dependencies of |root_targets|."""
+  qualified_root_targets = []
+  for target in root_targets:
+    target = target.strip()
+    qualified_targets = gyp.common.FindQualifiedTargets(target, flat_list)
+    if not qualified_targets:
+      raise GypError("Could not find target %s" % target)
+    qualified_root_targets.extend(qualified_targets)
+
+  wanted_targets = {}
+  for target in qualified_root_targets:
+    wanted_targets[target] = targets[target]
+    for dependency in dependency_nodes[target].DeepDependencies():
+      wanted_targets[dependency] = targets[dependency]
+
+  wanted_flat_list = [t for t in flat_list if t in wanted_targets]
+  return wanted_targets, wanted_flat_list
+
+
 def VerifyNoCollidingTargets(targets):
   """Verify that no two targets in the same directory share the same name.
 
   Arguments:
     targets: A list of targets in the form 'path/to/file.gyp:target_name'.
   """
   # Keep a dict going from 'subdirectory:target_name' to 'foo.gyp'.
   used = {}
   for target in targets:
     # Separate out 'path/to/file.gyp, 'target_name' from
     # 'path/to/file.gyp:target_name'.
     path, name = target.rsplit(':', 1)
     # Separate out 'path/to', 'file.gyp' from 'path/to/file.gyp'.
     subdir, gyp = os.path.split(path)
     # Use '.' for the current directory '', so that the error messages make
     # more sense.
     if not subdir:
       subdir = '.'
     # Prepare a key like 'path/to:target_name'.
     key = subdir + ':' + name
     if key in used:
       # Complain if this target is already used.
       raise GypError('Duplicate target name "%s" in directory "%s" used both '
                      'in "%s" and "%s".' % (name, subdir, gyp, used[key]))
     used[key] = gyp
 
 
 def Load(build_files, variables, includes, depth, generator_input_info, check,
-         circular_check, parallel):
+         circular_check, parallel, root_targets):
   # Set up path_sections and non_configuration_keys with the default data plus
   # the generator-specifc data.
   global path_sections
   path_sections = base_path_sections[:]
   path_sections.extend(generator_input_info['path_sections'])
 
   global non_configuration_keys
   non_configuration_keys = base_non_configuration_keys[:]
   non_configuration_keys.extend(generator_input_info['non_configuration_keys'])
 
@@ skipping 67 matching lines @@
   # Make sure every dependency appears at most once.
   RemoveDuplicateDependencies(targets)
 
   if circular_check:
     # Make sure that any targets in a.gyp don't contain dependencies in other
     # .gyp files that further depend on a.gyp.
     VerifyNoGYPFileCircularDependencies(targets)
 
   [dependency_nodes, flat_list] = BuildDependencyList(targets)
 
+  if root_targets:
+    # Remove, from |targets| and |flat_list|, the targets that are not deep
+    # dependencies of the targets specified in |root_targets|.
+    targets, flat_list = PruneUnwantedTargets(
+        targets, flat_list, dependency_nodes, root_targets)
+
   # Check that no two targets in the same directory have the same name.
   VerifyNoCollidingTargets(flat_list)
 
   # Handle dependent settings of various types.
   for settings_type in ['all_dependent_settings',
                         'direct_dependent_settings',
                         'link_settings']:
     DoDependentSettings(settings_type, flat_list, targets, dependency_nodes)
 
     # Take out the dependent settings now that they've been published to all
@@ skipping 50 matching lines @@
     ValidateRunAsInTarget(target, target_dict, build_file)
     ValidateActionsInTarget(target, target_dict, build_file)
 
   # Generators might not expect ints.  Turn them into strs.
   TurnIntIntoStrInDict(data)
 
   # TODO(mark): Return |data| for now because the generator needs a list of
   # build files that came in.  In the future, maybe it should just accept
   # a list, and not the whole data dict.
   return [flat_list, targets, data]