src/com/facebook/buck/io/MorePaths.java - buck - Git at Google

 /*
  * Copyright 2013-present Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may
  * not use this file except in compliance with the License. You may obtain
  * a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * License for the specific language governing permissions and limitations
  * under the License.
  */

 package com.facebook.buck.io;

 import com.facebook.buck.util.BuckConstant;
 import com.google.common.base.Function;
 import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
 import com.google.common.base.Predicate;
 import com.google.common.base.Throwables;
 import com.google.common.collect.FluentIterable;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ImmutableSortedSet;

 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.file.Files;
 import java.nio.file.NoSuchFileException;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.security.DigestInputStream;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.util.Arrays;
 import java.util.Collection;

 import javax.annotation.Nullable;

 public class MorePaths {

   /**
    * Returns true iff a path on the filesystem exists, is a regular file, and is executable.
    */
   public static final Function<Path, Boolean> DEFAULT_PATH_IS_EXECUTABLE_CHECKER =
       new Function<Path, Boolean>() {
         @Override
         public Boolean apply(Path path) {
           return Files.isRegularFile(path) &&
               Files.isExecutable(path);
         }
       };

   /** Utility class: do not instantiate. */
   private MorePaths() {}

   public static final Function<String, Path> TO_PATH = new Function<String, Path>() {
     @Override
     public Path apply(String path) {
       return Paths.get(path);
     }
   };

   public static String pathWithUnixSeparators(String path) {
     return pathWithUnixSeparators(Paths.get(path));
   }

   public static String pathWithUnixSeparators(Path path) {
     return path.toString().replace("\\", "/");
   }

   /**
    * @param toMakeAbsolute The {@link Path} to act upon.
    * @return The Path, made absolute and normalized.
    */
   public static Path absolutify(Path toMakeAbsolute) {
     return toMakeAbsolute.toAbsolutePath().normalize();
   }

   /**
    * Get the path of a file relative to a base directory.
    *
    * @param path must reference a file, not a directory.
    * @param baseDir must reference a directory that is relative to a common directory with the path.
    *     may be null if referencing the same directory as the path.
    * @return the relative path of path from the directory baseDir.
    */
   public static Path getRelativePath(Path path, @Nullable Path baseDir) {
     if (baseDir == null) {
       // This allows callers to use this method with "file.parent()" for files from the project
       // root dir.
       baseDir = Paths.get("");
     }
     Preconditions.checkArgument(!path.isAbsolute(),
         "Path must be relative: %s.", path);
     Preconditions.checkArgument(!baseDir.isAbsolute(),
         "Path must be relative: %s.", baseDir);
     return relativize(baseDir, path);
   }

   /**
    * Get a relative path from path1 to path2, first normalizing each path.
    *
    * This method is a workaround for JDK-6925169 (Path.relativize
    * returns incorrect result if path contains "." or "..").
    */
   public static Path relativize(Path path1, Path path2) {
     Path emptyPath = Paths.get("");

     Preconditions.checkArgument(
         path1.isAbsolute() == path2.isAbsolute(),
         "Both paths must be absolute or both paths must be relative. (%s is %s, %s is %s)",
         path1,
         path1.isAbsolute() ? "absolute" : "relative",
         path2,
         path2.isAbsolute() ? "absolute" : "relative");

     // Work around JDK-8037945 (Paths.get("").normalize() throws ArrayIndexOutOfBoundsException).
     if (!path1.equals(emptyPath)) {
       path1 = path1.normalize();
     }
     if (!path2.equals(emptyPath)) {
       path2 = path2.normalize();
     }

     // On Windows, if path1 is "" then Path.relativize returns ../path2 instead of path2 or ./path2
     if (path1.equals(emptyPath)) {
       return path2;
     }
     return path1.relativize(path2);
   }

   /**
    * Creates a symlink at
    * {@code projectFilesystem.getRootPath().resolve(pathToDesiredLinkUnderProjectRoot)} that
    * points to {@code projectFilesystem.getRootPath().resolve(pathToExistingFileUnderProjectRoot)}
    * using a relative symlink.
    *
    * @param pathToDesiredLinkUnderProjectRoot must reference a file, not a directory.
    * @param pathToExistingFileUnderProjectRoot must reference a file, not a directory.
    * @return the relative path from the new symlink that was created to the existing file.
    */
   public static Path createRelativeSymlink(
       Path pathToDesiredLinkUnderProjectRoot,
       Path pathToExistingFileUnderProjectRoot,
       ProjectFilesystem projectFilesystem) throws IOException {
     return createRelativeSymlink(
         pathToDesiredLinkUnderProjectRoot,
         pathToExistingFileUnderProjectRoot,
         projectFilesystem.getRootPath());
   }

   /**
    * Creates a symlink at {@code pathToProjectRoot.resolve(pathToDesiredLinkUnderProjectRoot)} that
    * points to {@code pathToProjectRoot.resolve(pathToExistingFileUnderProjectRoot)} using a
    * relative symlink. Both params must be relative to the project root.
    *
    * @param pathToDesiredLinkUnderProjectRoot must reference a file, not a directory.
    * @param pathToExistingFileUnderProjectRoot must reference a file, not a directory.
    * @return the relative path from the new symlink that was created to the existing file.
    */
   public static Path createRelativeSymlink(
       Path pathToDesiredLinkUnderProjectRoot,
       Path pathToExistingFileUnderProjectRoot,
       Path pathToProjectRoot) throws IOException {
     Path target = getRelativePath(
         pathToExistingFileUnderProjectRoot,
         pathToDesiredLinkUnderProjectRoot.getParent());
     Files.createSymbolicLink(pathToProjectRoot.resolve(pathToDesiredLinkUnderProjectRoot), target);
     return target;
   }

   /**
    * Convert a set of input file paths as strings to {@link Path} objects.
    */
   public static ImmutableSortedSet<Path> asPaths(Iterable<String> paths) {
     ImmutableSortedSet.Builder<Path> builder = ImmutableSortedSet.naturalOrder();
     for (String path : paths) {
       builder.add(TO_PATH.apply(path));
     }
     return builder.build();
   }

   /**
    * Filters out {@link Path} objects from {@code paths} that aren't a subpath of {@code root} and
    * returns a set of paths relative to {@code root}.
    */
   public static ImmutableSet<Path> filterForSubpaths(Iterable<Path> paths, final Path root) {
     final Path normalizedRoot = root.toAbsolutePath().normalize();
     return FluentIterable.from(paths)
         .filter(new Predicate<Path>() {
           @Override
           public boolean apply(Path input) {
             if (input.isAbsolute()) {
               return input.normalize().startsWith(normalizedRoot);
             } else {
               return true;
             }
           }
         })
         .transform(new Function<Path, Path>() {
           @Override
           public Path apply(Path input) {
             if (input.isAbsolute()) {
               return relativize(normalizedRoot, input);
             } else {
               return input;
             }
           }
         })
         .toSet();
   }

   /**
    * @return Whether the input path directs to a file in the buck generated files folder.
    */
   public static boolean isGeneratedFile(Path pathRelativeToProjectRoot) {
     return pathRelativeToProjectRoot.startsWith(BuckConstant.GEN_PATH);
   }

   /**
    * Expands "~/foo" into "/home/zuck/foo". Returns regular paths unmodified.
    */
   public static Path expandHomeDir(Path path) {
     if (!path.startsWith("~")) {
       return path;
     }
     Path homePath = Paths.get(System.getProperty("user.home"));
     if (path.equals(Paths.get("~"))) {
       return homePath;
     }
     return homePath.resolve(path.subpath(1, path.getNameCount()));
   }

   public static boolean fileContentsDiffer(
       InputStream contents,
       Path path,
       ProjectFilesystem projectFilesystem) throws IOException {
     try {
       // Hash the contents of the file at path so we don't have to pull the whole thing into memory.
       MessageDigest sha1 = MessageDigest.getInstance("SHA-1");
       byte[] pathDigest;
       try (InputStream is = projectFilesystem.newFileInputStream(path)) {
           pathDigest = inputStreamDigest(is, sha1);
       }
       // Hash 'contents' and see if the two differ.
       sha1.reset();
       byte[] contentsDigest = inputStreamDigest(contents, sha1);
       return !Arrays.equals(pathDigest, contentsDigest);
     } catch (NoSuchFileException e) {
       // If the file doesn't exist, we need to create it.
       return true;
     } catch (NoSuchAlgorithmException e) {
       throw Throwables.propagate(e);
     }
   }

   /**
    * Looks for {@code executableToFind} under each entry of {@code pathsToSearch} and returns
    * the full path ({@code pathToSearch/executableToFind)}) to the first one which
    * exists on disk as an executable file.
    *
    * This is similar to the {@code which} command in Unix, but handles the various extensions
    * that are configured by Windows (when supplied with valid {@code extensions}).
    *
    * {@code executableToFind} must be a relative path.
    *
    * If none are found, returns {@link Optional#absent()}.
    */
   public static Optional<Path> searchPathsForExecutable(
       Path executableToFind,
       Collection<Path> pathsToSearch,
       Collection<String> extensions) {
     return searchPathsForExecutable(
         executableToFind,
         pathsToSearch,
         extensions,
         DEFAULT_PATH_IS_EXECUTABLE_CHECKER);
   }

   /**
    * Looks for {@code executableToFind} under each entry of {@code pathsToSearch} and returns
    * the full path ({@code pathToSearch/executableToFind)}) to the first one for which
    * {@code pathIsExecutableChecker(path)} returns true.
    *
    * This is similar to the {@code which} command in Unix, but handles the various extensions
    * that are configured by Windows (when supplied with valid {@code extensions}).
    *
    * {@code executableToFind} must be a relative path.
    *
    * If none are found, returns {@link Optional#absent()}.
    */
   public static Optional<Path> searchPathsForExecutable(
       Path executableToFind,
       Collection<Path> pathsToSearch,
       Collection<String> extensions,
       Function<Path, Boolean> pathIsExecutableChecker) {
     Preconditions.checkArgument(
         !executableToFind.isAbsolute(),
         "Path %s must be relative",
         executableToFind);

     for (Path pathToSearch : pathsToSearch) {
       Optional<Path> maybeResolved = resolveExecutable(
           pathToSearch,
           executableToFind,
           extensions,
           pathIsExecutableChecker);
       if (maybeResolved.isPresent()) {
         return maybeResolved;
       }
     }
     return Optional.absent();
   }

   private static Optional<Path> resolveExecutable(
       Path base,
       Path executableToFind,
       Collection<String> extensions,
       Function<Path, Boolean> pathIsExecutableChecker) {
     if (extensions.isEmpty()) {
       Path resolved = base.resolve(executableToFind);
       if (pathIsExecutableChecker.apply(resolved)) {
         return Optional.of(resolved);
       }
       return Optional.absent();
     }
     for (String pathExt : extensions) {
       Path resolved = base.resolve(executableToFind + pathExt);
       if (pathIsExecutableChecker.apply(resolved)) {
         return Optional.of(resolved);
       }
     }
     return Optional.absent();
   }

   private static byte[] inputStreamDigest(InputStream inputStream, MessageDigest messageDigest)
       throws IOException {
     try (DigestInputStream dis = new DigestInputStream(inputStream, messageDigest)) {
       byte[] buf = new byte[4096];
       while (true) {
         // Read the contents of the existing file so we can hash it.
         if (dis.read(buf) == -1) {
           break;
         }
       }
       return dis.getMessageDigest().digest();
     }
   }
 }
	/*
	* Copyright 2013-present Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License"); you may
	* not use this file except in compliance with the License. You may obtain
	* a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	* License for the specific language governing permissions and limitations
	* under the License.
	*/

	package com.facebook.buck.io;

	import com.facebook.buck.util.BuckConstant;
	import com.google.common.base.Function;
	import com.google.common.base.Optional;
	import com.google.common.base.Preconditions;
	import com.google.common.base.Predicate;
	import com.google.common.base.Throwables;
	import com.google.common.collect.FluentIterable;
	import com.google.common.collect.ImmutableSet;
	import com.google.common.collect.ImmutableSortedSet;

	import java.io.IOException;
	import java.io.InputStream;
	import java.nio.file.Files;
	import java.nio.file.NoSuchFileException;
	import java.nio.file.Path;
	import java.nio.file.Paths;
	import java.security.DigestInputStream;
	import java.security.MessageDigest;
	import java.security.NoSuchAlgorithmException;
	import java.util.Arrays;
	import java.util.Collection;

	import javax.annotation.Nullable;

	public class MorePaths {

	/**
	* Returns true iff a path on the filesystem exists, is a regular file, and is executable.
	*/
	public static final Function<Path, Boolean> DEFAULT_PATH_IS_EXECUTABLE_CHECKER =
	new Function<Path, Boolean>() {
	@Override
	public Boolean apply(Path path) {
	return Files.isRegularFile(path) &&
	Files.isExecutable(path);
	}
	};

	/** Utility class: do not instantiate. */
	private MorePaths() {}

	public static final Function<String, Path> TO_PATH = new Function<String, Path>() {
	@Override
	public Path apply(String path) {
	return Paths.get(path);
	}
	};

	public static String pathWithUnixSeparators(String path) {
	return pathWithUnixSeparators(Paths.get(path));
	}

	public static String pathWithUnixSeparators(Path path) {
	return path.toString().replace("\\", "/");
	}

	/**
	* @param toMakeAbsolute The {@link Path} to act upon.
	* @return The Path, made absolute and normalized.
	*/
	public static Path absolutify(Path toMakeAbsolute) {
	return toMakeAbsolute.toAbsolutePath().normalize();
	}

	/**
	* Get the path of a file relative to a base directory.
	*
	* @param path must reference a file, not a directory.
	* @param baseDir must reference a directory that is relative to a common directory with the path.
	* may be null if referencing the same directory as the path.
	* @return the relative path of path from the directory baseDir.
	*/
	public static Path getRelativePath(Path path, @Nullable Path baseDir) {
	if (baseDir == null) {
	// This allows callers to use this method with "file.parent()" for files from the project
	// root dir.
	baseDir = Paths.get("");
	}
	Preconditions.checkArgument(!path.isAbsolute(),
	"Path must be relative: %s.", path);
	Preconditions.checkArgument(!baseDir.isAbsolute(),
	"Path must be relative: %s.", baseDir);
	return relativize(baseDir, path);
	}

	/**
	* Get a relative path from path1 to path2, first normalizing each path.
	*
	* This method is a workaround for JDK-6925169 (Path.relativize
	* returns incorrect result if path contains "." or "..").
	*/
	public static Path relativize(Path path1, Path path2) {
	Path emptyPath = Paths.get("");

	Preconditions.checkArgument(
	path1.isAbsolute() == path2.isAbsolute(),
	"Both paths must be absolute or both paths must be relative. (%s is %s, %s is %s)",
	path1,
	path1.isAbsolute() ? "absolute" : "relative",
	path2,
	path2.isAbsolute() ? "absolute" : "relative");

	// Work around JDK-8037945 (Paths.get("").normalize() throws ArrayIndexOutOfBoundsException).
	if (!path1.equals(emptyPath)) {
	path1 = path1.normalize();
	}
	if (!path2.equals(emptyPath)) {
	path2 = path2.normalize();
	}

	// On Windows, if path1 is "" then Path.relativize returns ../path2 instead of path2 or ./path2
	if (path1.equals(emptyPath)) {
	return path2;
	}
	return path1.relativize(path2);
	}

	/**
	* Creates a symlink at
	* {@code projectFilesystem.getRootPath().resolve(pathToDesiredLinkUnderProjectRoot)} that
	* points to {@code projectFilesystem.getRootPath().resolve(pathToExistingFileUnderProjectRoot)}
	* using a relative symlink.
	*
	* @param pathToDesiredLinkUnderProjectRoot must reference a file, not a directory.
	* @param pathToExistingFileUnderProjectRoot must reference a file, not a directory.
	* @return the relative path from the new symlink that was created to the existing file.
	*/
	public static Path createRelativeSymlink(
	Path pathToDesiredLinkUnderProjectRoot,
	Path pathToExistingFileUnderProjectRoot,
	ProjectFilesystem projectFilesystem) throws IOException {
	return createRelativeSymlink(
	pathToDesiredLinkUnderProjectRoot,
	pathToExistingFileUnderProjectRoot,
	projectFilesystem.getRootPath());
	}

	/**
	* Creates a symlink at {@code pathToProjectRoot.resolve(pathToDesiredLinkUnderProjectRoot)} that
	* points to {@code pathToProjectRoot.resolve(pathToExistingFileUnderProjectRoot)} using a
	* relative symlink. Both params must be relative to the project root.
	*
	* @param pathToDesiredLinkUnderProjectRoot must reference a file, not a directory.
	* @param pathToExistingFileUnderProjectRoot must reference a file, not a directory.
	* @return the relative path from the new symlink that was created to the existing file.
	*/
	public static Path createRelativeSymlink(
	Path pathToDesiredLinkUnderProjectRoot,
	Path pathToExistingFileUnderProjectRoot,
	Path pathToProjectRoot) throws IOException {
	Path target = getRelativePath(
	pathToExistingFileUnderProjectRoot,
	pathToDesiredLinkUnderProjectRoot.getParent());
	Files.createSymbolicLink(pathToProjectRoot.resolve(pathToDesiredLinkUnderProjectRoot), target);
	return target;
	}

	/**
	* Convert a set of input file paths as strings to {@link Path} objects.
	*/
	public static ImmutableSortedSet<Path> asPaths(Iterable<String> paths) {
	ImmutableSortedSet.Builder<Path> builder = ImmutableSortedSet.naturalOrder();
	for (String path : paths) {
	builder.add(TO_PATH.apply(path));
	}
	return builder.build();
	}

	/**
	* Filters out {@link Path} objects from {@code paths} that aren't a subpath of {@code root} and
	* returns a set of paths relative to {@code root}.
	*/
	public static ImmutableSet<Path> filterForSubpaths(Iterable<Path> paths, final Path root) {
	final Path normalizedRoot = root.toAbsolutePath().normalize();
	return FluentIterable.from(paths)
	.filter(new Predicate<Path>() {
	@Override
	public boolean apply(Path input) {
	if (input.isAbsolute()) {
	return input.normalize().startsWith(normalizedRoot);
	} else {
	return true;
	}
	}
	})
	.transform(new Function<Path, Path>() {
	@Override
	public Path apply(Path input) {
	if (input.isAbsolute()) {
	return relativize(normalizedRoot, input);
	} else {
	return input;
	}
	}
	})
	.toSet();
	}

	/**
	* @return Whether the input path directs to a file in the buck generated files folder.
	*/
	public static boolean isGeneratedFile(Path pathRelativeToProjectRoot) {
	return pathRelativeToProjectRoot.startsWith(BuckConstant.GEN_PATH);
	}

	/**
	* Expands "~/foo" into "/home/zuck/foo". Returns regular paths unmodified.
	*/
	public static Path expandHomeDir(Path path) {
	if (!path.startsWith("~")) {
	return path;
	}
	Path homePath = Paths.get(System.getProperty("user.home"));
	if (path.equals(Paths.get("~"))) {
	return homePath;
	}
	return homePath.resolve(path.subpath(1, path.getNameCount()));
	}

	public static boolean fileContentsDiffer(
	InputStream contents,
	Path path,
	ProjectFilesystem projectFilesystem) throws IOException {
	try {
	// Hash the contents of the file at path so we don't have to pull the whole thing into memory.
	MessageDigest sha1 = MessageDigest.getInstance("SHA-1");
	byte[] pathDigest;
	try (InputStream is = projectFilesystem.newFileInputStream(path)) {
	pathDigest = inputStreamDigest(is, sha1);
	}
	// Hash 'contents' and see if the two differ.
	sha1.reset();
	byte[] contentsDigest = inputStreamDigest(contents, sha1);
	return !Arrays.equals(pathDigest, contentsDigest);
	} catch (NoSuchFileException e) {
	// If the file doesn't exist, we need to create it.
	return true;
	} catch (NoSuchAlgorithmException e) {
	throw Throwables.propagate(e);
	}
	}

	/**
	* Looks for {@code executableToFind} under each entry of {@code pathsToSearch} and returns
	* the full path ({@code pathToSearch/executableToFind)}) to the first one which
	* exists on disk as an executable file.
	*
	* This is similar to the {@code which} command in Unix, but handles the various extensions
	* that are configured by Windows (when supplied with valid {@code extensions}).
	*
	* {@code executableToFind} must be a relative path.
	*
	* If none are found, returns {@link Optional#absent()}.
	*/
	public static Optional<Path> searchPathsForExecutable(
	Path executableToFind,
	Collection<Path> pathsToSearch,
	Collection<String> extensions) {
	return searchPathsForExecutable(
	executableToFind,
	pathsToSearch,
	extensions,
	DEFAULT_PATH_IS_EXECUTABLE_CHECKER);
	}

	/**
	* Looks for {@code executableToFind} under each entry of {@code pathsToSearch} and returns
	* the full path ({@code pathToSearch/executableToFind)}) to the first one for which
	* {@code pathIsExecutableChecker(path)} returns true.
	*
	* This is similar to the {@code which} command in Unix, but handles the various extensions
	* that are configured by Windows (when supplied with valid {@code extensions}).
	*
	* {@code executableToFind} must be a relative path.
	*
	* If none are found, returns {@link Optional#absent()}.
	*/
	public static Optional<Path> searchPathsForExecutable(
	Path executableToFind,
	Collection<Path> pathsToSearch,
	Collection<String> extensions,
	Function<Path, Boolean> pathIsExecutableChecker) {
	Preconditions.checkArgument(
	!executableToFind.isAbsolute(),
	"Path %s must be relative",
	executableToFind);

	for (Path pathToSearch : pathsToSearch) {
	Optional<Path> maybeResolved = resolveExecutable(
	pathToSearch,
	executableToFind,
	extensions,
	pathIsExecutableChecker);
	if (maybeResolved.isPresent()) {
	return maybeResolved;
	}
	}
	return Optional.absent();
	}

	private static Optional<Path> resolveExecutable(
	Path base,
	Path executableToFind,
	Collection<String> extensions,
	Function<Path, Boolean> pathIsExecutableChecker) {
	if (extensions.isEmpty()) {
	Path resolved = base.resolve(executableToFind);
	if (pathIsExecutableChecker.apply(resolved)) {
	return Optional.of(resolved);
	}
	return Optional.absent();
	}
	for (String pathExt : extensions) {
	Path resolved = base.resolve(executableToFind + pathExt);
	if (pathIsExecutableChecker.apply(resolved)) {
	return Optional.of(resolved);
	}
	}
	return Optional.absent();
	}

	private static byte[] inputStreamDigest(InputStream inputStream, MessageDigest messageDigest)
	throws IOException {
	try (DigestInputStream dis = new DigestInputStream(inputStream, messageDigest)) {
	byte[] buf = new byte[4096];
	while (true) {
	// Read the contents of the existing file so we can hash it.
	if (dis.read(buf) == -1) {
	break;
	}
	}
	return dis.getMessageDigest().digest();
	}
	}
	}