Move file path functions into utils/file_path.py.

isolate.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Front end tool to operate on .isolate files.
 
 This includes creating, merging or compiling them to generate a .isolated file.
 
 See more information at
@@ skipping 18 matching lines @@
 import run_isolated
 import trace_inputs
 
 # Import here directly so isolate is easier to use as a library.
 from run_isolated import get_flavor
 
 from third_party import colorama
 from third_party.depot_tools import fix_encoding
 from third_party.depot_tools import subcommand
 
+from utils import file_path
 from utils import tools
 from utils import short_expression_finder
 
 
 __version__ = '0.1.1'
 
 
 PATH_VARIABLES = ('DEPTH', 'PRODUCT_DIR')
 
 # Files that should be 0-length when mapped.
@@ skipping 82 matching lines @@
 
 
 def path_starts_with(prefix, path):
   """Returns true if the components of the path |prefix| are the same as the
   initial components of |path| (or all of the components of |path|). The paths
   must be absolute.
   """
   assert os.path.isabs(prefix) and os.path.isabs(path)
   prefix = os.path.normpath(prefix)
   path = os.path.normpath(path)
-  assert prefix == trace_inputs.get_native_path_case(prefix), prefix
-  assert path == trace_inputs.get_native_path_case(path), path
+  assert prefix == file_path.get_native_path_case(prefix), prefix
+  assert path == file_path.get_native_path_case(path), path
   prefix = prefix.rstrip(os.path.sep) + os.path.sep
   path = path.rstrip(os.path.sep) + os.path.sep
   return path.startswith(prefix)
 
 
 def fix_native_path_case(root, path):
   """Ensures that each component of |path| has the proper native case by
      iterating slowly over the directory elements of |path|."""
   native_case_path = root
   for raw_part in path.split(os.sep):
     if not raw_part or raw_part == '.':
       break
 
-    part = trace_inputs.find_item_native_case(native_case_path, raw_part)
+    part = file_path.find_item_native_case(native_case_path, raw_part)
     if not part:
       raise isolateserver.MappingError(
           'Input file %s doesn\'t exist' %
           os.path.join(native_case_path, raw_part))
     native_case_path = os.path.join(native_case_path, part)
 
   return os.path.normpath(native_case_path)
 
 
 def expand_symlinks(indir, relfile):
   """Follows symlinks in |relfile|, but treating symlinks that point outside the
   build tree as if they were ordinary directories/files. Returns the final
   symlink-free target and a list of paths to symlinks encountered in the
   process.
 
   The rule about symlinks outside the build tree is for the benefit of the
   Chromium OS ebuild, which symlinks the output directory to an unrelated path
   in the chroot.
 
   Fails when a directory loop is detected, although in theory we could support
   that case.
   """
   is_directory = relfile.endswith(os.path.sep)
   done = indir
   todo = relfile.strip(os.path.sep)
   symlinks = []
 
   while todo:
-    pre_symlink, symlink, post_symlink = trace_inputs.split_at_symlink(
+    pre_symlink, symlink, post_symlink = file_path.split_at_symlink(
         done, todo)
     if not symlink:
       todo = fix_native_path_case(done, todo)
       done = os.path.join(done, todo)
       break
     symlink_path = os.path.join(done, pre_symlink, symlink)
     post_symlink = post_symlink.lstrip(os.path.sep)
     # readlink doesn't exist on Windows.
     # pylint: disable=E1101
     target = os.path.normpath(os.path.join(done, pre_symlink))
     symlink_target = os.readlink(symlink_path)
     if os.path.isabs(symlink_target):
       # Absolute path are considered a normal directories. The use case is
       # generally someone who puts the output directory on a separate drive.
       target = symlink_target
     else:
       # The symlink itself could be using the wrong path case.
       target = fix_native_path_case(target, symlink_target)
 
     if not os.path.exists(target):
       raise isolateserver.MappingError(
           'Symlink target doesn\'t exist: %s -> %s' % (symlink_path, target))
-    target = trace_inputs.get_native_path_case(target)
+    target = file_path.get_native_path_case(target)
     if not path_starts_with(indir, target):
       done = symlink_path
       todo = post_symlink
       continue
     if path_starts_with(target, symlink_path):
       raise isolateserver.MappingError(
           'Can\'t map recursive symlink reference %s -> %s' %
           (symlink_path, target))
     logging.info('Found symlink: %s -> %s', symlink_path, target)
     symlinks.append(os.path.relpath(symlink_path, indir))
@@ skipping 28 matching lines @@
   if os.path.isabs(relfile):
     raise isolateserver.MappingError(
         'Can\'t map absolute path %s' % relfile)
 
   infile = normpath(os.path.join(indir, relfile))
   if not infile.startswith(indir):
     raise isolateserver.MappingError(
         'Can\'t map file %s outside %s' % (infile, indir))
 
   filepath = os.path.join(indir, relfile)
-  native_filepath = trace_inputs.get_native_path_case(filepath)
+  native_filepath = file_path.get_native_path_case(filepath)
   if filepath != native_filepath:
     # Special case './'.
     if filepath != native_filepath + '.' + os.path.sep:
       # Give up enforcing strict path case on OSX. Really, it's that sad. The
       # case where it happens is very specific and hard to reproduce:
       # get_native_path_case(
       #    u'Foo.framework/Versions/A/Resources/Something.nib') will return
       # u'Foo.framework/Versions/A/resources/Something.nib', e.g. lowercase 'r'.
       #
       # Note that this is really something deep in OSX because running
       # ls Foo.framework/Versions/A
-      # will print out 'Resources', while trace_inputs.get_native_path_case()
+      # will print out 'Resources', while file_path.get_native_path_case()
       # returns a lower case 'r'.
       #
       # So *something* is happening under the hood resulting in the command 'ls'
       # and Carbon.File.FSPathMakeRef('path').FSRefMakePath() to disagree.  We
       # have no idea why.
       if sys.platform != 'darwin':
         raise isolateserver.MappingError(
             'File path doesn\'t equal native file path\n%s != %s' %
             (filepath, native_filepath))
 
@@ skipping 189 matching lines @@
     if prevdict.get('t') == out['t']:
       # Reuse the previous link destination if available.
       out['l'] = prevdict.get('l')
     if out.get('l') is None:
       # The link could be in an incorrect path case. In practice, this only
       # happen on OSX on case insensitive HFS.
       # TODO(maruel): It'd be better if it was only done once, in
       # expand_directory_and_symlink(), so it would not be necessary to do again
       # here.
       symlink_value = os.readlink(filepath)  # pylint: disable=E1101
-      filedir = trace_inputs.get_native_path_case(os.path.dirname(filepath))
+      filedir = file_path.get_native_path_case(os.path.dirname(filepath))
       native_dest = fix_native_path_case(filedir, symlink_value)
       out['l'] = os.path.relpath(native_dest, filedir)
   return out
 
 
 ### Variable stuff.
 
 
 def isolatedfile_to_state(filename):
   """Replaces the file's extension."""
@@ skipping 33 matching lines @@
     return variables[m.group(1)]
   return part
 
 
 def process_variables(cwd, variables, relative_base_dir):
   """Processes path variables as a special case and returns a copy of the dict.
 
   For each 'path' variable: first normalizes it based on |cwd|, verifies it
   exists then sets it as relative to relative_base_dir.
   """
-  relative_base_dir = trace_inputs.get_native_path_case(relative_base_dir)
+  relative_base_dir = file_path.get_native_path_case(relative_base_dir)
   variables = variables.copy()
   for i in PATH_VARIABLES:
     if i not in variables:
       continue
     variable = variables[i].strip()
     # Variables could contain / or \ on windows. Always normalize to
     # os.path.sep.
     variable = variable.replace('/', os.path.sep)
     variable = os.path.join(cwd, variable)
     variable = os.path.normpath(variable)
-    variable = trace_inputs.get_native_path_case(variable)
+    variable = file_path.get_native_path_case(variable)
     if not os.path.isdir(variable):
       raise ExecutionError('%s=%s is not a directory' % (i, variable))
 
     # All variables are relative to the .isolate file.
     variable = os.path.relpath(variable, relative_base_dir)
     logging.debug(
         'Translated variable %s from %s to %s', i, variables[i], variable)
     variables[i] = variable
   return variables
 
@@ skipping 1120 matching lines @@
             isolatedfile_to_state(isolated_filepath), isolated_basedir))
 
   def load_isolate(self, cwd, isolate_file, variables, ignore_broken_items):
     """Updates self.isolated and self.saved_state with information loaded from a
     .isolate file.
 
     Processes the loaded data, deduce root_dir, relative_cwd.
     """
     # Make sure to not depend on os.getcwd().
     assert os.path.isabs(isolate_file), isolate_file
-    isolate_file = trace_inputs.get_native_path_case(isolate_file)
+    isolate_file = file_path.get_native_path_case(isolate_file)
     logging.info(
         'CompleteState.load_isolate(%s, %s, %s, %s)',
         cwd, isolate_file, variables, ignore_broken_items)
     relative_base_dir = os.path.dirname(isolate_file)
 
     # Processes the variables and update the saved state.
     variables = process_variables(cwd, variables, relative_base_dir)
     self.saved_state.update(isolate_file, variables)
     variables = self.saved_state.variables
 
@@ skipping 108 matching lines @@
       raise ExecutionError('Please specify --isolate')
     isolate_dir = os.path.dirname(self.saved_state.isolate_filepath)
     # Special case '.'.
     if self.saved_state.relative_cwd == '.':
       root_dir = isolate_dir
     else:
       assert isolate_dir.endswith(self.saved_state.relative_cwd), (
           isolate_dir, self.saved_state.relative_cwd)
       # Walk back back to the root directory.
       root_dir = isolate_dir[:-(len(self.saved_state.relative_cwd) + 1)]
-    return trace_inputs.get_native_path_case(root_dir)
+    return file_path.get_native_path_case(root_dir)
 
   @property
   def resultdir(self):
     """Returns the absolute path containing the .isolated file.
 
     It is usually equivalent to the variable PRODUCT_DIR. Uses the .isolated
     path as the value.
     """
     return os.path.dirname(self.isolated_filepath)
 
@@ skipping 20 matching lines @@
              options.isolate and options.isolated, if the value is set, it is an
              absolute path.
     cwd: base directory to be used when loading the .isolate file.
     subdir: optional argument to only process file in the subdirectory, relative
             to CompleteState.root_dir.
     skip_update: Skip trying to load the .isolate file and processing the
                  dependencies. It is useful when not needed, like when tracing.
   """
   assert not options.isolate or os.path.isabs(options.isolate)
   assert not options.isolated or os.path.isabs(options.isolated)
-  cwd = trace_inputs.get_native_path_case(unicode(cwd))
+  cwd = file_path.get_native_path_case(unicode(cwd))
   if options.isolated:
     # Load the previous state if it was present. Namely, "foo.isolated.state".
     # Note: this call doesn't load the .isolate file.
     complete_state = CompleteState.load_files(options.isolated)
   else:
     # Constructs a dummy object that cannot be saved. Useful for temporary
     # commands like 'run'.
     complete_state = CompleteState(None, SavedState())
 
   if not options.isolate:
@@ skipping 548 matching lines @@
   def parse_args(self, *args, **kwargs):
     """Makes sure the paths make sense.
 
     On Windows, / and \ are often mixed together in a path.
     """
     options, args = tools.OptionParserWithLogging.parse_args(
         self, *args, **kwargs)
     if not self.allow_interspersed_args and args:
       self.error('Unsupported argument: %s' % args)
 
-    cwd = trace_inputs.get_native_path_case(unicode(os.getcwd()))
+    cwd = file_path.get_native_path_case(unicode(os.getcwd()))
     parse_isolated_option(self, options, cwd, self.require_isolated)
     parse_variable_option(options)
 
     if options.isolate:
       # TODO(maruel): Work with non-ASCII.
       # The path must be in native path case for tracing purposes.
       options.isolate = unicode(options.isolate).replace('/', os.path.sep)
       options.isolate = os.path.normpath(os.path.join(cwd, options.isolate))
-      options.isolate = trace_inputs.get_native_path_case(options.isolate)
+      options.isolate = file_path.get_native_path_case(options.isolate)
 
     if options.outdir and not is_url(options.outdir):
       options.outdir = unicode(options.outdir).replace('/', os.path.sep)
       # outdir doesn't need native path case since tracing is never done from
       # there.
       options.outdir = os.path.normpath(os.path.join(cwd, options.outdir))
 
     return options, args
 
 
 def main(argv):
   dispatcher = subcommand.CommandDispatcher(__name__)
   try:
     return dispatcher.execute(OptionParserIsolate(version=__version__), argv)
   except (
       ExecutionError,
       isolateserver.ConfigError,
       isolateserver.MappingError) as e:
     sys.stderr.write('\nError: ')
     sys.stderr.write(str(e))
     sys.stderr.write('\n')
     return 1
 
 
 if __name__ == '__main__':
   fix_encoding.fix_encoding()
   tools.disable_buffering()
   colorama.init()
   sys.exit(main(sys.argv[1:]))