Refactor #2879 slightly, feature now MapperFeature.SORT_CREATOR_PROPERTIES_FIRST

Author: cowtowncoder

release-notes/CREDITS-2.x

@@ -1239,3 +1239,8 @@ Siavash Soleymani (siavashsoleymani@github)
 Ilya Golovin (ilgo0413@github)
   * Contributed #2873: `MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS` should work for enum as keys
   (2.12.0)
+
+Sergiy Yevtushenko (siy@github)
+  * Contributed #2879: Add support for disabling special handling of "Creator properties" wrt
+    alphabetic property ordering
+  (2.12.0)

release-notes/VERSION-2.x

@@ -21,6 +21,9 @@ Project: jackson-databind
 #2855: Add `JsonNode.canConvertToExactIntegral()` to indicate whether floating-point/BigDecimal
   values could be converted to integers losslessly
  (requested by Oguzhan U; implementation contributed by Siavash S)
+#2879: Add support for disabling special handling of "Creator properties" wrt
+  alphabetic property ordering
+ (contributed by Sergiy Y)
 
 2.12.0-rc1 (12-Oct-2020)
 

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

@@ -360,9 +360,8 @@ public enum MapperFeature implements ConfigFeature
 
     /**
      * Feature that defines default property serialization order used
-     * for POJO fields (note: does <b>not</b> apply to {@link java.util.Map}
-     * serialization!):
-     * if enabled, default ordering is alphabetic (similar to
+     * for POJO properties.
+     * If enabled, default ordering is alphabetic (similar to
      * how {@link com.fasterxml.jackson.annotation.JsonPropertyOrder#alphabetic()}
      * works); if disabled, order is unspecified (based on what JDK gives
      * us, which may be declaration order, but is not guaranteed).
@@ -371,23 +370,29 @@ public enum MapperFeature implements ConfigFeature
      * explicit overrides in classes (for example with
      * {@link com.fasterxml.jackson.annotation.JsonPropertyOrder} annotation)
      *<p>
+     * Note: does <b>not</b> apply to {@link java.util.Map} serialization (since
+     * entries are not considered Bean/POJO properties.
+     *<p>
      * Feature is disabled by default.
      */
     SORT_PROPERTIES_ALPHABETICALLY(false),
 
     /**
-     * Feature that enforces strict ordering as requested by other configuration methods
-     * for POJO fields (note: does <b>not</b> apply to {@link java.util.Map}
-     * serialization!):
-     * if enabled, ordering is preserved even if {@link com.fasterxml.jackson.annotation.JsonCreator}
-     * is present. Without this feature properties referenced by {@link com.fasterxml.jackson.annotation.JsonCreator}
-     * taking precedence over other properties even if sorting is requested.
+     * Feature that defines whether Creator properties (ones passed through
+     * constructor or static factory method) should be sorted before other properties
+     * for which no explicit order is specified, in case where alphabetic
+     * ordering is to be used for such properties.
+     * Note that in either case explicit order (whether by name or by index)
+     * will have precedence over this setting.
      *<p>
-     * Note that if ordering is not enabled using other ways, this feature has no effect.
+     * Note: does <b>not</b> apply to {@link java.util.Map} serialization (since
+     * entries are not considered Bean/POJO properties.
      *<p>
-     * Feature is disabled by default.
+     * Feature is enabled by default.
+     *
+     * @since 2.12
      */
-    STRICT_PROPERTIES_ORDERING(false),
+    SORT_CREATOR_PROPERTIES_FIRST(true),
 
     /*
     /******************************************************

src/main/java/com/fasterxml/jackson/databind/cfg/MapperConfig.java

@@ -188,14 +188,6 @@ public final boolean shouldSortPropertiesAlphabetically() {
         return isEnabled(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY);
     }
 
-    /**
-     * Accessor for checking whether default settings for forcing property
-     * ordering is enabled.
-     */
-    public final boolean shouldPreservePropertiesOrdering() {
-        return isEnabled(MapperFeature.STRICT_PROPERTIES_ORDERING);
-    }
-
     /**
      * Accessor for checking whether configuration indicates that
      * "root wrapping" (use of an extra property/name pair at root level)

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

@@ -1052,21 +1052,21 @@ protected void _sortProperties(Map<String, POJOPropertyBuilder> props)
         // Then how about explicit ordering?
         final AnnotationIntrospector intr = _annotationIntrospector;
         Boolean alpha = intr.findSerializationSortAlphabetically(_classDef);
-        final boolean sort = (alpha == null)
+        final boolean sortAlpha = (alpha == null)
                 ? _config.shouldSortPropertiesAlphabetically()
                 : alpha.booleanValue();
         final boolean indexed = _anyIndexed(props.values());
 
         String[] propertyOrder = intr.findSerializationPropertyOrder(_classDef);
 
         // no sorting? no need to shuffle, then
-        if (!sort && !indexed && (_creatorProperties == null) && (propertyOrder == null)) {
+        if (!sortAlpha && !indexed && (_creatorProperties == null) && (propertyOrder == null)) {
             return;
         }
         int size = props.size();
         Map<String, POJOPropertyBuilder> all;
         // Need to (re)sort alphabetically?
-        if (sort) {
+        if (sortAlpha) {
             all = new TreeMap<String,POJOPropertyBuilder>();
         } else {
             all = new LinkedHashMap<String,POJOPropertyBuilder>(size+size);
@@ -1116,14 +1116,15 @@ protected void _sortProperties(Map<String, POJOPropertyBuilder> props)
 
         // Third by sorting Creator properties before other unordered properties
         // (unless strict ordering is requested)
-        if (_creatorProperties != null && !_config.shouldPreservePropertiesOrdering()) {
+        if ((_creatorProperties != null)
+                && (!sortAlpha || _config.isEnabled(MapperFeature.SORT_CREATOR_PROPERTIES_FIRST))) {
             /* As per [databind#311], this is bit delicate; but if alphabetic ordering
              * is mandated, at least ensure creator properties are in alphabetic
              * order. Related question of creator vs non-creator is punted for now,
              * so creator properties still fully predate non-creator ones.
              */
             Collection<POJOPropertyBuilder> cr;
-            if (sort) {
+            if (sortAlpha) {
                 TreeMap<String, POJOPropertyBuilder> sorted =
                         new TreeMap<String,POJOPropertyBuilder>();
                 for (POJOPropertyBuilder prop : _creatorProperties) {

src/test/java/com/fasterxml/jackson/databind/ObjectMapperTest.java

@@ -278,24 +278,21 @@ public void testConfigForForcedPropertySorting() throws Exception
         ObjectMapper m = new ObjectMapper();
 
         // sort-alphabetically is disabled by default:
-        assertFalse(m.isEnabled(MapperFeature.STRICT_PROPERTIES_ORDERING));
+        assertTrue(m.isEnabled(MapperFeature.SORT_CREATOR_PROPERTIES_FIRST));
         SerializationConfig sc = m.getSerializationConfig();
-        assertFalse(sc.isEnabled(MapperFeature.STRICT_PROPERTIES_ORDERING));
-        assertFalse(sc.shouldPreservePropertiesOrdering());
+        assertTrue(sc.isEnabled(MapperFeature.SORT_CREATOR_PROPERTIES_FIRST));
         DeserializationConfig dc = m.getDeserializationConfig();
-        assertFalse(dc.shouldPreservePropertiesOrdering());
+        assertTrue(dc.isEnabled(MapperFeature.SORT_CREATOR_PROPERTIES_FIRST));
 
         // but when enabled, should be visible:
         m = jsonMapperBuilder()
-                .enable(MapperFeature.STRICT_PROPERTIES_ORDERING)
+                .disable(MapperFeature.SORT_CREATOR_PROPERTIES_FIRST)
                 .build();
         sc = m.getSerializationConfig();
-        assertTrue(sc.isEnabled(MapperFeature.STRICT_PROPERTIES_ORDERING));
-        assertTrue(sc.shouldPreservePropertiesOrdering());
+        assertFalse(sc.isEnabled(MapperFeature.SORT_CREATOR_PROPERTIES_FIRST));
         dc = m.getDeserializationConfig();
         // and not just via SerializationConfig, but also via DeserializationConfig
-        assertTrue(dc.isEnabled(MapperFeature.STRICT_PROPERTIES_ORDERING));
-        assertTrue(dc.shouldPreservePropertiesOrdering());
+        assertFalse(dc.isEnabled(MapperFeature.SORT_CREATOR_PROPERTIES_FIRST));
     }
 
     public void testJsonFactoryLinkage()

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

@@ -82,20 +82,19 @@ public BeanForGH311(@JsonProperty("b") int b, @JsonProperty("a") int a) { //b an
         public int getB() { return b; }
     }
 
-    static class BeanForStrictOrdering {
-        private final int a;
-        private int b;
-        private final int c;
+    // We'll expect ordering of "FUBAR"
+    @JsonPropertyOrder({ "f"  })
+    static class OrderingByIndexBean {
+        public int r;
+        public int a;
 
-        @JsonCreator
-        public BeanForStrictOrdering(@JsonProperty("c") int c, @JsonProperty("a") int a) { //b and a are out of order, although alphabetic = true
-            this.a = a;
-            this.c = c;
-        }
+        @JsonProperty(index = 1)
+        public int b;
 
-        public int getA() { return a; }
-        public int getB() { return b; }
-        public int getC() { return c; }
+        @JsonProperty(index = 0)
+        public int u;
+
+        public int f;
     }
 
     // For [databind#2879]
@@ -115,19 +114,21 @@ public BeanFor2879(@JsonProperty("a") int a,
         }
     }
 
-    // We'll expect ordering of "FUBAR"
-    @JsonPropertyOrder({ "f"  })
-    static class OrderingByIndexBean {
-        public int r;
-        public int a;
-
-        @JsonProperty(index = 1)
-        public int b;
+    // For [databind#2879]
+    static class BeanForStrictOrdering {
+        private final int a;
+        private int b;
+        private final int c;
 
-        @JsonProperty(index = 0)
-        public int u;
+        @JsonCreator
+        public BeanForStrictOrdering(@JsonProperty("c") int c, @JsonProperty("a") int a) { //b and a are out of order, although alphabetic = true
+            this.a = a;
+            this.c = c;
+        }
 
-        public int f;
+        public int getA() { return a; }
+        public int getB() { return b; }
+        public int getC() { return c; }
     }
 
     /*
@@ -142,11 +143,6 @@ static class OrderingByIndexBean {
             .configure(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY, true)
             .build();
 
-    private final ObjectMapper STRICT_ALPHA_MAPPER = jsonMapperBuilder()
-            .enable(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY)
-            .enable(MapperFeature.STRICT_PROPERTIES_ORDERING)
-            .build();
-
     public void testImplicitOrderByCreator() throws Exception {
         assertEquals("{\"c\":1,\"a\":2,\"b\":0}",
                 MAPPER.writeValueAsString(new BeanWithCreator(1, 2)));
@@ -209,9 +205,24 @@ public void testOrderByIndexEtc() throws Exception
                 ALPHA_MAPPER.writeValueAsString(new OrderingByIndexBean()));
     }
 
+    // [databind#2879]: allow preventing Creator properties from overriding
+    //    alphabetic ordering
     public void testStrictAlphaAndCreatorOrdering() throws Exception
     {
-        String json = STRICT_ALPHA_MAPPER.writeValueAsString(new BeanForStrictOrdering(1, 2));
-        assertEquals("{\"a\":2,\"b\":0,\"c\":1}", json);
+        // without changing defaults, creators are sorted before other properties
+        // BUT are sorted within their own category
+        assertTrue(ALPHA_MAPPER.isEnabled(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY));
+        assertTrue(ALPHA_MAPPER.isEnabled(MapperFeature.SORT_CREATOR_PROPERTIES_FIRST));
+        assertEquals(a2q("{'a':3,'c':2,'b':0}"),
+                ALPHA_MAPPER.writeValueAsString(new BeanForStrictOrdering(2, 3)));
+
+        // but can change that
+        final ObjectMapper STRICT_ALPHA_MAPPER = jsonMapperBuilder()
+                .enable(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY)
+                .disable(MapperFeature.SORT_CREATOR_PROPERTIES_FIRST)
+                .build();
+
+        assertEquals(a2q("{'a':2,'b':0,'c':1}"),
+                STRICT_ALPHA_MAPPER.writeValueAsString(new BeanForStrictOrdering(1, 2)));
     }
 }