Extract ZipPaths for splitting and joining zip paths

4 files changed, 106 insertions, 15 deletions

diff --git a/src/main/java/org/zwobble/mammoth/internal/archives/ZipPaths.java b/src/main/java/org/zwobble/mammoth/internal/archives/ZipPaths.java
new file mode 100644
index 0000000..52fa2f4
--- /dev/null
+++ b/src/main/java/org/zwobble/mammoth/internal/archives/ZipPaths.java
@@ -0,0 +1,54 @@
+package org.zwobble.mammoth.internal.archives;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static java.util.Arrays.asList;
+import static org.zwobble.mammoth.internal.util.Lists.eagerFilter;
+
+public class ZipPaths {
+    private ZipPaths() {
+    }
+
+    public static class SplitPath {
+        private final String dirname;
+        private final String basename;
+
+        public SplitPath(String dirname, String basename) {
+            this.dirname = dirname;
+            this.basename = basename;
+        }
+
+        public String getDirname() {
+            return dirname;
+        }
+
+        public String getBasename() {
+            return basename;
+        }
+    }
+
+    public static SplitPath splitPath(String path) {
+        int index = path.lastIndexOf("/");
+        if (index == -1) {
+            return new SplitPath("", path);
+        } else {
+            String dirname = path.substring(0, index);
+            String basename = path.substring(index + 1);
+            return new SplitPath(dirname, basename);
+        }
+    }
+
+    public static String joinPath(String... paths) {
+        List<String> nonEmptyPaths = eagerFilter(asList(paths), path -> !path.isEmpty());
+
+        List<String> relevantPaths = new ArrayList<>();
+        for (String path : nonEmptyPaths) {
+            if (path.startsWith("/")) {
+                relevantPaths.clear();
+            }
+            relevantPaths.add(path);
+        }
+        return String.join("/", relevantPaths);
+    }
+}
diff --git a/src/main/java/org/zwobble/mammoth/internal/docx/DocumentReader.java b/src/main/java/org/zwobble/mammoth/internal/docx/DocumentReader.java
index 727731e..b506d99 100644
--- a/src/main/java/org/zwobble/mammoth/internal/docx/DocumentReader.java
+++ b/src/main/java/org/zwobble/mammoth/internal/docx/DocumentReader.java
@@ -1,6 +1,7 @@
 package org.zwobble.mammoth.internal.docx;
 
 import org.zwobble.mammoth.internal.archives.Archive;
+import org.zwobble.mammoth.internal.archives.ZipPaths;
 import org.zwobble.mammoth.internal.documents.Comment;
 import org.zwobble.mammoth.internal.documents.Document;
 import org.zwobble.mammoth.internal.documents.Notes;
@@ -16,7 +17,6 @@ import java.util.Optional;
 import java.util.function.BiFunction;
 
 import static org.zwobble.mammoth.internal.util.Lists.*;
-import static org.zwobble.mammoth.internal.util.Strings.split;
 import static org.zwobble.mammoth.internal.util.Strings.trimLeft;
 
 public class DocumentReader {
@@ -126,11 +126,8 @@ public class DocumentReader {
     }
 
     private static String findRelationshipsPathFor(String name) {
-        List<String> parts = split(name, "/");
-        return String.join("/", eagerConcat(
-            parts.subList(0, parts.size() - 1),
-            list("_rels/" + parts.get(parts.size() - 1) + ".rels")
-        ));
+        ZipPaths.SplitPath parts = ZipPaths.splitPath(name);
+        return ZipPaths.joinPath(parts.getDirname(), "_rels", parts.getBasename() + ".rels");
     }
 
     private static Optional<XmlElement> tryParseOfficeXml(Archive zipFile, String name) {
diff --git a/src/main/java/org/zwobble/mammoth/internal/util/Strings.java b/src/main/java/org/zwobble/mammoth/internal/util/Strings.java
index e672785..f39f35e 100644
--- a/src/main/java/org/zwobble/mammoth/internal/util/Strings.java
+++ b/src/main/java/org/zwobble/mammoth/internal/util/Strings.java
@@ -1,10 +1,5 @@
 package org.zwobble.mammoth.internal.util;
 
-import java.util.List;
-import java.util.regex.Pattern;
-
-import static java.util.Arrays.asList;
-
 public class Strings {
     public static String trimLeft(String value, char character) {
         int index = 0;
@@ -21,8 +16,4 @@ public class Strings {
     public static boolean startsWithIgnoreCase(String value, String prefix) {
         return value.regionMatches(true, 0, prefix, 0, prefix.length());
     }
-
-    public static List<String> split(String value, String separator) {
-        return asList(value.split(Pattern.quote(separator)));
-    }
 }
diff --git a/src/test/java/org/zwobble/mammoth/tests/archives/ZipPathsTests.java b/src/test/java/org/zwobble/mammoth/tests/archives/ZipPathsTests.java
new file mode 100644
index 0000000..88d613f
--- /dev/null
+++ b/src/test/java/org/zwobble/mammoth/tests/archives/ZipPathsTests.java
@@ -0,0 +1,49 @@
+package org.zwobble.mammoth.tests.archives;
+
+import org.hamcrest.Matcher;
+import org.junit.jupiter.api.Test;
+import org.zwobble.mammoth.internal.archives.ZipPaths;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.zwobble.mammoth.tests.DeepReflectionMatcher.deepEquals;
+
+public class ZipPathsTests {
+    @Test
+    public void splitPathSplitZipPathsOnLastForwardSlash() {
+        assertThat(ZipPaths.splitPath("a/b"), isSplitPath("a", "b"));
+        assertThat(ZipPaths.splitPath("a/b/c"), isSplitPath("a/b", "c"));
+        assertThat(ZipPaths.splitPath("/a/b/c"), isSplitPath("/a/b", "c"));
+    }
+
+    @Test
+    public void whenPathHasNoForwardSlashesThenSplitPathReturnsEmptyDirname() {
+        assertThat(ZipPaths.splitPath("name"), isSplitPath("", "name"));
+    }
+
+    private Matcher<ZipPaths.SplitPath> isSplitPath(String dirname, String basename) {
+        return deepEquals(new ZipPaths.SplitPath(dirname, basename));
+    }
+
+    @Test
+    public void joinPathJoinsArgumentsWithForwardSlashes() {
+        assertThat(ZipPaths.joinPath("a", "b"), equalTo("a/b"));
+        assertThat(ZipPaths.joinPath("a/b", "c"), equalTo("a/b/c"));
+        assertThat(ZipPaths.joinPath("/a/b", "c"), equalTo("/a/b/c"));
+    }
+
+    @Test
+    public void emptyPartsAreIgnoredWhenJoiningPaths() {
+        assertThat(ZipPaths.joinPath("a", ""), equalTo("a"));
+        assertThat(ZipPaths.joinPath("", "b"), equalTo("b"));
+        assertThat(ZipPaths.joinPath("a", "", "b"), equalTo("a/b"));
+    }
+
+    @Test
+    public void whenJoiningPathsThenAbsolutePathsIgnoreEarlierPaths() {
+        assertThat(ZipPaths.joinPath("a", "/b"), equalTo("/b"));
+        assertThat(ZipPaths.joinPath("a", "/b", "c"), equalTo("/b/c"));
+        assertThat(ZipPaths.joinPath("/a", "/b"), equalTo("/b"));
+        assertThat(ZipPaths.joinPath("/a"), equalTo("/a"));
+    }
+}