Fixes bug in path handling of 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 file_path) the list of relative file paths to consider. If
 any target has at least one of the paths as a source (or input to an action or
 rule) then 'Found dependency' is output, otherwise 'No dependencies' is output.
 """
@@ skipping 14 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 __MakeRelativeTargetName(path):
+def __MakeRelativeTargetName(path, toplevel_dir):
   """Converts a gyp target name into a relative name. For example, the path to a
   gyp file may be something like c:\foo\bar.gyp:target, this converts it to
   bar.gyp.
   """
-  prune_path = os.getcwd()
-  if path.startswith(prune_path):
-    path = path[len(prune_path):]
+  if path.startswith(toplevel_dir):

[Mark Mentovai, 2014/07/14 18:10:55]

This should be
  if path == toplevel_dir or path.startswith(toplevel_dir + '/'):

because /home/skyguy shouldn’t be considered to “start with” /home/sky.

+    path = path[len(toplevel_dir):]
     if len(path) and path.startswith(os.sep):
       path = path[len(os.sep):]
   # Gyp paths are always posix style.
   path = path.replace('\\', '/')
   if path.endswith('#target'):
     path = path[0:len(path) - len('#target')]
   return path
 
 def __ExtractBasePath(target):
   """Extracts the path components of the specified gyp target path."""
@@ skipping 68 matching lines @@
 
 class Target(object):
   """Holds information about a particular target:
   sources: set of source files defined by this target. This includes inputs to
            actions and rules.
   deps: list of direct dependencies."""
   def __init__(self):
     self.sources = []
     self.deps = []
 
-def __GenerateTargets(target_list, target_dicts):
+def __GenerateTargets(target_list, target_dicts, toplevel_dir):
   """Generates a dictionary with the key the name of a target and the value a
-  Target."""
+  Target. |toplevel_dir| is the root of the source tree."""
   targets = {}
 
   # Queue of targets to visit.
   targets_to_visit = target_list[:]
 
   while len(targets_to_visit) > 0:
     absolute_target_name = targets_to_visit.pop()
     # |absolute_target| may be an absolute path and may include #target.
     # References to targets are relative, so we need to clean the name.
-    relative_target_name = __MakeRelativeTargetName(absolute_target_name)
+    relative_target_name = __MakeRelativeTargetName(absolute_target_name,
+                                                    toplevel_dir)
     if relative_target_name in targets:
       continue
 
     target = Target()
     targets[relative_target_name] = target
     target.sources.extend(__ExtractSources(relative_target_name,
                                            target_dicts[absolute_target_name]))
 
     for dep in target_dicts[absolute_target_name].get('dependencies', []):
-      targets[relative_target_name].deps.append(__MakeRelativeTargetName(dep))
+      targets[relative_target_name].deps.append(
+        __MakeRelativeTargetName(dep, toplevel_dir))
       targets_to_visit.append(dep)
 
   return targets
 
 def __GetFiles(params):
   """Returns the list of files to analyze, or None if none specified."""
   generator_flags = params.get('generator_flags', {})
   file_path = generator_flags.get('file_path', None)
   if not file_path:
     return None
@@ skipping 33 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."""
   files = __GetFiles(params)
   if not files:
     print 'Must specify files to analyze via file_path generator flag'
     return
 
-  targets = __GenerateTargets(target_list, target_dicts)
+  targets = __GenerateTargets(target_list, target_dicts,
+                              os.path.abspath(params['options'].toplevel_dir))
 
   files_set = frozenset(files)
   found_in_all_sources = 0
   for target_name, target in targets.iteritems():
     sources = files_set.intersection(target.sources)
     if len(sources):
       print 'Found dependency'
       return
 
   print 'No dependencies'