Merge branch '2.14'

Author: cowtowncoder

src/main/java/com/fasterxml/jackson/databind/JsonNode.java

@@ -41,6 +41,45 @@ public abstract class JsonNode
     extends JacksonSerializable.Base // i.e. implements JacksonSerializable
     implements TreeNode, Iterable<JsonNode>
 {
+    /**
+     * Configuration setting used with {@link JsonNode#withObject(JsonPointer)}
+     * method overrides, to indicate which overwrites are acceptable if the
+     * path pointer indicates has incompatible nodes (for example, instead
+     * of Object node a Null node is encountered).
+     * Overwrite means that the existing value is replaced with compatible type,
+     * potentially losing existing values or even sub-trees.
+     *<p>
+     * Default value if {@code NULLS} which only allows Null-value nodes
+     * to be replaced but no other types.
+     *
+     * @since 2.14
+     */
+    public enum OverwriteMode {
+        /**
+         * Mode in which no values may be overwritten, not even {@code NullNode}s;
+         * only compatible paths may be traversed.
+         */
+        NONE,
+
+        /**
+         * Mode in which explicit {@code NullNode}s may be replaced but no other
+         * node types. 
+         */
+        NULLS,
+
+        /**
+         * Mode in which all scalar value nodes may be replaced, but not
+         * Array or Object nodes.
+         */
+        SCALARS,
+
+        /**
+         * Mode in which all incompatible node types may be replaced, including
+         * Array and Object nodes where necessary.
+         */
+        ALL;
+    }
+
     /*
     /**********************************************************************
     /* Construction, related
@@ -1058,15 +1097,42 @@ public final List<JsonNode> findParents(String fieldName)
      */
     public abstract ObjectNode withObject(String propertyName);
 
+    /**
+     * Same as {@link #withObject(JsonPointer, OverwriteMode, boolean)} but
+     * with defaults of {@code OvewriteMode#NULLS} (overwrite mode)
+     * and {@code true} for {@code preferIndex} (that is, will try to
+     * consider {@link JsonPointer} segments index if at all possible
+     * and only secondarily as property name
+     *
+     * @param ptr Pointer that indicates path to use for Object value to return
+     *   (potentially creating as necessary)
+     *
+     * @return ObjectNode found or created
+     *
+     * @since 2.14
+     */
+    public final ObjectNode withObject(JsonPointer ptr) {
+        return withObject(ptr, OverwriteMode.NULLS, true);
+    }
+
     /**
      * Method that can be called on Object nodes, to access a Object-valued
      * node pointed to by given {@link JsonPointer}, if such a node exists:
      * if not, an attempt is made to create it.
      * If the node method is called on is not Object node,
      * or if property exists and has value that is not Object node,
      * {@link DatabindException} is thrown
-     */
-    public abstract ObjectNode withObject(JsonPointer ptr);
+     *
+     * @param ptr Pointer that indicates path to use for Object value to return
+     *   (potentially creating as necessary)
+     * @param overwriteMode Defines w
+     */
+    public ObjectNode withObject(JsonPointer ptr,
+            OverwriteMode overwriteMode, boolean preferIndex) {
+        // To avoid abstract method, base implementation just fails
+        throw new UnsupportedOperationException("`withObject(JsonPointer)` not implemented by "
+                +getClass().getName());
+    }
 
     /**
      * Method that can be called on Object nodes, to access a property

src/main/java/com/fasterxml/jackson/databind/node/ArrayNode.java

@@ -63,7 +63,8 @@ public ArrayNode deepCopy()
 
     @Override
     protected ObjectNode _withObjectCreatePath(JsonPointer origPtr,
-            JsonPointer currentPtr)
+            JsonPointer currentPtr,
+            OverwriteMode overwriteMode, boolean preferIndex)
     {
         // With Arrays, bit different; the first entry needs to be index
         if (!currentPtr.mayMatchElement()) {
@@ -91,7 +92,7 @@ protected ObjectNode _withObjectCreatePath(JsonPointer origPtr,
             currentNode = currentNode.putObject(currentPtr.getMatchingProperty());
             currentPtr = currentPtr.tail();
         }
-        return currentNode;
+        return (ObjectNode) currentNode;
     }
 
     /*

src/main/java/com/fasterxml/jackson/databind/node/BaseJsonNode.java

@@ -114,7 +114,7 @@ public JsonParser.NumberType numberType() {
 
     /*
     /**********************************************************************
-    /* JacksonSerializable
+    /* With-Traversal
     /**********************************************************************
      */
 
@@ -123,23 +123,25 @@ public ObjectNode withObject(String propertyName) {
         return _reportWrongNodeType(
                 "Can only call `withObject(String)` on `ObjectNode`, not `%s`",
             getClass().getName());
-    }
+    }    
 
     @Override
-    public ObjectNode withObject(JsonPointer ptr) {
+    public ObjectNode withObject(JsonPointer ptr,
+            OverwriteMode overwriteMode, boolean preferIndex) {
         if (!isObject()) {
             // To avoid abstract method, base implementation just fails
             _reportWrongNodeType("Can only call `withObject(JsonPointer)` on `ObjectNode`, not `%s`",
                 getClass().getName());
         }
-        return _withObject(ptr, ptr);
+        return _withObject(ptr, ptr, overwriteMode, preferIndex);
     }
 
     protected ObjectNode _withObject(JsonPointer origPtr,
-            JsonPointer currentPtr)
+            JsonPointer currentPtr,
+            OverwriteMode overwriteMode, boolean preferIndex)
     {
         if (currentPtr.matches()) {
-            if (this.isObject()) {
+            if (this instanceof ObjectNode) {
                 return (ObjectNode) this;
             }
             return _reportWrongNodeType(
@@ -148,10 +150,12 @@ protected ObjectNode _withObject(JsonPointer origPtr,
                     getClass().getName());
         }
         JsonNode n = _at(currentPtr);
+        // If there's a path, follow it
         if ((n != null) && (n instanceof BaseJsonNode)) {
-            return ((BaseJsonNode) n)._withObject(origPtr, currentPtr.tail());
+            return ((BaseJsonNode) n)._withObject(origPtr, currentPtr.tail(),
+                    overwriteMode, preferIndex);
         }
-        return _withObjectCreatePath(origPtr, currentPtr);
+        return _withObjectCreatePath(origPtr, currentPtr, overwriteMode, preferIndex);
     }
 
     /**
@@ -160,7 +164,8 @@ protected ObjectNode _withObject(JsonPointer origPtr,
      * the innermost {@code ObjectNode} constructed.
      */
     protected ObjectNode _withObjectCreatePath(JsonPointer origPtr,
-            JsonPointer currentPtr)
+            JsonPointer currentPtr,
+            OverwriteMode overwriteMode, boolean preferIndex)
     {
         // Cannot traverse non-container nodes:
         return _reportWrongNodeType(

src/main/java/com/fasterxml/jackson/databind/node/ObjectNode.java

@@ -58,7 +58,8 @@ public ObjectNode deepCopy()
 
     @Override
     protected ObjectNode _withObjectCreatePath(JsonPointer origPtr,
-            JsonPointer currentPtr)
+            JsonPointer currentPtr,
+            OverwriteMode overwriteMode, boolean preferIndex)
     {
         ObjectNode currentNode = this;
         while (!currentPtr.matches()) {

src/test/java/com/fasterxml/jackson/databind/node/WithPathTest.java

@@ -40,6 +40,38 @@ public void testValidWithObjectSimple() throws Exception
                 root.toString());
     }
 
+    public void testObjectPathWithReplace() throws Exception
+    {
+        final JsonPointer abPath = JsonPointer.compile("/a/b");
+        ObjectNode root = MAPPER.createObjectNode();
+        root.put("a", 13);
+
+        // First, without replacement (default) get exception
+        try {
+            root.withObject(abPath);
+            fail("Should not pass");
+        } catch (UnsupportedOperationException e) {
+            verifyException(e, "cannot traverse non-container");
+        }
+
+        // Except fine via nulls (by default)
+        /*
+        root.putNull("a");
+        root.withObject(abPath).put("value", 42);
+        assertEquals(a2q("{'a':{'b':{'value':42}}}"),
+                root.toString());
+
+        // but not if prevented
+        root = (ObjectNode) MAPPER.readTree(a2q("{'a':null}"));
+        try {
+            root.withObject(abPath);
+            fail("Should not pass");
+        } catch (UnsupportedOperationException e) {
+            verifyException(e, "cannot traverse non-container");
+        }
+        */
+    }
+
     public void testValidWithObjectWithArray() throws Exception
     {
         ObjectNode root = MAPPER.createObjectNode();
@@ -56,5 +88,7 @@ public void testValidWithObjectWithArray() throws Exception
         match.put("value2", true);
         assertEquals(a2q("{'arr':[null,null,{'value':42,'value2':true}]}"),
                 root.toString());
+
+        // And even more! `null`s can be replaced
     }
 }