Merge branch 'podcherklife-support-partially-case-sensitive-fs' into devel

Author: Argent77

src/org/infinity/util/io/CaseAwarePathResolver.java

@@ -0,0 +1,34 @@
+package org.infinity.util.io;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.infinity.util.io.CaseAwareSingleDirectoryPathResolver.ResolutionResult;
+
+public class CaseAwarePathResolver {
+
+  private final Map<Path, CaseAwareSingleDirectoryPathResolver> roots = new ConcurrentHashMap<>();
+
+  public Path resolve(Path path, boolean requireFullyResolvedPath) {
+    if (!path.isAbsolute()) {
+      throw new IllegalArgumentException("Provided path should be absolute, got " + path + " instead");
+    }
+    if (Files.exists(path)) {
+      return path;
+    }
+
+    ResolutionResult resolutionResult = roots
+        .computeIfAbsent(path.getRoot(), (root) -> new CaseAwareSingleDirectoryPathResolver(root))
+        .resolve(path.subpath(0, path.getNameCount()));
+
+    if (resolutionResult.getUnresolvedPart() == null) {
+      return resolutionResult.getResolvedPart();
+    } else if (requireFullyResolvedPath) {
+      return null;
+    } else {
+      return resolutionResult.getResolvedPart().resolve(resolutionResult.getUnresolvedPart());
+    }
+  }
+}

src/org/infinity/util/io/CaseAwareSingleDirectoryPathResolver.java

@@ -0,0 +1,118 @@
+package org.infinity.util.io;
+
+import java.io.IOException;
+import java.nio.file.DirectoryStream;
+import java.nio.file.Files;
+import java.nio.file.NoSuchFileException;
+import java.nio.file.Path;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class CaseAwareSingleDirectoryPathResolver {
+
+  public static class ResolutionResult {
+    private Path resolvedPart;
+    private Path unresolvedPart;
+
+    public ResolutionResult(Path resolvedPart, Path unresolvedPart) {
+      super();
+      this.resolvedPart = resolvedPart;
+      this.unresolvedPart = unresolvedPart;
+    }
+
+    public Path getResolvedPart() {
+      return resolvedPart;
+    }
+
+    public Path getUnresolvedPart() {
+      return unresolvedPart;
+    }
+  }
+
+  private final Map<Path, CaseAwareSingleDirectoryPathResolver> subdirectoryResolvers = new ConcurrentHashMap<>();
+  private final Path directory;
+
+  private boolean caseSensitivityIsFiguredOut = false;
+  private boolean caseSensitive = false;
+
+  public CaseAwareSingleDirectoryPathResolver(Path resolveFrom) {
+    this.directory = resolveFrom;
+  }
+
+  public ResolutionResult resolve(Path relativePath) {
+    Path unresolvedPart = relativePath;
+    Path currentLocation = directory;
+    Path nextPathElement = unresolvedPart.subpath(0, 1);
+    Path actualNextLocation = resolveSinglePathElementToActualLocation(currentLocation, nextPathElement);
+    if (actualNextLocation == null) {
+      return new ResolutionResult(currentLocation, unresolvedPart);
+    }
+
+    if (unresolvedPart.getNameCount() == 1) { // this was the last path element, nothing left to resolve
+      return new ResolutionResult(currentLocation.resolve(actualNextLocation), null);
+    } else {
+      unresolvedPart = unresolvedPart.subpath(1, unresolvedPart.getNameCount());
+      return subdirectoryResolvers
+          .computeIfAbsent(actualNextLocation, (key) -> new CaseAwareSingleDirectoryPathResolver(key))
+          .resolve(unresolvedPart);
+    }
+
+  }
+
+  private Path resolveSinglePathElementToActualLocation(Path resolveFrom, Path elementToResolve) {
+    Path directResolution = resolveFrom.resolve(elementToResolve);
+    if (Files.exists(directResolution)) {
+      return directResolution;
+    }
+
+    if (currentDirIsKnownToBeCaseInsensitive()) {
+      return null;
+    }
+
+    String searchString = elementToResolve.getFileName().toString();
+    try (DirectoryStream<Path> ds = Files.newDirectoryStream(resolveFrom)) {
+      for (final Path dirPath : ds) {
+        if (!caseSensitivityIsFiguredOut) {
+          tryFigureOutCaseSensitivityUsingExistingPath(dirPath);
+          if (currentDirIsKnownToBeCaseInsensitive()) {
+            break;
+          }
+        }
+        String dirString = dirPath.getFileName().toString();
+        if (searchString.equalsIgnoreCase(dirString)) {
+          return resolveFrom.resolve(dirPath);
+        }
+      }
+    } catch (Throwable t) {
+      throw new RuntimeException(t);
+    }
+    return null;
+  }
+
+  private boolean currentDirIsKnownToBeCaseInsensitive() {
+    return caseSensitivityIsFiguredOut && !caseSensitive;
+  }
+
+  private boolean tryFigureOutCaseSensitivityUsingExistingPath(Path existingPath) throws IOException {
+    Path baseDir = existingPath.getParent();
+    String filename = existingPath.getFileName().toString();
+    String lowerCaseFilename = filename.toLowerCase();
+    String upperCaseFilename = filename.toUpperCase();
+    if (Objects.equals(lowerCaseFilename, upperCaseFilename)) {
+      return false;
+    }
+
+    try {
+      Path lowercaseFilePath = baseDir.resolve(lowerCaseFilename);
+      Path uppercaseFilePath = baseDir.resolve(upperCaseFilename);
+      this.caseSensitive = !Files.isSameFile(lowercaseFilePath, uppercaseFilePath);
+      this.caseSensitivityIsFiguredOut = true;
+    } catch (NoSuchFileException e) {
+      this.caseSensitive = true;
+      this.caseSensitivityIsFiguredOut = true;
+    }
+    return true;
+  }
+
+}

src/org/infinity/util/io/FileManager.java

@@ -5,7 +5,6 @@
 package org.infinity.util.io;
 
 import java.io.IOException;
-import java.nio.file.DirectoryStream;
 import java.nio.file.FileSystem;
 import java.nio.file.FileSystems;
 import java.nio.file.Files;
@@ -14,9 +13,9 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Objects;
+import java.util.function.BiFunction;
 
 import org.infinity.util.Logger;
 import org.infinity.util.Platform;
@@ -37,6 +36,12 @@ public static boolean isCaseSensitiveMode() {
     return caseSensitiveMode;
   }
 
+  private static final BiFunction<Path, Boolean, Path> pathResolver = makePathResolver();
+  
+  private static BiFunction<Path, Boolean, Path> makePathResolver() {
+    return isCaseSensitiveMode() ? new CaseAwarePathResolver()::resolve : (p, f) -> p;
+  }
+
   /**
    * This method can be used to override the default case-sensitive operation mode for filesystems.
    *
@@ -363,39 +368,7 @@ private static Path resolvePath(Path path, boolean forced) {
       // validating path segments
       Path validatedPath = path.getRoot();
       if (validatedPath != null && FileEx.create(validatedPath).exists()) {
-        int idx = 0;
-        for (; idx < path.getNameCount(); idx++) {
-          final Path pathItem = path.getName(idx);
-          final String pathName = pathItem.toString();
-
-          final Path resolvedPath = validatedPath.resolve(pathName);
-          if (Files.exists(resolvedPath)) {
-            validatedPath = resolvedPath;
-          } else {
-            try (final DirectoryStream<Path> ds = Files.newDirectoryStream(validatedPath,
-                p -> p.getFileName().toString().equalsIgnoreCase(pathName))) {
-              final Iterator<Path> iter = ds.iterator();
-              if (iter.hasNext()) {
-                validatedPath = iter.next();
-              } else {
-                break;
-              }
-            } catch (IOException e) {
-              break;
-            }
-          }
-        }
-
-        // adding remaining unvalidated path segments (if any)
-        if (forced && idx < path.getNameCount()) {
-          validatedPath = null;
-        } else {
-          for (; idx < path.getNameCount(); idx++) {
-            validatedPath = validatedPath.resolve(path.getName(idx));
-          }
-        }
-
-        retVal = validatedPath;
+          retVal = pathResolver.apply(path, forced);
       }
     } else if (forced && !pathEx.exists()) {
       retVal = null;