Merge pull request #8 from gravity9piotr/feature/787_json_path_parser

#787 JsonPath parsing

Author: pbugara

src/main/java/com/github/fge/jsonpatch/AddOperation.java

@@ -75,18 +75,11 @@ public JsonNode applyInternal(final JsonNode node) throws JsonPatchException {
         if (path.isEmpty()) {
             return value;
         }
-        /*
-         * Check the parent node: it must exist and be a container (ie an array
-         * or an object) for the add operation to work.
-         */
-        final String fullJsonPath = JsonPathParser.tmfStringToJsonPath(path);
-        final int lastDotIndex = fullJsonPath.lastIndexOf('.');
-        final String newNodeName = fullJsonPath.substring(lastDotIndex + 1)
-                .replace("[", "").replace("]", "");
-        final String pathToParent = fullJsonPath.substring(0, lastDotIndex);
+        PathDetails pathDetails = PathParser.getParentPathAndNewNodeName(path);
+        final String pathToParent = pathDetails.getPathToParent();
+        final String newNodeName = pathDetails.getNewNodeName();
 
         final DocumentContext nodeContext = JsonPath.parse(node.deepCopy());
-
         final JsonNode evaluatedJsonParents = nodeContext.read(pathToParent);
         if (evaluatedJsonParents == null) {
             throw new JsonPatchException(BUNDLE.getMessage("jsonPatch.noSuchParent"));
@@ -95,7 +88,7 @@ public JsonNode applyInternal(final JsonNode node) throws JsonPatchException {
             throw new JsonPatchException(BUNDLE.getMessage("jsonPatch.parentNotContainer"));
         }
 
-        if (pathToParent.contains("[?(")) { // json filter result is always a list
+        if (pathDetails.doesContainFiltersOrMultiIndexesNotation()) { // json filter result is always a list
             for (int i = 0; i < evaluatedJsonParents.size(); i++) {
                 JsonNode parentNode = evaluatedJsonParents.get(i);
                 if (!parentNode.isContainerNode()) {

src/main/java/com/github/fge/jsonpatch/PathDetails.java

@@ -0,0 +1,37 @@
+package com.github.fge.jsonpatch;
+
+public class PathDetails {
+
+    private final String pathToParent;
+
+    private final String newNodeName;
+
+    private final boolean containsFiltersOrMultiIndexesNotation;
+
+    public PathDetails(String pathToParent, String newNodeName, boolean containsFiltersOrMultiIndexesNotation) {
+        this.pathToParent = pathToParent;
+        this.newNodeName = newNodeName;
+        this.containsFiltersOrMultiIndexesNotation = containsFiltersOrMultiIndexesNotation;
+    }
+
+    public String getPathToParent() {
+        return pathToParent;
+    }
+
+    public String getNewNodeName() {
+        return newNodeName;
+    }
+
+    public boolean doesContainFiltersOrMultiIndexesNotation() {
+        return containsFiltersOrMultiIndexesNotation;
+    }
+
+    @Override
+    public String toString() {
+        return "PathDetails{" +
+                "pathToParent='" + pathToParent + '\'' +
+                ", newNodeName='" + newNodeName + '\'' +
+                ", containsFiltersOrMultiIndexesNotation=" + containsFiltersOrMultiIndexesNotation +
+                '}';
+    }
+}

src/main/java/com/github/fge/jsonpatch/PathParser.java

@@ -0,0 +1,120 @@
+package com.github.fge.jsonpatch;
+
+import com.jayway.jsonpath.internal.Path;
+import com.jayway.jsonpath.internal.path.PathCompiler;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class PathParser {
+
+    private static final String FILTER_PLACEHOLDER = "[?]";
+
+    /**
+     * This method parses JsonPath to find node name that needs to be added and path to the parent of new node.
+     * Additionally, it finds if path contains filter or multi index notation (like [1:5])
+     *
+     * @param path Path in JsonPath or JsonPointer notation
+     * @return PathDetails containing path to parent, name of new node and boolean value if path contains filter or multi
+     * index notation
+     * */
+    public static PathDetails getParentPathAndNewNodeName(String path) throws JsonPatchException {
+        final String fullJsonPath = JsonPathParser.tmfStringToJsonPath(path);
+        final Path compiledPath = compilePath(fullJsonPath);
+        String[] splitJsonPath = splitJsonPath(compiledPath);
+
+        int filterCounter = 0;
+        List<String> filters = getFiltersOperations(fullJsonPath);
+        boolean containsFiltersOrMultiIndexNotation = false;
+        StringBuilder sb = new StringBuilder();
+        sb.append("$");
+        for (int i = 0; i < splitJsonPath.length - 1; i++) {
+            if (splitJsonPath[i].isEmpty()) {
+                continue;
+            }
+            if (splitJsonPath[i].equals(FILTER_PLACEHOLDER)) {
+                sb.append(filters.get(filterCounter++));
+                containsFiltersOrMultiIndexNotation = true;
+            } else if (isArrayPart(splitJsonPath[i])) {
+                sb.append(splitJsonPath[i]);
+                if (isMultiIndexNotation(splitJsonPath[i])) {
+                    containsFiltersOrMultiIndexNotation = true;
+                }
+            } else if (isDoubleDot(splitJsonPath[i])) {
+                sb.append(splitJsonPath[i]);
+            } else {
+                sb.append("[").append(splitJsonPath[i]).append("]");
+            }
+        }
+        final String pathToParent = sb.toString();
+        final String newNodeName = getNewNodeName(splitJsonPath);
+        return new PathDetails(pathToParent, newNodeName, containsFiltersOrMultiIndexNotation);
+    }
+
+    private static boolean isMultiIndexNotation(String path) {
+        String pathWithoutBracket = path
+                .replace("[", "")
+                .replace("]", "");
+        return !pathWithoutBracket.startsWith("'") && !pathWithoutBracket.matches("[0-9]+");
+    }
+
+    private static String getNewNodeName(String[] splitJsonPath) {
+        return splitJsonPath[splitJsonPath.length - 1]
+                .replace("'", "")
+                .replace("[", "")
+                .replace("]", "");
+    }
+
+    /**
+     * Removes $ sign from the beginning of the path for easier processing - it will be added later on
+     * This method is called after PathCompiler.compile, so we are sure now, that the path is correct
+     * and bracket notation is used.
+     * We can now split JsonPath using positive lookahead regex (without removing separator).
+     * */
+    private static String[] splitJsonPath(Path compiledPath) {
+        return compiledPath.toString()
+                .replace("$", "")
+                .split("(?=\\[)");
+    }
+
+    private static Path compilePath(String fullJsonPath) throws JsonPatchException {
+        try {
+            return PathCompiler.compile(fullJsonPath);
+        } catch (Exception e) {
+            throw new JsonPatchException("Non-compilable path provided");
+        }
+    }
+
+    private static boolean isDoubleDot(String jsonPathPart) {
+        return jsonPathPart.equals("..");
+    }
+
+    private static boolean isArrayPart(String jsonPathPart) {
+        return jsonPathPart.startsWith("[") && jsonPathPart.endsWith("]");
+    }
+
+    private static List<String> getFiltersOperations(String jsonPath) {
+        if (!jsonPath.contains("[?(")) {
+            return new ArrayList<>();
+        }
+        List<String> filters = new ArrayList<>();
+        int openingBracketPosition = -1;
+        int counter = 0;
+        for (int i = 0; i < jsonPath.length(); i++) {
+            if (jsonPath.charAt(i) == '[' && jsonPath.charAt(i+1) == '?') {
+                if (openingBracketPosition == -1) {
+                    openingBracketPosition = i;
+                }
+                counter++;
+            }
+            if (jsonPath.charAt(i) == ']' && counter > 0) {
+                counter--;
+                if (counter == 0) {
+                    filters.add(jsonPath.substring(openingBracketPosition, i+1));
+                    openingBracketPosition = -1;
+                }
+            }
+        }
+        return filters;
+    }
+}