Merge pull request #3 in MFATT/common from pr/add-file-utils to master

* commit '3be5a9067fc8b392950a17055ee85b7870192044':
  Fix bugs
  Fix assertion message copy/paste issues
  Fix test method name
  New PathUtils class with unit tests

Author: Babcock, Scott

src/main/java/com/nordstrom/common/file/PathUtils.java

@@ -0,0 +1,79 @@
+package com.nordstrom.common.file;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.FileSystems;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.PathMatcher;
+import java.util.Comparator;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Stream;
+
+public class PathUtils {
+
+    private PathUtils() {
+        throw new AssertionError("PathUtils is a static utility class that cannot be instantiated");
+    }
+    
+    /**
+     * Get the next available path in sequence for the specified base name and extension in the specified folder.
+     * 
+     * @param targetPath path to target directory for the next available path in sequence
+     * @param baseName base name for the path sequence
+     * @param extension extension for the path sequence
+     * @return the next available path in sequence
+     * @throws IOException if an I/O error is thrown when accessing the starting file.
+     */
+    public static Path getNextPath(Path targetPath, String baseName, String extension) throws IOException {
+        String newName;
+        
+        Objects.requireNonNull(targetPath, "[targetPath] must be non-null");
+        Objects.requireNonNull(baseName, "[baseName] must be non-null");
+        Objects.requireNonNull(extension, "[extension] must be non-null");
+        
+        File targetFile = targetPath.toFile();
+        if ( ! (targetFile.exists() && targetFile.isDirectory())) {
+            throw new IllegalArgumentException("[targetPath] must specify an existing directory");
+        }
+        if (baseName.isEmpty()) {
+            throw new IllegalArgumentException("[baseName] must specify a non-empty string");
+        }
+        if (extension.isEmpty()) {
+            throw new IllegalArgumentException("[extension] must specify a non-empty string");
+        }
+        
+        PathMatcher pathMatcher = FileSystems.getDefault().getPathMatcher("glob:" + baseName + "*." + extension);
+        
+        try (Stream<Path> stream = Files.walk(targetPath, 1)) {
+            int ext = extension.length() + 1;
+            
+            Optional<String> optional =
+                stream
+                .map(Path::getFileName)
+                .filter(pathMatcher::matches)
+                .map(String::valueOf)
+                .map(s -> s.substring(0, s.length() - ext))
+                .sorted(Comparator.reverseOrder())
+                .findFirst();
+            
+            if (optional.isPresent()) {
+                int index = 1;
+                Pattern pattern = Pattern.compile(baseName + "-(\\d+)");
+                Matcher matcher = pattern.matcher(optional.get());
+                if (matcher.matches()) {
+                    index = Integer.parseInt(matcher.group(1));
+                }
+                newName = baseName + "-" + Integer.toString(index + 1) + "." + extension;
+            } else {
+                newName = baseName + "." + extension;
+            }
+        }
+        
+        return targetPath.resolve(newName);
+    }
+    
+}

src/test/java/com/nordstrom/common/file/PathUtilsTest.java

@@ -0,0 +1,97 @@
+package com.nordstrom.common.file;
+
+import static org.testng.Assert.assertEquals;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Modifier;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+import org.testng.ITestContext;
+import org.testng.ITestResult;
+import org.testng.Reporter;
+import org.testng.annotations.Test;
+
+public class PathUtilsTest {
+    
+    @Test
+    public void testNextPath() throws IOException {
+        Path outputDir = getOutputPath();
+        Path targetPath = outputDir.resolve("targetPath");
+        if (targetPath.toFile().exists()) {
+            for (File file : targetPath.toFile().listFiles()) {
+                file.delete();
+            }
+        } else {
+            Files.createDirectories(targetPath);
+        }
+        
+        Path path1 = PathUtils.getNextPath(targetPath, "test", "txt");
+        assertEquals(path1.getFileName().toString(), "test.txt");
+        
+        path1.toFile().createNewFile();
+        Path path2 = PathUtils.getNextPath(targetPath, "test", "txt");
+        assertEquals(path2.getFileName().toString(), "test-2.txt");
+    }
+
+    private Path getOutputPath() {
+        ITestResult testResult = Reporter.getCurrentTestResult();
+        ITestContext testContext = testResult.getTestContext();
+        String outputDirectory = testContext.getOutputDirectory();
+        Path outputDir = Paths.get(outputDirectory);
+        return outputDir;
+    }
+
+    @Test(expectedExceptions = {AssertionError.class},
+                    expectedExceptionsMessageRegExp = "PathUtils is a static utility class that cannot be instantiated")
+    public void testPrivateConstructor() throws Throwable {
+        
+        Constructor<?>[] ctors;
+        ctors = PathUtils.class.getDeclaredConstructors();
+        assertEquals(ctors.length, 1, "PathUtils must have exactly one constructor");
+        assertEquals(ctors[0].getModifiers() & Modifier.PRIVATE, Modifier.PRIVATE,
+                        "PathUtils constructor must be private");
+        assertEquals(ctors[0].getParameterTypes().length, 0, "PathUtils constructor must have no arguments");
+        
+        try {
+            ctors[0].setAccessible(true);
+            ctors[0].newInstance();
+        } catch (InvocationTargetException e) {
+            throw e.getCause();
+        }
+    }
+    
+    @Test(expectedExceptions = {NullPointerException.class})
+    public void testNullPath() throws IOException {
+        PathUtils.getNextPath(null, "test", "txt");
+    }
+    
+    @Test(expectedExceptions = {IllegalArgumentException.class})
+    public void testNonExistentPath() throws IOException {
+        PathUtils.getNextPath(Paths.get("foobar"), "test", "txt");
+    }
+
+    @Test(expectedExceptions = {NullPointerException.class})
+    public void testNullBaseName() throws IOException {
+        PathUtils.getNextPath(getOutputPath(), null, "txt");
+    }
+
+    @Test(expectedExceptions = {IllegalArgumentException.class})
+    public void testEmptyBaseName() throws IOException {
+        PathUtils.getNextPath(getOutputPath(), "", "txt");
+    }
+
+    @Test(expectedExceptions = {NullPointerException.class})
+    public void testNullExtenstion() throws IOException {
+        PathUtils.getNextPath(getOutputPath(), "test", null);
+    }
+
+    @Test(expectedExceptions = {IllegalArgumentException.class})
+    public void testEmptyExtension() throws IOException {
+        PathUtils.getNextPath(getOutputPath(), "test", "");
+    }
+}