Merge branch 'master' of github.com:FasterXML/jackson-databind

Author: cowtowncoder

release-notes/VERSION

@@ -4,6 +4,9 @@ Version: 2.5.0 (xx-xxx-2014)
 #521: Keep bundle annotations, prevent problems with recursive annotation
    types
   (reported by tea-dragon@github)
+#539: Problem with post-procesing of "empty bean" serializer; was not calling
+  'BeanSerializerModifier.modifySerializer()` for empty beans
+ (reported by Fabien R, fabienrenaud@github)
 #543: Problem resolving self-referential recursive types
   (reported by ahgittin@github)
 

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

@@ -1073,12 +1073,23 @@ public ObjectMapper enableDefaultTyping(DefaultTyping dti) {
      * Method for enabling automatic inclusion of type information, needed
      * for proper deserialization of polymorphic types (unless types
      * have been annotated with {@link com.fasterxml.jackson.annotation.JsonTypeInfo}).
+     *<P>
+     * NOTE: use of {@link JsonTypeInfo.As#EXTERNAL_PROPERTY} is <b>NOT SUPPORTED</b>;
+     * and attempts of do so will throw an {@link IllegalArgumentException} to make
+     * this limitation explicit.
      * 
      * @param applicability Defines kinds of types for which additional type information
      *    is added; see {@link DefaultTyping} for more information.
      */
     public ObjectMapper enableDefaultTyping(DefaultTyping applicability, JsonTypeInfo.As includeAs)
     {
+        /* 18-Sep-2014, tatu: Let's add explicit check to ensure no one tries to
+         *   use "As.EXTERNAL_PROPERTY", since that will not work.
+         */
+        if (includeAs == JsonTypeInfo.As.EXTERNAL_PROPERTY) {
+            throw new IllegalArgumentException("Can not use includeAs of "+includeAs);
+        }
+        
         TypeResolverBuilder<?> typer = new DefaultTypeResolverBuilder(applicability);
         // we'll always use full class name, when using defaulting
         typer = typer.init(JsonTypeInfo.Id.CLASS, null);

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

@@ -745,6 +745,17 @@ public JsonSerializer<Object> getUnknownTypeSerializer(Class<?> unknownType) {
         return _unknownTypeSerializer;
     }
 
+    /**
+     * Helper method called to see if given serializer is considered to be
+     * something returned by {@link #getUnknownTypeSerializer}, that is, something
+     * for which no regular serializer was found or constructed.
+     * 
+     * @since 2.5
+     */
+    public boolean isUnknownTypeSerializer(JsonSerializer<?> ser) {
+        return (ser == _unknownTypeSerializer) || (ser == null);
+    }
+    
     /*
     /**********************************************************
     /* Methods for creating instances based on annotations
@@ -987,19 +998,26 @@ protected void _reportIncompatibleRootType(Object value, JavaType rootType)
      * @return Serializer if one can be found, null if not.
      */
     protected JsonSerializer<Object> _findExplicitUntypedSerializer(Class<?> runtimeType)
-		throws JsonMappingException
+        throws JsonMappingException
     {        
         // Fast lookup from local lookup thingy works?
         JsonSerializer<Object> ser = _knownSerializers.untypedValueSerializer(runtimeType);
-        if (ser != null) {
-            return ser;
-        }
-        // If not, maybe shared map already has it?
-        ser = _serializerCache.untypedValueSerializer(runtimeType);
-        if (ser != null) {
-            return ser;
+        if (ser == null) {
+            // If not, maybe shared map already has it?
+            ser = _serializerCache.untypedValueSerializer(runtimeType);
+            if (ser == null) {
+                ser = _createAndCacheUntypedSerializer(runtimeType);
+                /* 18-Sep-2014, tatu: This is unfortunate patch over related change
+                 *    that pushes creation of "unknown type" serializer deeper down
+                 *    in BeanSerializerFactory; as a result, we need to "undo" creation
+                 *    here.
+                 */
+                if (isUnknownTypeSerializer(ser)) {
+                    return null;
+                }
+            }
         }
-        return _createAndCacheUntypedSerializer(runtimeType);
+        return ser;
     }
 
     /*

src/main/java/com/fasterxml/jackson/databind/introspect/POJOPropertyBuilder.java

@@ -857,6 +857,11 @@ private void _explode(Collection<PropertyName> newNames,
         for (Linked<?> node = accessors; node != null; node = node.next) {
             PropertyName name = node.name;
             if (!node.isNameExplicit || name == null) { // no explicit name -- problem!
+                // [Issue#541] ... but only as long as it's visible
+                if (!node.isVisible) {
+                    continue;
+                }
+                
                 throw new IllegalStateException("Conflicting/ambiguous property name definitions (implicit name '"
                         +_name+"'): found multiple explicit names: "
                         +newNames+", but also implicit accessor: "+node);

src/main/java/com/fasterxml/jackson/databind/ser/BeanSerializerFactory.java

@@ -223,6 +223,12 @@ protected JsonSerializer<?> _createSerializer2(SerializerProvider prov,
                     // Finally: maybe we can still deal with it as an implementation of some basic JDK interface?
                     if (ser == null) {
                         ser = findSerializerByAddonType(config, type, beanDesc, staticTyping);
+                        // 18-Sep-2014, tatu: Actually, as per [jackson-databind#539], need to get
+                        //   'unknown' serializer assigned earlier, here, so that it gets properly
+                        //   post-processed
+                        if (ser == null) {
+                            ser = prov.getUnknownTypeSerializer(beanDesc.getBeanClass());
+                        }
                     }
                 }
             }
@@ -403,14 +409,10 @@ protected JsonSerializer<Object> constructBeanSerializer(SerializerProvider prov
 
         JsonSerializer<Object> ser = (JsonSerializer<Object>) builder.build();
 
-        /* However, after all modifications: no properties, no serializer
-         * (note; as per [JACKSON-670], check was moved later on from an earlier location)
-         */
         if (ser == null) {
-            /* 27-Nov-2009, tatu: Except that as per [JACKSON-201], we are
-             *   ok with that as long as it has a recognized class annotation
-             *  (which may come from a mix-in too)
-             */
+            // If we get this far, there were no properties found, so no regular BeanSerializer
+            // would be constructed. But, couple of exceptions.
+            // First: if there are known annotations, just create 'empty bean' serializer
             if (beanDesc.hasKnownClassAnnotations()) {
                 return builder.createDummy();
             }

src/test/java/com/fasterxml/jackson/databind/introspect/TestPropertyConflicts.java

@@ -1,6 +1,9 @@
 package com.fasterxml.jackson.databind.introspect;
 
+import com.fasterxml.jackson.annotation.*;
+
 import com.fasterxml.jackson.core.JsonProcessingException;
+
 import com.fasterxml.jackson.databind.*;
 
 /**
@@ -62,6 +65,21 @@ public void _stuff(String value) {
         }
     }
 
+    // For [Issue#541]
+    static class Bean541 {
+        protected String str;
+
+        @JsonCreator
+        public Bean541(@JsonProperty("str") String str) {
+            this.str = str;
+        }
+
+        @JsonProperty("s")
+        public String getStr() {
+            return str;
+        }
+     }
+     
     /*
     /**********************************************************
     /* Test methods
@@ -110,4 +128,23 @@ public void testInferredNameConflictsWithSetters() throws Exception
         Infernal inf = mapper.readValue(aposToQuotes("{'stuff':'Bob'}"), Infernal.class);
         assertNotNull(inf);
     }
+
+    public void testIssue541() throws Exception {
+        final ObjectMapper mapper = new ObjectMapper();
+        mapper.disable(
+                MapperFeature.AUTO_DETECT_CREATORS,
+                MapperFeature.AUTO_DETECT_FIELDS,
+                MapperFeature.AUTO_DETECT_GETTERS,
+                MapperFeature.AUTO_DETECT_IS_GETTERS,
+                MapperFeature.AUTO_DETECT_SETTERS,
+                MapperFeature.USE_GETTERS_AS_SETTERS
+        );
+        Bean541 data = mapper.readValue("{\"str\":\"the string\"}", Bean541.class);
+        if (data == null) {
+            throw new IllegalStateException("data is null");
+        }
+        if (!"the string".equals(data.getStr())) {
+            throw new IllegalStateException("bad value for data.str");
+        }
+    }
 }

src/test/java/com/fasterxml/jackson/databind/jsontype/TestDefaultForObject.java

@@ -32,14 +32,14 @@ enum Choice { YES, NO; }
      * Another enum type, but this time forcing sub-classing
      */
     enum ComplexChoice {
-    	MAYBE(true), PROBABLY_NOT(false);
+        MAYBE(true), PROBABLY_NOT(false);
 
-    	private boolean state;
+        private boolean state;
 
-    	private ComplexChoice(boolean b) { state = b; }
+        private ComplexChoice(boolean b) { state = b; }
 
         @Override
-    	public String toString() { return String.valueOf(state); }
+        public String toString() { return String.valueOf(state); }
     }
 
     // [JACKSON-311]
@@ -113,6 +113,24 @@ public void testBeanAsObject() throws Exception
         assertEquals("abc", ((StringBean) result[0]).name);
     }
 
+    // with 2.5, another test to check that "as-property" is valid option
+    public void testBeanAsObjectUsingAsProperty() throws Exception
+    {
+        ObjectMapper m = new ObjectMapper();
+        m.enableDefaultTypingAsProperty(ObjectMapper.DefaultTyping.NON_FINAL,
+                ".hype");
+        // note: need to wrap, to get declared as Object
+        String json = m.writeValueAsString(new StringBean("abc"));
+
+        System.err.println("JSON == "+json);
+        
+        // Ok: serialization seems to work as expected. Now deserialize:
+        Object result = m.readValue(json, Object.class);
+        assertNotNull(result);
+        assertEquals(StringBean.class, result.getClass());
+        assertEquals("abc", ((StringBean) result).name);
+    }
+    
     /**
      * Unit test that verifies that an abstract bean is stored with type information
      * if default type information is enabled for non-concrete types.
@@ -331,6 +349,18 @@ public void testFeature432() throws Exception
         String json = mapper.writeValueAsString(new BeanHolder(new StringBean("punny")));
         assertEquals("{\"bean\":{\"*CLASS*\":\"com.fasterxml.jackson.databind.jsontype.TestDefaultForObject$StringBean\",\"name\":\"punny\"}}", json);
     }
+
+    public void testNoGoWithExternalProperty() throws Exception
+    {
+        ObjectMapper mapper = new ObjectMapper();
+        try {
+            mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.JAVA_LANG_OBJECT,
+                    JsonTypeInfo.As.EXTERNAL_PROPERTY);
+            fail("Should not have passed");
+        } catch (IllegalArgumentException e) {
+            verifyException(e, "Can not use includeAs of EXTERNAL_PROPERTY");
+        }
+    }
 
     /*
     /**********************************************************

src/test/java/com/fasterxml/jackson/databind/ser/TestBeanSerializer.java

@@ -5,7 +5,6 @@
 
 import com.fasterxml.jackson.annotation.*;
 import com.fasterxml.jackson.core.*;
-
 import com.fasterxml.jackson.databind.*;
 import com.fasterxml.jackson.databind.introspect.AnnotatedField;
 import com.fasterxml.jackson.databind.introspect.POJOPropertyBuilder;
@@ -26,17 +25,11 @@
 @SuppressWarnings("serial")
 public class TestBeanSerializer extends BaseMapTest
 {
-    /*
-    /********************************************************
-    /* Helper types
-    /********************************************************
-     */
-
-    static class ModuleImpl extends SimpleModule
+    static class SerializerModifierModule extends SimpleModule
     {
         protected BeanSerializerModifier modifier;
 
-        public ModuleImpl(BeanSerializerModifier modifier)
+        public SerializerModifierModule(BeanSerializerModifier modifier)
         {
             super("test", Version.unknownVersion());
             this.modifier = modifier;
@@ -178,6 +171,24 @@ public List<BeanPropertyWriter> changeProperties(SerializationConfig config,
         }
     }
 
+    // [Issue#539]: use post-modifier
+    static class EmptyBeanModifier539 extends BeanSerializerModifier
+    {
+        @Override
+        public List<BeanPropertyWriter> changeProperties(SerializationConfig config,
+                BeanDescription beanDesc, List<BeanPropertyWriter> beanProperties)
+        {
+            System.err.println("DEBUG: changeProperties!");
+            return beanProperties;
+        }
+        
+        @Override
+        public JsonSerializer<?> modifySerializer(SerializationConfig config,
+                BeanDescription beanDesc, JsonSerializer<?> serializer) {
+System.err.println("DEBUG: modifySer!");            
+            return new BogusBeanSerializer(42);
+        }
+    }
     // [Issue#120], arrays, collections, maps
 
     static class ArraySerializerModifier extends BeanSerializerModifier {
@@ -251,30 +262,30 @@ enum EnumABC { A, B, C };
     public void testPropertyRemoval() throws Exception
     {
         ObjectMapper mapper = new ObjectMapper();
-        mapper.registerModule(new ModuleImpl(new RemovingModifier("a")));
+        mapper.registerModule(new SerializerModifierModule(new RemovingModifier("a")));
         Bean bean = new Bean();
         assertEquals("{\"b\":\"b\"}", mapper.writeValueAsString(bean));
     }
 
     public void testPropertyReorder() throws Exception
     {
         ObjectMapper mapper = new ObjectMapper();
-        mapper.registerModule(new ModuleImpl(new ReorderingModifier()));
+        mapper.registerModule(new SerializerModifierModule(new ReorderingModifier()));
         Bean bean = new Bean();
         assertEquals("{\"a\":\"a\",\"b\":\"b\"}", mapper.writeValueAsString(bean));
     }
 
     public void testBuilderReplacement() throws Exception
     {
         ObjectMapper mapper = new ObjectMapper();
-        mapper.registerModule(new ModuleImpl(new BuilderModifier(new BogusBeanSerializer(17))));
+        mapper.registerModule(new SerializerModifierModule(new BuilderModifier(new BogusBeanSerializer(17))));
         Bean bean = new Bean();
         assertEquals("17", mapper.writeValueAsString(bean));
     }    
     public void testSerializerReplacement() throws Exception
     {
         ObjectMapper mapper = new ObjectMapper();
-        mapper.registerModule(new ModuleImpl(new ReplacingModifier(new BogusBeanSerializer(123))));
+        mapper.registerModule(new SerializerModifierModule(new ReplacingModifier(new BogusBeanSerializer(123))));
         Bean bean = new Bean();
         assertEquals("123", mapper.writeValueAsString(bean));
     }
@@ -295,6 +306,22 @@ public void setupModule(SetupContext context)
         assertEquals("{\"bogus\":\"foo\"}", json);
     }
 
+    // [Issue#539]
+    public void testEmptyBean539() throws Exception
+    {
+        ObjectMapper mapper = new ObjectMapper();
+        mapper.registerModule(new SimpleModule("test", Version.unknownVersion()) {
+            @Override
+            public void setupModule(SetupContext context)
+            {
+                super.setupModule(context);
+                context.addBeanSerializerModifier(new EmptyBeanModifier539());
+            }
+        });
+        String json = mapper.writeValueAsString(new EmptyBean());
+        assertEquals("42", json);
+    }
+    
     // [Issue#121]
 
     public void testModifyArraySerializer() throws Exception