Removes old way to specify files to look for

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.
@@ skipping 149 matching lines @@
   """Holds information about a particular target:
   deps: set of the names of direct dependent targets.
   match_staus: one of the MatchStatus values"""
   def __init__(self):
     self.deps = set()
     self.match_status = MATCH_STATUS_TBD
 
 
 class Config(object):
   """Details what we're looking for
-  look_for_dependency_only: if true only search for a target listing any of
-                            the files in files.
   files: set of files to search for
   targets: see file description for details"""
   def __init__(self):
-    self.look_for_dependency_only = True
     self.files = []
     self.targets = []
 
   def Init(self, params):
-    """Initializes Config. This is a separate method as it may raise an
-    exception if there is a parse error."""
+    """Initializes Config. This is a separate method as it raises an exception
+    if there is a parse error."""
     generator_flags = params.get('generator_flags', {})
-    # TODO(sky): nuke file_path and look_for_dependency_only once migrate
-    # recipes.
-    file_path = generator_flags.get('file_path', None)
-    if file_path:
-      self._InitFromFilePath(file_path)
-      return
-
-    # If |file_path| wasn't specified then we look for config_path.
-    # TODO(sky): always look for config_path once migrated recipes.
     config_path = generator_flags.get('config_path', None)
     if not config_path:
       return
-    self.look_for_dependency_only = False
     try:
       f = open(config_path, 'r')
       config = json.load(f)
       f.close()
     except IOError:
       raise Exception('Unable to open file ' + config_path)
     except ValueError as e:
       raise Exception('Unable to parse config file ' + config_path + str(e))
     if not isinstance(config, dict):
       raise Exception('config_path must be a JSON file containing a dictionary')
     self.files = config.get('files', [])
     # Coalesce duplicates
     self.targets = list(set(config.get('targets', [])))
 
-  def _InitFromFilePath(self, file_path):
-    try:
-      f = open(file_path, 'r')
-      for file_name in f:
-        if file_name.endswith('\n'):
-          file_name = file_name[0:len(file_name) - 1]
-          if len(file_name):
-            self.files.append(file_name)
-      f.close()
-    except IOError:
-      raise Exception('Unable to open file', file_path)
-
 
 def _WasBuildFileModified(build_file, data, files):
   """Returns true if the build file |build_file| is either in |files| or
   one of the files included by |build_file| is in |files|."""
   if _ToGypPath(build_file) in files:
     if debug:
       print 'gyp file modified', build_file
     return True
 
   # First element of included_files is the file itself.
@@ skipping 150 matching lines @@
       operating_system = 'linux'  # Keep this legacy behavior for now.
     default_variables.setdefault('OS', operating_system)
 
 
 def GenerateOutput(target_list, target_dicts, data, params):
   """Called by gyp as the final stage. Outputs results."""
   config = Config()
   try:
     config.Init(params)
     if not config.files:
-      if config.look_for_dependency_only:
-        print 'Must specify files to analyze via file_path generator flag'
-        return
       raise Exception('Must specify files to analyze via config_path generator '
                       'flag')
 
     toplevel_dir = _ToGypPath(os.path.abspath(params['options'].toplevel_dir))
     if debug:
       print 'toplevel_dir', toplevel_dir
 
     matched = False
     matched_include = False
 
     # If one of the modified files is an include file then everything is
     # affected.
     if params['options'].includes:
       for include in params['options'].includes:
         if _ToGypPath(include) in config.files:
           if debug:
             print 'include path modified', include
           matched_include = True
           matched = True
           break
 
     if not matched:
       all_targets, matched = _GenerateTargets(data, 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_include:
       output_targets = config.targets
     elif 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)
         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 = []
 
     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:
     _WriteOutput(params, error=str(e))