Updates analyzer to output to a file

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 (as JSON) is output:
+The following is output:
 error: only supplied if there is an error.
+warning: only supplied if there is a warning.
 targets: the set of targets passed in via targets that either directly or
   indirectly depend upon the set of paths supplied in files.
 status: indicates if any of the supplied files matched at least one target.
+
+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
 import sys
 
 debug = False
@@ skipping 259 matching lines @@
   directly on indirectly) on the matched files.
   all_targets: mapping from target name to Target.
   possible_targets: targets to search from."""
   found = []
   for target in possible_targets:
     if _DoesTargetDependOn(all_targets[target], all_targets):
       # possible_targets was initially unqualified, keep it unqualified.
       found.append(gyp.common.ParseQualifiedTarget(target)[1])
   return found
 
+def _WriteOutput(params, **values):
+  """Writes the output, either to stdout or a file is specified."""
+  output_path = params.get('generator_flags', {}).get(
+      'analyzer_output_path', None)
+  if not output_path:
+    print json.dumps(values)
+    return
+  try:
+    f = open(output_path, 'w')
+    f.write(json.dumps(values) + '\n')
+    f.close()
+  except IOError as e:
+    print 'Error writing to output file', output_path, str(e)
+
 def CalculateVariables(default_variables, params):
   """Calculate additional variables for use in the build (called by gyp)."""
   flavor = gyp.common.GetFlavor(params)
   if flavor == 'mac':
     default_variables.setdefault('OS', 'mac')
   elif flavor == 'win':
     default_variables.setdefault('OS', 'win')
     # Copy additional generator configuration data from VS, which is shared
     # by the Windows Ninja generator.
     import gyp.generator.msvs as msvs_generator
@@ skipping 29 matching lines @@
 
     all_targets, matched = __GenerateTargets(target_list, target_dicts,
                                              toplevel_dir,
                                              frozenset(config.files))
 
     # Set of targets that refer to one of the files.
     if config.look_for_dependency_only:
       print found_dependency_string if matched else no_dependency_string
       return
 
+    warning = None
     if matched:
       unqualified_mapping = _GetUnqualifiedToQualifiedMapping(
           all_targets, config.targets)
       if len(unqualified_mapping) != len(config.targets):
         not_found = []
         for target in config.targets:
           if not target in unqualified_mapping:
             not_found.append(target)
-        raise Exception('Unable to find all targets: ' + str(not_found))
-      qualified_targets = [unqualified_mapping[x] for x in config.targets]
+        warning = 'Unable to find all targets: ' + str(not_found)
+      qualified_targets = []
+      for target in config.targets:
+        if target in unqualified_mapping:
+          qualified_targets.append(unqualified_mapping[target])
       output_targets = _GetTargetsDependingOn(all_targets, qualified_targets)
     else:
       output_targets = []
 
-    print json.dumps(
-      {'targets': output_targets,
-       'status': found_dependency_string if matched else no_dependency_string })
+    result_dict = { 'targets': output_targets,
+                    'status': found_dependency_string if matched else
+                              no_dependency_string }
+    if warning:
+      result_dict['warning'] = warning
+    _WriteOutput(params, **result_dict)
 
   except Exception as e:
-    print json.dumps({'error': str(e)})
+    _WriteOutput(params, error=str(e))