Add xcode_ninja_target_pattern to xcode-ninja generator

pylib/gyp/xcode_ninja.py

 # Copyright (c) 2014 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.
 
 """Xcode-ninja wrapper project file generator.
 
 This updates the data structures passed to the Xcode gyp generator to build
 with ninja instead. The Xcode project itself is transformed into a list of
 executable targets, each with a build step to build with ninja, and a target
 with every source and resource file.  This appears to sidestep some of the
@@ skipping 94 matching lines @@
           new_xcode_settings['CONFIGURATION_BUILD_DIR'],
           target_name,
         ],
         'message': 'Compile and copy %s via ninja' % target_name,
       },
     ]
     if jobs > 0:
       ninja_target['actions'][0]['action'].extend(('-j', jobs))
   return ninja_target
 
+def IsValidTargetForWrapper(target_extras, executable_target_pattern, spec):
+  """Limit targets for Xcode wrapper.
+
+  Xcode sometimes performs poorly with too many targets, so only include
+  proper executable targets, with filters to customize.
+  Arguments:
+    target_extras: Regular expression to always add, matching any target.
+    executable_target_pattern: Regular expression limiting executable targets.
+    spec: Specifications for target.
+  """
+  target_name = spec.get('target_name')
+  # Always include targets matching target_extras.
+  if target_extras is not None and re.search(target_extras, target_name):
+    return True
+
+  # Otherwise just show executable targets.
+  if spec.get('type', '') == 'executable' and \
+     spec.get('product_extension', '') != 'bundle':
+
+    # If there is a filter and the target does not match, exclude the target.
+    if executable_target_pattern is not None:
+      if not re.search(executable_target_pattern, target_name):
+        return False
+    return True
+  return False
+
 def CreateWrapper(target_list, target_dicts, data, params):
   """Initialize targets for the ninja wrapper.
 
   This sets up the necessary variables in the targets to generate Xcode projects
   that use ninja as an external builder.
   Arguments:
     target_list: List of target pairs: 'base/base.gyp:base'.
     target_dicts: Dict of target properties keyed on target pair.
     data: Dict of flattened build files keyed on gyp path.
     params: Dict of global options for gyp.
@@ skipping 16 matching lines @@
   new_target_dicts = {}
   new_data = {}
 
   # Set base keys needed for |data|.
   new_data[main_gyp] = {}
   new_data[main_gyp]['included_files'] = []
   new_data[main_gyp]['targets'] = []
   new_data[main_gyp]['xcode_settings'] = \
       data[orig_gyp].get('xcode_settings', {})
 
+  # Normally the xcode-ninja generator includes only valid executable targets.
+  # If |xcode_ninja_executable_target_pattern| is set, that list is reduced to
+  # executable targets that match the pattern. (Default all)
+  executable_target_pattern = \
+      generator_flags.get('xcode_ninja_executable_target_pattern', None)
+
+  # For including other non-executable targets, add the matching target name
+  # to the |xcode_ninja_target_pattern| regular expression. (Default none)
+  target_extras = generator_flags.get('xcode_ninja_target_pattern', None)
+
   for old_qualified_target in target_list:
     spec = target_dicts[old_qualified_target]
-    if spec.get('type', '') == 'executable' and \
-        spec.get('product_extension', '') != 'bundle':
-
+    if IsValidTargetForWrapper(target_extras, executable_target_pattern, spec):
       # Add to new_target_list.
       target_name = spec.get('target_name')
-
-      # Filter target names if requested.
-      target_filter = generator_flags.get('xcode_ninja_target_filter', None)
-      if target_filter is not None:
-        if not re.search(target_filter, target_name):
-          continue;
-
       new_target_name = '%s:%s#target' % (main_gyp, target_name)
       new_target_list.append(new_target_name)
 
       # Add to new_target_dicts.
       new_target_dicts[new_target_name] = _TargetFromSpec(spec, params)
 
       # Add to new_data.
       for old_target in data[old_qualified_target.split(':')[0]]['targets']:
         if old_target['target_name'] == target_name:
           new_data_target = {}
@@ skipping 46 matching lines @@
   new_data[sources_gyp] = {}
   new_data[sources_gyp]['targets'] = []
   new_data[sources_gyp]['included_files'] = []
   new_data[sources_gyp]['xcode_settings'] = \
       data[orig_gyp].get('xcode_settings', {})
   new_data[sources_gyp]['targets'].append(new_data_target)
 
   # Write workspace to file.
   _WriteWorkspace(main_gyp, sources_gyp)
   return (new_target_list, new_target_dicts, new_data)