--- /dev/null
+package jalview.util;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.DirectoryStream;
+import java.nio.file.FileSystems;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.PathMatcher;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Miscellaneous file-related functions
+ */
+public final class FileUtils
+{
+
+ /**
+ * Answers the executable file for the given command, or null if not found or
+ * not executable. The path to the executable is the command name prefixed by
+ * the given folder path, optionally with .exe appended.
+ *
+ * @param cmd
+ * command short name, for example hmmbuild
+ * @param binaryPath
+ * parent folder for the executable
+ * @return
+ */
+ public static File getExecutable(String cmd, String binaryPath)
+ {
+ File file = new File(binaryPath, cmd);
+ if (!file.canExecute())
+ {
+ file = new File(binaryPath, cmd + ".exe");
+ {
+ if (!file.canExecute())
+ {
+ file = null;
+ }
+ }
+ }
+ return file;
+ }
+
+ /**
+ * Answers the path to the folder containing the given executable file, by
+ * searching the PATH environment variable. Answers null if no such executable
+ * can be found.
+ *
+ * @param cmd
+ * @return
+ */
+ public static String getPathTo(String cmd)
+ {
+ String paths = System.getenv("PATH");
+ // backslash is to escape regular expression argument
+ for (String path : paths.split("\\" + File.pathSeparator))
+ {
+ if (getExecutable(cmd, path) != null)
+ {
+ return path;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * A convenience method to create a temporary file that is deleted on exit of
+ * the JVM
+ *
+ * @param prefix
+ * @param suffix
+ * @return
+ * @throws IOException
+ */
+ public static File createTempFile(String prefix, String suffix)
+ throws IOException
+ {
+ File f = File.createTempFile(prefix, suffix);
+ f.deleteOnExit();
+ return f;
+ }
+
+ /**
+ * Answers a (possibly empty) list of file paths found by searching below
+ * <code>from</code> that match the supplied regular expression
+ * <code>pattern</code>. Results may include <code>from</code> itself if it
+ * matches. If an exception occurs it is written to syserr and any results up to
+ * that point are returned. Note that the regular expression match applies to
+ * the whole path of any matched file.
+ * <p>
+ * WARNING: because the whole directory tree below <code>from</code> is
+ * searched, this method may be slow if used for a high level directory, or may
+ * exit prematurely if security or other exceptions occur.
+ *
+ * <pre>
+ * Example:
+ * findMatchingPaths(Paths.get("C:/Program Files"), ".*/chimera.exe$")
+ * </pre>
+ *
+ * @param from
+ * @param pattern
+ *
+ * @return
+ * @see https://stackoverflow.com/questions/794381/how-to-find-files-that-match-a-wildcard-string-in-java/31685610#comment62441832_31685610
+ */
+ public static List<String> findMatchingPaths(Path from, String pattern)
+ {
+ List<String> matches = new ArrayList<>();
+ PathMatcher pathMatcher = FileSystems.getDefault()
+ .getPathMatcher("regex:" + pattern);
+ try
+ {
+ Files.walk(from).filter(pathMatcher::matches)
+ .forEach(m -> matches.add(m.toString()));
+ } catch (IOException e)
+ {
+ System.err.println(
+ "Error searching for " + pattern + " : " + e.toString());
+ }
+
+ return matches;
+ }
+
+ /**
+ * Answers a (possibly empty) list of paths to files below the given root path,
+ * that match the given pattern. The pattern should be a '/' delimited set of
+ * glob patterns, each of which is used to match child file names (not full
+ * paths). Note that 'directory spanning' glob patterns (**) are <em>not</em>
+ * supported by this method.
+ * <p>
+ * For example
+ *
+ * <pre>
+ * findMatches("C:\\", "Program Files*/Chimera*/bin/{chimera,chimera.exe}"
+ * </pre>
+ *
+ * would match "C:\Program Files\Chimera 1.11\bin\chimera.exe" and "C:\Program
+ * Files (x86)\Chimera 1.10.1\bin\chimera"
+ *
+ * @param root
+ * @param pattern
+ * @return
+ * @see https://docs.oracle.com/javase/tutorial/essential/io/fileOps.html#glob
+ */
+ public static List<String> findMatches(String root, String pattern)
+ {
+ List<String> results = new ArrayList<>();
+ try
+ {
+ Path from = Paths.get(root);
+ findMatches(results, from, Arrays.asList(pattern.split("/")));
+ } catch (Throwable e)
+ {
+ // Paths.get can throw IllegalArgumentException
+ System.err.println(String.format("Error searching %s for %s: %s",
+ root, pattern, e.toString()));
+ }
+
+ return results;
+ }
+
+ /**
+ * A helper method that performs recursive search of file patterns and adds any
+ * 'leaf node' matches to the results list
+ *
+ * @param results
+ * @param from
+ * @param patterns
+ */
+ protected static void findMatches(List<String> results, Path from,
+ List<String> patterns)
+ {
+ if (patterns.isEmpty())
+ {
+ /*
+ * reached end of recursion with all components matched
+ */
+ results.add(from.toString());
+ return;
+ }
+
+ String pattern = patterns.get(0);
+ try (DirectoryStream<Path> dirStream = Files.newDirectoryStream(from,
+ pattern))
+ {
+ dirStream.forEach(p -> {
+
+ /*
+ * matched a next level file - search below it
+ * (ignore non-directory non-leaf matches)
+ */
+ List<String> subList = patterns.subList(1, patterns.size());
+ if (subList.isEmpty() || p.toFile().isDirectory())
+ {
+ findMatches(results, p, subList);
+ }
+ });
+ } catch (IOException e)
+ {
+ System.err.println(String.format("Error searching %s: %s", pattern,
+ e.toString()));
+ }
+ }
+}
git://source.jalview.org / jalview.git / blobdiff