Bring back file URI support in open dialog

Before some of my older refactoring changes, FilePathPreProcessor was
used to allow to open "file:" URIs and to also decode URL-encoded file
names. But I've removed it in the Open dialog, as it was pretty hacky
and could result in not opening files in some cases.

So I've made some changes to the FilePathPreProcessor:
* If a file exists on disk at the specified path, no conversion happens.
* URL-decoding of paths only happens, if no file at the original path
  exists and there is a file at the decoded path.
* File URI handling is now done via the URI and File classes, which
  should make it more robust.

With that in mind, there was still a problem with the Open dialog.
JFileChooser only returns a File, not the path provided in the dialog.
And there doesn't seem to be a way to get it without UI class hackery.
In the original implementation it searched for "file:" within the path
and discarded everything before it. This comes from the fact, that if,
for example, you put "file:///C:/3142b600.pdf" in the dialog, you would
get something like this from the File API:
"C:\selected_dir\file:\C:\3142b600.pdf"

To handle this in a less hacky way, there is an EnhancedFileSystemView
now, which is passed to the JFileChooser. It just wraps the original
FileSystemView, but in the File creation methods, which involve String
file names or paths (createFileObject, getChild), they now go through
the FilePathPreProcessor. This way all the path transformation will
happen before File conversion, which is much cleaner.

Author: Eswcvlad

src/main/java/com/itextpdf/rups/io/PdfFileOpenAction.java

@@ -44,6 +44,7 @@ This file is part of the iText (R) project.
 
 import com.itextpdf.rups.RupsConfiguration;
 import com.itextpdf.rups.io.filters.PdfFilter;
+import com.itextpdf.rups.view.EnhancedFileSystemView;
 
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
@@ -83,24 +84,24 @@ public PdfFileOpenAction(Consumer<File> listener, Component parent) {
 
     @Override
     public void actionPerformed(ActionEvent evt) {
-        final JFileChooser fileChooser = new JFileChooser();
-        setCurrentDirectory(fileChooser);
+        final JFileChooser fileChooser = new JFileChooser(
+                getCurrentDirectory(), EnhancedFileSystemView.INSTANCE
+        );
         fileChooser.setFileFilter(PdfFilter.INSTANCE);
         if (fileChooser.showOpenDialog(parent) == JFileChooser.APPROVE_OPTION) {
             listener.accept(fileChooser.getSelectedFile());
         }
     }
 
-    private static void setCurrentDirectory(JFileChooser fileChooser) {
+    private static File getCurrentDirectory() {
         final File mostRecentOpenFile = RupsConfiguration.INSTANCE.getMruListHandler().peekMostRecent();
         if (mostRecentOpenFile != null) {
             final File mostRecentDir = mostRecentOpenFile.getParentFile();
             if (mostRecentDir != null) {
-                fileChooser.setCurrentDirectory(mostRecentDir);
-                return;
+                return mostRecentDir;
             }
         }
         // Fallback to home dir
-        fileChooser.setCurrentDirectory(RupsConfiguration.INSTANCE.getHomeFolder());
+        return RupsConfiguration.INSTANCE.getHomeFolder();
     }
 }

src/main/java/com/itextpdf/rups/model/FilePathPreProcessor.java

@@ -42,41 +42,150 @@ This file is part of the iText (R) project.
  */
 package com.itextpdf.rups.model;
 
+import java.io.File;
+import java.net.URI;
 import java.net.URLDecoder;
 import java.nio.charset.StandardCharsets;
+import java.util.Optional;
 
 /**
- * Pre-processes file path to make it suitable for further processing.
+ * Static file path processor, which allows handling additional use cases:
+ * <ul>
+ *     <li>URIs with the {@code file} schema.</li>
+ *     <li>URL-encoded paths.</li>
+ * </ul>
+ * <p>
+ * All these additional use cases are only triggered, when it wouldn't prevent
+ * opening an existing file with the original path name.
+ * </p>
  */
 public final class FilePathPreProcessor {
-
     private FilePathPreProcessor() {
         // Empty constructor
     }
 
-    public static String process(String path) {
-        if (path == null) {
-            return null;
+    /**
+     * Process the file name within the context of the specified directory.
+     * Directory will not be included in the output file name string.
+     *
+     * @param currentDir current working dir for the test
+     * @param filename   file name to process
+     *
+     * @return the processed file name
+     */
+    public static String process(File currentDir, String filename) {
+        // Just pass empty values through
+        if (filename == null || filename.isEmpty()) {
+            return filename;
         }
-        String processedPath = path;
-        final String fileProtocol = "file://";
-        if (processedPath.startsWith(fileProtocol)) {
-            processedPath = processedPath.substring(fileProtocol.length());
+        // If a file exists at the specified path, just go with it
+        if (isFile(currentDir, filename)) {
+            return filename;
         }
-        final String file = "file:";
-        if (processedPath.contains(file)) {
-            processedPath = processedPath.substring(processedPath.indexOf(file) + file.length());
+        // If path is, actually, a file URI, process that as well
+        final Optional<String> uriFilePath = fromFileUri(filename);
+        if (uriFilePath.isPresent()) {
+            return uriFilePath.get();
         }
-        // Check if the path is encoded
-        if (isUriEncoded(processedPath)) {
-            processedPath = URLDecoder.decode(processedPath, StandardCharsets.UTF_8);
+        // Another special case, if string is URL-encoded for some reason and
+        // is not a URI, then test that as well
+        final Optional<String> urlEncodedPath = fromUrlEncoded(currentDir, filename);
+        if (urlEncodedPath.isPresent()) {
+            return urlEncodedPath.get();
         }
-        return processedPath;
+        // If not special cases triggered, just return as-is.
+        return filename;
     }
 
-    private static boolean isUriEncoded(String path) {
-        return !path.equals(URLDecoder.decode(path, StandardCharsets.UTF_8));
+    /**
+     * Process the path within the context of the current working directory.
+     *
+     * @param path path to process
+     *
+     * @return the processed path
+     */
+    public static String process(String path) {
+        return process(null, path);
+    }
+
+    /**
+     * Decodes a URL-encoded string and returns the decoded string, if is a
+     * path to an existing file. Otherwise, returns an empty optional.
+     *
+     * @param currentDir       current working dir for the test
+     * @param urlEncodedString URL-encoded string
+     *
+     * @return the decoded path to the file
+     */
+    private static Optional<String> fromUrlEncoded(File currentDir, String urlEncodedString) {
+        try {
+            final String decoded = URLDecoder.decode(urlEncodedString, StandardCharsets.UTF_8);
+            if (isFile(currentDir, decoded)) {
+                return Optional.of(decoded);
+            }
+        } catch (Exception ignored) {
+            // Ignored
+        }
+        return Optional.empty();
     }
-}
 
+    /**
+     * Takes a {@code file} schema URI and returns the absolute path to the
+     * file. If this is not a file URI, returns an empty optional.
+     *
+     * @param fileUriString {@code file} schema URI string
+     *
+     * @return the absolute path to the file
+     */
+    private static Optional<String> fromFileUri(String fileUriString) {
+        try {
+            URI uri = URI.create(fileUriString);
+            final String scheme = uri.getScheme();
+            if (!"file".equalsIgnoreCase(scheme)) {
+                return Optional.empty();
+            }
+            /*
+             * This is some handling for invalid URIs. For example, if you
+             * want to have URI to, for example, "C:\note.pdf", then these
+             * cases are valid:
+             * - file:C:/node.pdf       (i.e. host part is omitted)
+             * - file:/C:/node.pdf      (i.e. host part is omitted and path starts with a slash)
+             * - file:///C:/node.pdf    (i.e. host part is empty)
+             * But this case is not:
+             * - file://C:/node.pdf     (i.e. "C:" is the host part)
+             * This block should handle this, as this is a common mistake.
+             */
+            if (uri.getRawAuthority() != null || uri.getPath() == null) {
+                //                          Skip "file:" at start
+                uri = URI.create("file:/" + fileUriString.substring(5));
+            }
+            String path = new File(uri).getPath();
+            // Returning the original URI separators for consistency
+            if (File.separatorChar != '/') {
+                path = path.replace(File.separatorChar, '/');
+            }
+            return Optional.of(path);
+        } catch (Exception ignored) {
+            // Ignored
+        }
+        return Optional.empty();
+    }
 
+    /**
+     * Returns whether a regular file exists at the specified path. If there is
+     * an exception during the check, {@code false} is returned.
+     *
+     * @param currentDir current working dir for the test
+     * @param path       path to check
+     *
+     * @return whether a regular file exists at the specified path
+     */
+    private static boolean isFile(File currentDir, String path) {
+        try {
+            return new File(currentDir, path).isFile();
+        } catch (Exception ignored) {
+            // Ignored
+        }
+        return false;
+    }
+}