refactor: patch matching management

Author: deblockt

src/main/java/com/deblock/jsondiff/matcher/IgnoringFieldMatcher.java

@@ -6,17 +6,18 @@
 
 import java.util.Arrays;
 import java.util.List;
-import java.util.regex.Pattern;
 
 public class IgnoringFieldMatcher implements PartialJsonMatcher {
-    private final List<Pattern> fieldsToIgnore;
+    private final List<PathMatcher> fieldsToIgnore;
 
-    public IgnoringFieldMatcher(List<Pattern> patterns) {
-        this.fieldsToIgnore = patterns;
+    public IgnoringFieldMatcher(List<String> paths) {
+        this.fieldsToIgnore = paths.stream()
+                .map(PathMatcher::from)
+                .toList();
     }
 
-    public IgnoringFieldMatcher(Pattern... patterns) {
-        this.fieldsToIgnore = Arrays.stream(patterns).toList();
+    public IgnoringFieldMatcher(String ...paths) {
+        this(Arrays.stream(paths).toList());
     }
 
     @Override
@@ -26,7 +27,6 @@ public JsonDiff jsonDiff(Path path, JsonNode expectedJson, JsonNode receivedJson
 
     @Override
     public boolean manage(Path path, JsonNode expected, JsonNode received) {
-        String stringPath = path.toString();
-        return fieldsToIgnore.stream().anyMatch(pattern -> pattern.matcher(stringPath).matches());
+        return fieldsToIgnore.stream().anyMatch(pattern -> pattern.match(path));
     }
 }

src/main/java/com/deblock/jsondiff/matcher/Path.java

@@ -2,50 +2,88 @@
 
 import java.util.Objects;
 
+/**
+ * Represents a JSON path (e.g., $.property.0.subproperty).
+ * Stored in reverse order (last element at head) for O(1) add operations
+ * and efficient end-matching in PathMatcher.
+ */
 public class Path {
     public static final Path ROOT = new Path();
 
-    public final PathItem property;
-    public final Path next;
+    private final PathItem last;
+    private final Path previous;
 
     public Path() {
         this(null, null);
     }
 
-    private Path(PathItem property, Path next) {
-        this.property = property;
-        this.next = next;
+    private Path(PathItem last, Path previous) {
+        this.last = last;
+        this.previous = previous;
     }
 
-    private Path(PathItem property) {
-        this.property = property;
-        this.next = null;
+    public Path add(PathItem item) {
+        if (this.last == null) {
+            return new Path(item, null);
+        }
+        return new Path(item, this);
     }
 
-    public Path add(PathItem item) {
-        if (this.next == null) {
-            return new Path(this.property, new Path(item));
-        } else {
-            return new Path(this.property, this.next.add(item));
+    public PathItem item() {
+        return last;
+    }
+
+    /**
+     * Returns the path without its last element.
+     */
+    public Path previous() {
+        return previous == null ? ROOT : previous;
+    }
+
+    /**
+     * Returns the path items in natural order (from root to leaf).
+     * This is useful for traversing the path from start to end.
+     */
+    public java.util.List<PathItem> toList() {
+        java.util.List<PathItem> result = new java.util.ArrayList<>();
+        collectItems(result);
+        return result;
+    }
+
+    private void collectItems(java.util.List<PathItem> result) {
+        if (last == null) return;
+        if (previous != null) {
+            previous.collectItems(result);
         }
+        result.add(last);
     }
 
+    @Override
     public String toString() {
-        return ((this.property == null) ? "$" : this.property) +
-                ((this.next == null) ? "" : "." + this.next);
+        StringBuilder sb = new StringBuilder("$");
+        appendReversed(sb);
+        return sb.toString();
+    }
+
+    private void appendReversed(StringBuilder sb) {
+        if (last == null) return;
+        if (previous != null) {
+            previous.appendReversed(sb);
+        }
+        sb.append(".").append(last);
     }
 
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
         Path path = (Path) o;
-        return Objects.equals(property, path.property) && Objects.equals(next, path.next);
+        return Objects.equals(last, path.last) && Objects.equals(previous, path.previous);
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(property, next);
+        return Objects.hash(last, previous);
     }
 
     public interface PathItem {

src/main/java/com/deblock/jsondiff/matcher/PathMatcher.java

@@ -1,128 +1,102 @@
 package com.deblock.jsondiff.matcher;
 
-
 public class PathMatcher {
-    public final PathMatcher.PathMatcherItem property;
-    public final PathMatcher next;
+    public final PathMatcherItem last;
+    public final PathMatcher previous;
 
     public static PathMatcher from(String path) {
         PathMatcher matcher = new PathMatcher();
-        for (String part: path.split("\\.")) {
+        for (String part : path.split("\\.")) {
+            if (part.isEmpty()) {
+                throw new IllegalArgumentException("path matcher part can not be empty");
+            }
             if (part.endsWith("]")) {
                 String index = part.substring(part.lastIndexOf("[") + 1, part.length() - 1);
-                matcher = matcher.add(new PathMatcherItem.ObjectProperty(part.substring(0, part.lastIndexOf("["))));
-                if ("*".equals(index)) {
-                    matcher = matcher.add(new PathMatcherItem.WilcardMatcherItem(Path.PathItem.ArrayIndex.class));
-                } else {
-                    matcher = matcher.add(new PathMatcherItem.ArrayIndex(Integer.parseInt(index)));
-                }
-            } else if ("*".equals(part)) {
-                matcher = matcher.add(new PathMatcherItem.WilcardMatcherItem(Path.PathItem.ObjectProperty.class));
+                matcher = matcher.add(PathMatcherItem.ofProperty(part.substring(0, part.lastIndexOf("["))));
+                matcher = matcher.add(PathMatcherItem.ofArrayIndex(index));
             } else {
-                matcher = matcher.add(new PathMatcher.PathMatcherItem.ObjectProperty(part));
+                matcher = matcher.add(PathMatcherItem.ofProperty(part));
             }
         }
         return matcher;
     }
 
-    public PathMatcher() {
+    private PathMatcher() {
         this(null, null);
     }
 
-    private PathMatcher(PathMatcher.PathMatcherItem property, PathMatcher next) {
-        this.property = property;
-        this.next = next;
+    private PathMatcher(PathMatcherItem last, PathMatcher previous) {
+        this.last = last;
+        this.previous = previous;
     }
 
-    private PathMatcher(PathMatcher.PathMatcherItem property) {
-        this.property = property;
-        this.next = null;
-    }
-
-    public PathMatcher add(PathMatcher.PathMatcherItem item) {
-        if (this.next == null) {
-            return new PathMatcher(this.property, new PathMatcher(item));
-        } else {
-            return new PathMatcher(this.property, this.next.add(item));
+    private PathMatcher add(PathMatcherItem item) {
+        if (this.last == null) {
+            return new PathMatcher(item, null);
         }
+        return new PathMatcher(item, this);
     }
 
     public boolean match(Path path) {
-        int pathLength = length(path);
-        int matcherLength = length();
+        if (this.last == null) {
+            return true;
+        }
 
-        if (matcherLength > pathLength) {
+        if (path == null || path.item() == null) {
             return false;
         }
 
-        // Align path to match from the end
-        Path alignedPath = path;
-        for (int i = 0; i < pathLength - matcherLength; i++) {
-            alignedPath = alignedPath.next;
+        if (!this.last.match(path.item())) {
+            return false;
         }
 
-        return matchFromHere(alignedPath);
-    }
-
-    private int length() {
-        int count = 0;
-        PathMatcher current = this;
-        while (current != null && current.property != null) {
-            count++;
-            current = current.next;
+        if (this.previous == null) {
+            return true;
         }
-        return count;
-    }
 
-    private int length(Path path) {
-        int count = 0;
-        Path current = path;
-        while (current != null && current.property != null) {
-            count++;
-            current = current.next;
-        }
-        return count;
+        return this.previous.match(path.previous());
     }
 
-    private boolean matchFromHere(Path path) {
-        if (this.property == null) {
-            return next == null || next.matchFromHere(path);
-        }
-        if (path == null || path.property == null) {
-            return false;
-        }
-        if (this.property.match(path.property)) {
-            if (next == null) {
-                return path.next == null || path.next.property == null;
-            }
-            return path.next != null && next.matchFromHere(path.next);
-        }
-        return false;
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder("$");
+        appendReversed(sb);
+        return sb.toString();
     }
 
-    public String toString() {
-        return ((this.property == null) ? "$" : this.property) +
-                ((this.next == null) ? "" : "." + this.next);
+    private void appendReversed(StringBuilder sb) {
+        if (last == null) return;
+        if (previous != null) {
+            previous.appendReversed(sb);
+        }
+        sb.append(".").append(last);
     }
 
-    private interface PathMatcherItem {
-        static PathMatcherItem of(String property) {
-            return new PathMatcher.PathMatcherItem.ObjectProperty(property);
+    public interface PathMatcherItem {
+        static PathMatcherItem ofProperty(String property) {
+            if ("*".equals(property)) {
+                return new WildcardMatcherItem(Path.PathItem.ObjectProperty.class);
+            }
+            return new ObjectProperty(property);
         }
 
-        static PathMatcherItem of(Integer index) {
-            return new PathMatcher.PathMatcherItem.ArrayIndex(index);
+        static PathMatcherItem ofArrayIndex(String index) {
+            if ("*".equals(index)) {
+                return new WildcardMatcherItem(Path.PathItem.ArrayIndex.class);
+            }
+            return new ArrayIndex(Integer.parseInt(index));
         }
 
         boolean match(Path.PathItem pathItem);
 
-        class WilcardMatcherItem implements PathMatcherItem {
+        class WildcardMatcherItem implements PathMatcherItem {
             private final Class<? extends Path.PathItem> type;
 
-            public WilcardMatcherItem(Class<? extends Path.PathItem> type) {
+            public WildcardMatcherItem(Class<? extends Path.PathItem> type) {
                 this.type = type;
             }
 
+            @Override
             public String toString() {
                 return "*";
             }