Adds support for detecting modified gyp* files to analyzer

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 46 matching lines @@
   generator_default_variables[dirname] = '!!!'
 
 for unused in ['RULE_INPUT_PATH', 'RULE_INPUT_ROOT', 'RULE_INPUT_NAME',
                'RULE_INPUT_DIRNAME', 'RULE_INPUT_EXT',
                'EXECUTABLE_PREFIX', 'EXECUTABLE_SUFFIX',
                'STATIC_LIB_PREFIX', 'STATIC_LIB_SUFFIX',
                'SHARED_LIB_PREFIX', 'SHARED_LIB_SUFFIX',
                'CONFIGURATION_NAME']:
   generator_default_variables[unused] = ''
 
+def _ToGypPath(path):

[scottmg, 2014/08/05 23:02:43]

I don't understand why some functions are _ and some are __?

[sky, 2014/08/06 00:26:07]

Indeed. Python sites recommend __, which is why I went with that. Then I saw the
Google Python guide which said '_', so I've started doing that. I plan on doing
a cleanup pass and straightening this all out shortly.

+  """Converts a path to the format used by gyp."""
+  if os.sep == '\\' and os.altsep == '/':
+    return path.replace('\\', '/')
+  return path
+
 def __ExtractBasePath(target):
   """Extracts the path components of the specified gyp target path."""
   last_index = target.rfind('/')
   if last_index == -1:
     return ''
   return target[0:(last_index + 1)]
 
 def __ResolveParent(path, base_path_components):
   """Resolves |path|, which starts with at least one '../'. Returns an empty
   string if the path shouldn't be considered. See __AddSources() for a
@@ skipping 36 matching lines @@
 
 def __ExtractSourcesFromAction(action, base_path, base_path_components,
                                results):
   if 'inputs' in action:
     __AddSources(action['inputs'], base_path, base_path_components, results)
 
 def __ExtractSources(target, target_dict, toplevel_dir):
   # |target| is either absolute or relative and in the format of the OS. Gyp
   # source paths are always posix. Convert |target| to a posix path relative to
   # |toplevel_dir_|. This is done to make it easy to build source paths.
-  if os.sep == '\\' and os.altsep == '/':
-    base_path = target.replace('\\', '/')
-  else:
-    base_path = target
+  base_path = _ToGypPath(target)
   if base_path == toplevel_dir:
     base_path = ''
   elif base_path.startswith(toplevel_dir + '/'):
     base_path = base_path[len(toplevel_dir) + len('/'):]
   base_path = posixpath.dirname(base_path)
   base_path_components = base_path.split('/')
 
   # Add a trailing '/' so that __AddSources() can easily build paths.
   if len(base_path):
     base_path += '/'
@@ skipping 72 matching lines @@
       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 __GenerateTargets(target_list, target_dicts, toplevel_dir, files):
+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.
+  if len(data[build_file]['included_files']) <= 1:
+    return False
+
+  for include_file in data[build_file]['included_files'][1:]:
+    # |included_files| are relative to the directory of the |build_file|.
+    rel_include_file = \
+        _ToGypPath(gyp.common.UnrelativePath(include_file, build_file))
+    if rel_include_file in files:
+      if debug:
+        print 'included gyp file modified, gyp_file=', build_file, \
+            'included file=', rel_include_file
+      return True
+  return False
+
+def __GenerateTargets(data, target_list, target_dicts, toplevel_dir, files):
   """Generates a dictionary with the key the name of a target and the value a
   Target. |toplevel_dir| is the root of the source tree. If the sources of
   a target match that of |files|, then |target.matched| is set to True.
   This returns a tuple of the dictionary and whether at least one target's
   sources listed one of the paths in |files|."""
   targets = {}
 
   # Queue of targets to visit.
   targets_to_visit = target_list[:]
 
   matched = False
 
+  # Maps from build file to a boolean indicating whether the build file is in
+  # |files|.
+  build_file_in_files = {}
+
   while len(targets_to_visit) > 0:
     target_name = targets_to_visit.pop()
     if target_name in targets:
       continue
 
     target = Target()
     targets[target_name] = target
-    sources = __ExtractSources(target_name, target_dicts[target_name],
-                               toplevel_dir)
-    for source in sources:
-      if source in files:
-        target.match_status = MATCH_STATUS_MATCHES
-        matched = True
-        break
+
+    build_file = gyp.common.ParseQualifiedTarget(target_name)[0]
+    if not build_file in build_file_in_files:
+      build_file_in_files[build_file] = \
+          _WasBuildFileModified(build_file, data, files)
+
+    # If a build file (or any of its included files) is modified we assume all
+    # targets in the file are modified.
+    if build_file_in_files[build_file]:
+      target.match_status = MATCH_STATUS_MATCHES
+      matched = True
+    else:
+      sources = __ExtractSources(target_name, target_dicts[target_name],
+                                 toplevel_dir)
+      for source in sources:
+        if source in files:
+          target.match_status = MATCH_STATUS_MATCHES
+          matched = True
+          break
 
     for dep in target_dicts[target_name].get('dependencies', []):
       targets[target_name].deps.add(dep)
       targets_to_visit.append(dep)
 
   return targets, matched
 
 def _GetUnqualifiedToQualifiedMapping(all_targets, to_find):
   """Returns a mapping (dictionary) from unqualified name to qualified name for
   all the targets in |to_find|."""
@@ skipping 82 matching lines @@
   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 = os.path.abspath(params['options'].toplevel_dir)
-    if os.sep == '\\' and os.altsep == '/':
-      toplevel_dir = toplevel_dir.replace('\\', '/')
+    toplevel_dir = _ToGypPath(os.path.abspath(params['options'].toplevel_dir))
     if debug:
       print 'toplevel_dir', toplevel_dir
 
-    all_targets, matched = __GenerateTargets(target_list, target_dicts,
-                                             toplevel_dir,
-                                             frozenset(config.files))
+    matched = False
+    matched_include = False
+
+    # If one of the modified files is an include file then everything is
+    # effected.

[scottmg, 2014/08/05 23:02:43]

nit; affected.

[sky, 2014/08/06 00:26:07]

I ALWAYS get that wrong.

+    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:
+    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))