FileUtils.toPath to convert File to Path

When invoking File.toPath(), an (unchecked) InvalidPathException may be
thrown which should be converted to a checked IOException.

For now, we will replace File.toPath() by FileUtils.toPath() only for
code which can already handle IOExceptions.

Change-Id: I0f0c5fd2a11739e7a02071adae9a5550985d4df6
Signed-off-by: Marc Strapetz <marc.strapetz@syntevo.com>

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/CleanFilter.java

 	public CleanFilter(Repository db, InputStream in, OutputStream out)
 			throws IOException {
 		super(in, out);
-		lfsUtil = new Lfs(db.getDirectory().toPath().resolve("lfs")); //$NON-NLS-1$
+		lfsUtil = new Lfs(FileUtils.toPath(db.getDirectory()).resolve("lfs")); //$NON-NLS-1$
 		Files.createDirectories(lfsUtil.getLfsTmpDir());
 		tmpFile = lfsUtil.createTmpFile();
 		this.aOut = new AtomicObjectOutputStream(tmpFile.toAbsolutePath());

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/SmudgeFilter.java

 import org.eclipse.jgit.attributes.FilterCommandRegistry;
 import org.eclipse.jgit.lfs.lib.Constants;
 import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.util.FileUtils;
 
 /**
  * Built-in LFS smudge filter
 	public SmudgeFilter(Repository db, InputStream in, OutputStream out)
 			throws IOException {
 		super(in, out);
-		lfs = new Lfs(db.getDirectory().toPath().resolve(Constants.LFS));
+		lfs = new Lfs(FileUtils.toPath(db.getDirectory()).resolve(Constants.LFS));
 		LfsPointer res = LfsPointer.parseLfsPointer(in);
 		if (res != null) {
 			Path mediaFile = lfs.getMediaFile(res.getOid());

org.eclipse.jgit.test/exttst/org/eclipse/jgit/ignore/CGitVsJGitRandomIgnorePatternTest.java

 import java.util.Random;
 
 import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.util.FileUtils;
 import org.junit.Assert;
 import org.junit.Test;
 
 				throws UnsupportedEncodingException, IOException {
 			this.gitDir = gitDir;
 			this.pattern = pattern;
-			Files.write(new File(gitDir, ".gitignore").toPath(),
+			Files.write(FileUtils.toPath(new File(gitDir, ".gitignore")),
 					(pattern + "\n").getBytes("UTF-8"),
 					StandardOpenOption.CREATE,
 					StandardOpenOption.TRUNCATE_EXISTING,

org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/GC.java

 			} else {
 				if (base == null || !n.startsWith(base)) {
 					try {
-						Files.delete(new File(packDir.toFile(), n).toPath());
+						Files.delete(FileUtils.toPath(new File(packDir.toFile(), n)));
 					} catch (IOException e) {
 						LOG.error(e.getMessage(), e);
 					}

org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/GcLog.java

 import org.eclipse.jgit.api.errors.JGitInternalException;
 import org.eclipse.jgit.internal.JGitText;
 import org.eclipse.jgit.lib.ConfigConstants;
+import org.eclipse.jgit.util.FileUtils;
 import org.eclipse.jgit.util.GitDateParser;
 import org.eclipse.jgit.util.SystemReader;
 
 
 	private boolean autoGcBlockedByOldLockFile(boolean background) {
 		try {
-			FileTime lastModified = Files.getLastModifiedTime(logFile.toPath());
+			FileTime lastModified = Files.getLastModifiedTime(FileUtils.toPath(logFile));
 			if (lastModified.toInstant().compareTo(getLogExpiry()) > 0) {
 				// There is an existing log file, which is too recent to ignore
 				if (!background) {
 					try (BufferedReader reader = Files
-							.newBufferedReader(logFile.toPath())) {
+							.newBufferedReader(FileUtils.toPath(logFile))) {
 						char[] buf = new char[1000];
 						int len = reader.read(buf, 0, 1000);
 						String oldError = new String(buf, 0, len);

org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/ObjectDirectory.java

 			return InsertLooseObjectResult.EXISTS_LOOSE;
 		}
 		try {
-			Files.move(tmp.toPath(), dst.toPath(),
+			Files.move(FileUtils.toPath(tmp), FileUtils.toPath(dst),
 					StandardCopyOption.ATOMIC_MOVE);
 			dst.setReadOnly();
 			unpackedObjectCache.add(id);
 		//
 		FileUtils.mkdir(dst.getParentFile(), true);
 		try {
-			Files.move(tmp.toPath(), dst.toPath(),
+			Files.move(FileUtils.toPath(tmp), FileUtils.toPath(dst),
 					StandardCopyOption.ATOMIC_MOVE);
 			dst.setReadOnly();
 			unpackedObjectCache.add(id);

org.eclipse.jgit/src/org/eclipse/jgit/util/FS_POSIX.java

 			return f.setExecutable(false, false);
 
 		try {
-			Path path = f.toPath();
+			Path path = FileUtils.toPath(f);
 			Set<PosixFilePermission> pset = Files.getPosixFilePermissions(path);
 
 			// owner (user) is always allowed to execute.

org.eclipse.jgit/src/org/eclipse/jgit/util/FileUtils.java

 import java.nio.file.AtomicMoveNotSupportedException;
 import java.nio.file.CopyOption;
 import java.nio.file.Files;
+import java.nio.file.InvalidPathException;
 import java.nio.file.LinkOption;
 import java.nio.file.Path;
 import java.nio.file.StandardCopyOption;
 	 */
 	public static final int EMPTY_DIRECTORIES_ONLY = 16;
 
+	/**
+	 * Safe conversion from {@link java.io.File} to {@link java.nio.file.Path}.
+	 *
+	 * @param f
+	 *            {@code File} to be converted to {@code Path}
+	 * @throws IOException
+	 *            in case the path represented by the file
+	 *            is not valid ({@link java.nio.file.InvalidPathException})
+	 *
+	 * @since 4.10
+	 */
+	public static Path toPath(final File f) throws IOException {
+		try {
+			return f.toPath();
+		} catch (InvalidPathException ex) {
+			throw new IOException(ex);
+		}
+	}
+
 	/**
 	 * Delete file or empty folder
 	 *
 		int attempts = FS.DETECTED.retryFailedLockFileCommit() ? 10 : 1;
 		while (--attempts >= 0) {
 			try {
-				Files.move(src.toPath(), dst.toPath(), options);
+				Files.move(toPath(src), toPath(dst), options);
 				return;
 			} catch (AtomicMoveNotSupportedException e) {
 				throw e;
 						delete(dst, EMPTY_DIRECTORIES_ONLY | RECURSIVE);
 					}
 					// On *nix there is no try, you do or do not
-					Files.move(src.toPath(), dst.toPath(), options);
+					Files.move(toPath(src), toPath(dst), options);
 					return;
 				} catch (IOException e2) {
 					// ignore and continue retry
 	 */
 	public static Path createSymLink(File path, String target)
 			throws IOException {
-		Path nioPath = path.toPath();
+		Path nioPath = toPath(path);
 		if (Files.exists(nioPath, LinkOption.NOFOLLOW_LINKS)) {
 			BasicFileAttributes attrs = Files.readAttributes(nioPath,
 					BasicFileAttributes.class, LinkOption.NOFOLLOW_LINKS);
 		if (SystemReader.getInstance().isWindows()) {
 			target = target.replace('/', '\\');
 		}
-		Path nioTarget = new File(target).toPath();
+		Path nioTarget = toPath(new File(target));
 		return Files.createSymbolicLink(nioPath, nioTarget);
 	}
 
 	 * @since 3.0
 	 */
 	public static String readSymLink(File path) throws IOException {
-		Path nioPath = path.toPath();
+		Path nioPath = toPath(path);
 		Path target = Files.readSymbolicLink(nioPath);
 		String targetString = target.toString();
 		if (SystemReader.getInstance().isWindows()) {
 	 * @throws IOException
 	 */
 	static long lastModified(File file) throws IOException {
-		return Files.getLastModifiedTime(file.toPath(), LinkOption.NOFOLLOW_LINKS)
+		return Files.getLastModifiedTime(toPath(file), LinkOption.NOFOLLOW_LINKS)
 				.toMillis();
 	}
 
 	 * @throws IOException
 	 */
 	static void setLastModified(File file, long time) throws IOException {
-		Files.setLastModifiedTime(file.toPath(), FileTime.fromMillis(time));
+		Files.setLastModifiedTime(toPath(file), FileTime.fromMillis(time));
 	}
 
 	/**
 	 * @throws IOException
 	 */
 	static boolean isHidden(File file) throws IOException {
-		return Files.isHidden(file.toPath());
+		return Files.isHidden(toPath(file));
 	}
 
 	/**
 	 * @since 4.1
 	 */
 	public static void setHidden(File file, boolean hidden) throws IOException {
-		Files.setAttribute(file.toPath(), "dos:hidden", Boolean.valueOf(hidden), //$NON-NLS-1$
+		Files.setAttribute(toPath(file), "dos:hidden", Boolean.valueOf(hidden), //$NON-NLS-1$
 				LinkOption.NOFOLLOW_LINKS);
 	}
 
 	 * @since 4.1
 	 */
 	public static long getLength(File file) throws IOException {
-		Path nioPath = file.toPath();
+		Path nioPath = toPath(file);
 		if (Files.isSymbolicLink(nioPath))
 			return Files.readSymbolicLink(nioPath).toString()
 					.getBytes(Constants.CHARSET).length;
 	 */
 	static Attributes getFileAttributesBasic(FS fs, File file) {
 		try {
-			Path nioPath = file.toPath();
+			Path nioPath = toPath(file);
 			BasicFileAttributes readAttributes = nioPath
 					.getFileSystem()
 					.provider()
 	 */
 	public static Attributes getFileAttributesPosix(FS fs, File file) {
 		try {
-			Path nioPath = file.toPath();
+			Path nioPath = toPath(file);
 			PosixFileAttributes readAttributes = nioPath
 					.getFileSystem()
 					.provider()