Merge branch '2.11'

Author: cowtowncoder

release-notes/CREDITS-2.x

@@ -1010,3 +1010,8 @@ Fitz (Joongsoo.Park) (joongsoo@github)
 Antonio Petrelli (apetrelli@github)
   * Reported #2049: TreeTraversingParser and UTF8StreamJsonParser create contexts differently
   (2.11.0)
+
+Joseph Koshakow (jkosh44@github)
+  * Contributed fix for #2515: `ObjectMapper.registerSubtypes(NamedType...)` doesn't allow registering
+    the same POJO for two different type ids
+ (contributed by Joseph	 K)

release-notes/VERSION-2.x

@@ -13,6 +13,9 @@ Project: jackson-databind
 #2503: Support `@JsonSerialize(keyUsing)` and `@JsonDeserialize(keyUsing)` on Key class
 #2511: Add `SerializationFeature.WRITE_SELF_REFERENCES_AS_NULL`
  (contributed by Joongsoo P)
+#2515: `ObjectMapper.registerSubtypes(NamedType...)` doesn't allow registering the same POJO
+  for two different type ids
+ (contributed by Joseph K)
 #2522: `DeserializationContext.handleMissingInstantiator()` throws `MismatchedInputException`
   for non-static inner classes
 #2525: Incorrect `JsonStreamContext` for `TokenBuffer` and `TreeTraversingParser`
@@ -37,6 +40,7 @@ Project: jackson-databind
 #2520: Sub-optimal exception message when failing to deserialize non-static inner classes
  (reported by Mark S)
 #2529: Add tests to ensure `EnumSet` and `EnumMap` work correctly with "null-as-empty"
+#2534: Add `BasicPolymorphicTypeValidator.Builder.allowIfSubTypeIsArray()`
 
 2.10.0 (26-Sep-2019)
 

src/main/java/com/fasterxml/jackson/databind/jsontype/BasicPolymorphicTypeValidator.java

@@ -37,15 +37,15 @@ public class BasicPolymorphicTypeValidator
      * General matcher interface (predicate) for validating class values
      * (base type or resolved subtype)
      */
-    protected abstract static class TypeMatcher {
+    public abstract static class TypeMatcher { // note: public since 2.11
         public abstract boolean match(Class<?> clazz);
     }
 
     /**
      * General matcher interface (predicate) for validating unresolved
      * subclass class name.
      */
-    protected abstract static class NameMatcher {
+    public abstract static class NameMatcher { // note: public since 2.11
         public abstract boolean match(String clazzName);
     }
 
@@ -64,6 +64,11 @@ protected abstract static class NameMatcher {
      * rules are checked.
      */
     public static class Builder {
+        /**
+         * Optional set of base types (exact match) that are NOT accepted
+         * as base types for polymorphic properties. May be used to prevent "unsafe"
+         * base types like {@link java.lang.Object} or {@link java.io.Serializable}.
+         */
         protected Set<Class<?>> _invalidBaseTypes;
 
         /**
@@ -81,7 +86,6 @@ public static class Builder {
          */
         protected List<TypeMatcher> _subTypeClassMatchers;
 
-        
         protected Builder() { }
 
         // // Methods for checking solely by base type (before subtype even considered)
@@ -152,6 +156,21 @@ public boolean match(Class<?> clazz) {
             });
         }
 
+        /**
+         * Method for appending custom matcher called with base type: if matcher returns
+         * {@code true}, all possible subtypes will be accepted; if {@code false}, other
+         * matchers are applied.
+         * 
+         * @param matcher Custom matcher to apply to base type
+         *
+         * @return This Builder to allow call chaining
+         *
+         * @since 2.11
+         */
+        public Builder allowIfBaseType(final TypeMatcher matcher) {
+            return _appendBaseMatcher(matcher);
+        }
+        
         /**
          * Method for appending matcher that will mark any polymorphic properties with exact
          * specific class to be invalid.
@@ -239,6 +258,44 @@ public boolean match(String clazzName) {
             });
         }
 
+        /**
+         * Method for appending custom matcher called with resolved subtype: if matcher returns
+         * {@code true}, type will be accepted; if {@code false}, other
+         * matchers are applied.
+         * 
+         * @param matcher Custom matcher to apply to resolved subtype
+         *
+         * @return This Builder to allow call chaining
+         *
+         * @since 2.11
+         */
+        public Builder allowIfSubType(final TypeMatcher matcher) {
+            return _appendSubClassMatcher(matcher);
+        }
+
+        /**
+         * Method for appending matcher that will allow all subtypes that are Java arrays
+         * (regardless of element type). Note that this does NOT validate element type
+         * itself as long as Polymorphic Type handling is enabled for element type: this
+         * is the case with all standard "Default Typing" inclusion criteria as well as for
+         * annotation ({@code @JsonTypeInfo}) use case (since annotation only applies to element
+         * types, not container).
+         *<p>
+         * NOTE: not used with other Java collection types ({@link java.util.List}s,
+         *    {@link java.util.Collection}s), mostly since use of generic types as polymorphic
+         *    values is not (well) supported.
+         *
+         * @since 2.10.1
+         */
+        public Builder allowIfSubTypeIsArray() {
+            return _appendSubClassMatcher(new TypeMatcher() {
+                @Override
+                public boolean match(Class<?> clazz) {
+                    return clazz.isArray();
+                }
+            });
+        }
+        
         public BasicPolymorphicTypeValidator build() {
             return new BasicPolymorphicTypeValidator(_invalidBaseTypes,
                     (_baseTypeMatchers == null) ? null : _baseTypeMatchers.toArray(new TypeMatcher[0]),

src/main/java/com/fasterxml/jackson/databind/jsontype/NamedType.java

@@ -1,5 +1,7 @@
 package com.fasterxml.jackson.databind.jsontype;
 
+import java.util.Objects;
+
 /**
  * Simple container class for types with optional logical name, used
  * as external identifier
@@ -14,10 +16,10 @@ public final class NamedType implements java.io.Serializable
     protected String _name;
 
     public NamedType(Class<?> c) { this(c, null); }
-    
+
     public NamedType(Class<?> c, String name) {
         _class = c;
-        _hashCode = c.getName().hashCode();
+        _hashCode = c.getName().hashCode() + ((name == null) ? 0 : name.hashCode());
         setName(name);
     }
 
@@ -28,14 +30,16 @@ public NamedType(Class<?> c, String name) {
     public boolean hasName() { return _name != null; }
 
     /**
-     * Equality is defined based on class only, not on name
+     * Equality is defined based on class and name
      */
     @Override
     public boolean equals(Object o) {
         if (o == this) return true;
         if (o == null) return false;
         if (o.getClass() != getClass()) return false;
-        return _class == ((NamedType) o)._class;
+        NamedType other = (NamedType)o;
+        return (_class == other._class)
+                && Objects.equals(_name, other._name);
     }
 
     @Override

src/main/java/com/fasterxml/jackson/databind/jsontype/impl/StdSubtypeResolver.java

@@ -128,6 +128,7 @@ public Collection<NamedType> collectAndResolveSubtypesByClass(MapperConfig<?> co
     {
         final AnnotationIntrospector ai = config.getAnnotationIntrospector();
         HashMap<NamedType, NamedType> subtypes = new HashMap<>();
+
         // then consider registered subtypes (which have precedence over annotations)
         if (_registeredSubtypes != null) {
             Class<?> rawBase = type.getRawType();
@@ -238,19 +239,23 @@ protected void _collectAndResolve(MapperConfig<?> config, AnnotatedClass annotat
             }
         }
 
+        //For Serialization we only want to return a single NamedType per class so it's
+        //unambiguous what name we use.
+        NamedType typeOnlyNamedType = new NamedType(namedType.getType());
+
         // First things first: is base type itself included?
-        if (collectedSubtypes.containsKey(namedType)) {
+        if (collectedSubtypes.containsKey(typeOnlyNamedType)) {
             // if so, no recursion; however, may need to update name?
             if (namedType.hasName()) {
-                NamedType prev = collectedSubtypes.get(namedType);
+                NamedType prev = collectedSubtypes.get(typeOnlyNamedType);
                 if (!prev.hasName()) {
-                    collectedSubtypes.put(namedType, namedType);
+                    collectedSubtypes.put(typeOnlyNamedType, namedType);
                 }
             }
             return;
         }
         // if it wasn't, add and check subtypes recursively
-        collectedSubtypes.put(namedType, namedType);
+        collectedSubtypes.put(typeOnlyNamedType, namedType);
         Collection<NamedType> st = ai.findSubtypes(config, annotatedType);
         if (st != null && !st.isEmpty()) {
             for (NamedType subtype : st) {

src/test/java/com/fasterxml/jackson/failing/BasicPTV2532Test.java renamed to src/test/java/com/fasterxml/jackson/databind/jsontype/vld/BasicPTVWithArraysTest.java

@@ -1,37 +1,33 @@
-package com.fasterxml.jackson.failing;
-
-import java.util.regex.Pattern;
+package com.fasterxml.jackson.databind.jsontype.vld;
 
 import com.fasterxml.jackson.databind.*;
 import com.fasterxml.jackson.databind.DefaultTyping;
-import com.fasterxml.jackson.databind.exc.InvalidDefinitionException;
 import com.fasterxml.jackson.databind.exc.InvalidTypeIdException;
 import com.fasterxml.jackson.databind.jsontype.BasicPolymorphicTypeValidator;
 import com.fasterxml.jackson.databind.jsontype.PolymorphicTypeValidator;
 
 /**
- * Tests for the main user-configurable {@code PolymorphicTypeValidator},
- * {@link BasicPolymorphicTypeValidator}.
+ * Tests related to [databind#2534], support for configuring
+ * {@link BasicPolymorphicTypeValidator} to allow all Array-valued
+ * polymorphic values.
  */
-public class BasicPTV2532Test extends BaseMapTest
+public class BasicPTVWithArraysTest extends BaseMapTest
 {
-    // // // Value types
-
-    static abstract class Base2532 {
+    static abstract class Base2534 {
         public int x = 3;
     }
 
-    static class Good2532 extends Base2532 {
-        protected Good2532() { }
-        public Good2532(int x) {
+    static class Good2534 extends Base2534 {
+        protected Good2534() { }
+        public Good2534(int x) {
             super();
             this.x = x;
         }
     }
 
-    static class Bad2532 extends Base2532 {
-        protected Bad2532() { }
-        public Bad2532(int x) {
+    static class Bad2534 extends Base2534 {
+        protected Bad2534() { }
+        public Bad2534(int x) {
             super();
             this.x = x;
         }
@@ -50,19 +46,17 @@ protected ObjectWrapper() { }
     /**********************************************************************
      */
 
-    // [databind#2532]: handle Java array-types appropriately wrt validation
+    // [databind#2534]: handle Java array-types appropriately wrt validation
     public void testAllowBySubClassInArray() throws Exception {
         PolymorphicTypeValidator ptv = BasicPolymorphicTypeValidator.builder()
-                .allowIfSubType(Good2532.class)
+                .allowIfSubType(Good2534.class)
                 .build();
         ObjectMapper mapper = jsonMapperBuilder()
                 .activateDefaultTyping(ptv, DefaultTyping.NON_FINAL)
                 .build();        
 
-        final ObjectWrapper input = new ObjectWrapper(new Base2532[] { new Good2532(42) });
-        final String json = mapper.writeValueAsString(input);
+        final String json = mapper.writeValueAsString(new ObjectWrapper(new Base2534[] { new Good2534(42) }));
 
-System.err.println("JSON: "+json);
         // First test blocked case:
         try {
             mapper.readValue(json, ObjectWrapper.class);
@@ -74,7 +68,8 @@ public void testAllowBySubClassInArray() throws Exception {
 
         // and then accepted:
         ptv = BasicPolymorphicTypeValidator.builder()
-                .allowIfSubType(Good2532.class)
+                .allowIfSubTypeIsArray() // key addition
+                .allowIfSubType(Good2534.class)
                 .build();
         mapper = jsonMapperBuilder()
                 .activateDefaultTyping(ptv, DefaultTyping.NON_FINAL)
@@ -83,10 +78,20 @@ public void testAllowBySubClassInArray() throws Exception {
         ObjectWrapper w = mapper.readValue(json, ObjectWrapper.class);
         assertNotNull(w);
         assertNotNull(w.value);
-        assertEquals(Base2532[].class, w.value.getClass());
-        Base2532[] arrayOut = (Base2532[]) w.value;
+        assertEquals(Base2534[].class, w.value.getClass());
+        Base2534[] arrayOut = (Base2534[]) w.value;
         assertEquals(1, arrayOut.length);
-
         assertEquals(42, arrayOut[0].x);
+
+        // but ensure array-acceptance does NOT allow non-validated element types!
+        final String badJson = mapper.writeValueAsString(new ObjectWrapper(new Base2534[] { new Bad2534(13) }));
+        try {
+            mapper.readValue(badJson, ObjectWrapper.class);
+            fail("Should not pass");
+        } catch (InvalidTypeIdException e) {
+            verifyException(e, "Could not resolve type id 'com.fasterxml.jackson.");
+            verifyException(e, "$Bad2534");
+            verifyException(e, "as a subtype of");
+        }
     }
 }

src/test/java/com/fasterxml/jackson/databind/jsontype/vld/CustomPTVMatchersTest.java

@@ -0,0 +1,52 @@
+package com.fasterxml.jackson.databind.jsontype.vld;
+
+import com.fasterxml.jackson.databind.BaseMapTest;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.DefaultTyping;
+import com.fasterxml.jackson.databind.exc.InvalidTypeIdException;
+import com.fasterxml.jackson.databind.jsontype.BasicPolymorphicTypeValidator;
+import com.fasterxml.jackson.databind.jsontype.PolymorphicTypeValidator;
+import com.fasterxml.jackson.databind.jsontype.vld.BasicPTVWithArraysTest.Base2534;
+import com.fasterxml.jackson.databind.jsontype.vld.BasicPTVWithArraysTest.Good2534;
+import com.fasterxml.jackson.databind.jsontype.vld.BasicPTVWithArraysTest.ObjectWrapper;
+
+public class CustomPTVMatchersTest extends BaseMapTest
+{
+    static abstract class CustomBase {
+        public int x = 3;
+    }
+
+    static class CustomGood extends CustomBase {
+        protected CustomGood() { }
+        public CustomGood(int x) {
+            super();
+            this.x = x;
+        }
+    }
+
+    static class CustomBad extends CustomBase {
+        protected CustomBad() { }
+        public CustomBad(int x) {
+            super();
+            this.x = x;
+        }
+    }
+
+    static final class ObjectWrapper {
+        public Object value;
+
+        protected ObjectWrapper() { }
+        public ObjectWrapper(Object v) { value = v; }
+    }
+
+    /*
+    /**********************************************************************
+    /* Test methods
+    /**********************************************************************
+     */
+
+    public void testCustomBaseMatchers() throws Exception
+    {
+        // TO BE COMPLETED
+    }
+}