Moves warning about invalid targets into 'invalid_targets' in result

pylib/gyp/generator/analyzer.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.
 
 """
 This script is intended for use as a GYP_GENERATOR. It takes as input (by way of
 the generator flag config_path) the path of a json file that dictates the files
 and targets to search for. The following keys are supported:
 files: list of paths (relative) of the files to search for.
 targets: list of targets to search for. The target names are unqualified.
 
 The following is output:
 error: only supplied if there is an error.
 warning: only supplied if there is a warning.

[scottmg, 2014/10/24 16:27:58]

delete this

[sky, 2014/10/24 16:30:12]

Done.

 targets: the set of targets passed in via targets that either directly or
   indirectly depend upon the set of paths supplied in files.
 build_targets: minimal set of targets that directly depend on the changed
   files and need to be built. The expectation is this set of targets is passed
   into a build step.
 status: outputs one of three values: none of the supplied files were found,
   one of the include files changed so that it should be assumed everything
   changed (in this case targets and build_targets are not output) or at
   least one file was found.
+invalid_targets: list of supplied targets thare were not found.
 
 If the generator flag analyzer_output_path is specified, output is written
 there. Otherwise output is written to stdout.
 """
 
 import gyp.common
 import gyp.ninja_syntax as ninja_syntax
 import json
 import os
 import posixpath
@@ skipping 403 matching lines @@
   """Writes the output, either to stdout or a file is specified."""
   if 'error' in values:
     print 'Error:', values['error']
   if 'status' in values:
     print values['status']
   if 'targets' in values:
     values['targets'].sort()
     print 'Supplied targets that depend on changed files:'
     for target in values['targets']:
       print '\t', target
+  if 'invalid_targets' in values:
+    values['invalid_targets'].sort()
+    print 'The following targets were not found:'
+    for target in values['invalid_targets']:
+      print '\t', target
   if 'build_targets' in values:
     values['build_targets'].sort()
     print 'Targets that require a build:'
     for target in values['build_targets']:
       print '\t', target
 
   output_path = params.get('generator_flags', {}).get(
       'analyzer_output_path', None)
   if not output_path:
     print json.dumps(values)
@@ skipping 67 matching lines @@
     if _WasGypIncludeFileModified(params, config.files):
       result_dict = { 'status': all_changed_string,
                       'targets': list(config.targets) }
       _WriteOutput(params, **result_dict)
       return
 
     all_targets, matching_targets, roots = _GenerateTargets(
       data, target_list, target_dicts, toplevel_dir, frozenset(config.files),
       params['build_files'])
 
-    warning = None
     unqualified_mapping = _GetUnqualifiedToTargetMapping(all_targets,
                                                          config.targets)
+    invalid_targets = None
     if len(unqualified_mapping) != len(config.targets):
-      not_found = _NamesNotIn(config.targets, unqualified_mapping)
-      warning = 'Unable to find all targets: ' + str(not_found)
+      invalid_targets = _NamesNotIn(config.targets, unqualified_mapping)
 
     if matching_targets:
       search_targets = _LookupTargets(config.targets, unqualified_mapping)
       matched_search_targets = _GetTargetsDependingOn(search_targets)
       # Reset the visited status for _GetBuildTargets.
       for target in all_targets.itervalues():
         target.visited = False
       build_targets = _GetBuildTargets(matching_targets, roots)
       matched_search_targets = [gyp.common.ParseQualifiedTarget(target.name)[1]
                                 for target in matched_search_targets]
       build_targets = [gyp.common.ParseQualifiedTarget(target.name)[1]
                        for target in build_targets]
     else:
       matched_search_targets = []
       build_targets = []
 
     result_dict = { 'targets': matched_search_targets,
                     'status': found_dependency_string if matching_targets else
                               no_dependency_string,
                     'build_targets': build_targets}
-    if warning:
-      result_dict['warning'] = warning
+    if invalid_targets:
+      result_dict['invalid_targets'] = invalid_targets
     _WriteOutput(params, **result_dict)
 
   except Exception as e:
     _WriteOutput(params, error=str(e))