Apply changes after first review

Author: JooHyukKim

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

@@ -382,6 +382,21 @@ public JsonIncludeProperties.Value findPropertyInclusionByName(MapperConfig<?> c
      */
     public Object findNamingStrategy(AnnotatedClass ac) { return null; }
 
+    /**
+     * Method for finding {@link EnumNamingStrategy} implenetation class for given
+     * class, if any specified by annotations; and if so, either return
+     * a {@link EnumNamingStrategy} instance, or Class to use for
+     * creating instance
+     *
+     * @param ac Annotated class to introspect
+     *
+     * @return Subclass of {@link EnumNamingStrategy}, if one
+     *   is specified for given class; null if not.
+     *
+     * @since 2.15
+     */
+    public Object findEnumNamingStrategy(AnnotatedClass ac) { return null; }
+
     /**
      * Method used to check whether specified class defines a human-readable
      * description to use for documentation.

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

@@ -1,63 +1,129 @@
 package com.fasterxml.jackson.databind;
 
+/**
+ * A container class for implementations of the {@link EnumNamingStrategy} interface.
+ *
+ * @since 2.15
+ */
 public class EnumNamingStrategies {
 
-    public static final EnumNamingStrategy CAMEL_CASE = CamelCaseStrategy.INSTANCE;
-
-    /**
-     * no-op naming. Does nothing
-     */
-    public static class NoOpEnumNamingStrategy implements EnumNamingStrategy {
-
-        @Override
-        public String translate(String value) {
-            return value;
-        }
-
-    }
+    private EnumNamingStrategies() {}
 
     /**
      * <p>
-     * Used when external value is in conventional CamelCase. Examples are "numberValue", "namingStrategy", "theDefiniteProof".
-     * First underscore prefix will always be removed.
+     * An implementation of {@link EnumNamingStrategy} that converts enum names in the typical upper
+     * snake case format to camel case format. This implementation follows three rules
+     * described below.
+     *
+     * <ol>
+     * <li>converts any character preceded by an underscore into upper case character,
+     * regardless of its original case (upper or lower).</li>
+     * <li>converts any character NOT preceded by an underscore into a lower case character,
+     * regardless of its original case (upper or lower).</li>
+     * <li>converts contiguous sequence of underscores into a single underscore.</li>
+     * </ol>
+     *
+     * WARNING: Naming conversion conflicts caused by underscore usage should be handled by client.
+     * e.g. Both <code>PEANUT_BUTTER</code>, <code>PEANUT__BUTTER</code> are converted into "peanutButter".
+     * And "peanutButter" will be deserialized into enum with smaller <code>Enum.ordinal()</code> value.
+     *
+     * <p>
+     * These rules result in the following example conversions from upper snakecase names
+     * to camelcase names.
+     * <ul>
+     * <li>"USER_NAME" is converted into "userName"</li>
+     * <li>"USER______NAME" is converted into "userName"</li>
+     * <li>"USERNAME" is converted into "username"</li>
+     * <li>"User__Name" is converted into "userName"</li>
+     * <li>"_user_name" is converted into "UserName"</li>
+     * <li>"_user_name_s" is converted into "UserNameS"</li>
+     * <li>"__Username" is converted into "Username"</li>
+     * <li>"__username" is converted into "Username"</li>
+     * <li>"username" is converted into "username"</li>
+     * <li>"Username" is converted into "username"</li>
+     * </ul>
+     *
+     * @since 2.15
      */
     public static class CamelCaseStrategy implements EnumNamingStrategy {
 
         /**
+         * An intance of {@link CamelCaseStrategy} for reuse.
+         *
          * @since 2.15
          */
-        public final static CamelCaseStrategy INSTANCE
-            = new CamelCaseStrategy();
+        public static final CamelCaseStrategy INSTANCE = new CamelCaseStrategy();
 
+        /**
+         * @since 2.15
+         */
         @Override
-        public String translate(String input) {
-            if (input == null) {
-                return input;
+        public String convertEnumToExternalName(String enumName) {
+            if (enumName == null) {
+                return null;
             }
 
-            int length = input.length();
-            StringBuilder result = new StringBuilder(length * 2);
-            int resultLength = 0;
-            boolean wasPrevTranslated = false;
-            for (int i = 0; i < length; i++) {
-                char c = input.charAt(i);
-                if (i > 0 || c != '_') {
-                    if (Character.isUpperCase(c)) {
-                        if (!wasPrevTranslated && resultLength > 0 && result.charAt(resultLength - 1) != '_') {
-                            result.append('_');
-                            resultLength++;
-                        }
-                        c = Character.toLowerCase(c);
-                        wasPrevTranslated = true;
+            final String UNDERSCORE = "_";
+            StringBuilder out = null;
+            int iterationCnt = 0;
+            int lastSeparatorIdx = -1;
+
+            do {
+                lastSeparatorIdx = indexIn(enumName, lastSeparatorIdx + 1);
+                if (lastSeparatorIdx != -1) {
+                    if (iterationCnt == 0) {
+                        out = new StringBuilder(enumName.length() + 4 * UNDERSCORE.length());
+                        out.append(toLowerCase(enumName.substring(iterationCnt, lastSeparatorIdx)));
                     } else {
-                        wasPrevTranslated = false;
+                        out.append(normalizeWord(enumName.substring(iterationCnt, lastSeparatorIdx)));
                     }
-                    result.append(c);
-                    resultLength++;
+                    iterationCnt = lastSeparatorIdx + UNDERSCORE.length();
+                }
+            } while (lastSeparatorIdx != -1);
+
+            if (iterationCnt == 0) {
+                return toLowerCase(enumName);
+            }
+            out.append(normalizeWord(enumName.substring(iterationCnt)));
+            return out.toString();
+        }
+
+        private static int indexIn(CharSequence sequence, int start) {
+            int length = sequence.length();
+            for (int i = start; i < length; i++) {
+                if ('_' == sequence.charAt(i)) {
+                    return i;
                 }
             }
-            String output = resultLength > 0 ? result.toString() : input;
-            return output.toUpperCase();
+            return -1;
+        }
+
+        private static String normalizeWord(String word) {
+            int length = word.length();
+            if (length == 0) {
+                return word;
+            }
+            return new StringBuilder(length)
+                .append(charToUpperCaseIfLower(word.charAt(0)))
+                .append(toLowerCase(word.substring(1)))
+                .toString();
+        }
+
+        private static String toLowerCase(String string) {
+            int length = string.length();
+            StringBuilder builder = new StringBuilder(length);
+            for (int i = 0; i < length; i++) {
+                builder.append(charToLowerCaseIfUpper(string.charAt(i)));
+            }
+            return builder.toString();
+        }
+
+        private static char charToUpperCaseIfLower(char c) {
+            return Character.isLowerCase(c) ? Character.toUpperCase(c) : c;
+        }
+
+        private static char charToLowerCaseIfUpper(char c) {
+            return Character.isUpperCase(c) ? Character.toLowerCase(c) : c;
         }
     }
 }

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

@@ -1,7 +1,23 @@
 package com.fasterxml.jackson.databind;
 
+/**
+ * Defines how the string representation of an enum is converted into an external property name for mapping
+ * during deserialization.
+ *
+ * @since 2.15
+ */
 public interface EnumNamingStrategy {
 
-    public String translate(String value);
+    /**
+     * Translates the given <code>enumName</code> into an external property name according to
+     * the implementation of this {@link EnumNamingStrategy}.
+     *
+     * @param enumName the name of the enum value to translate
+     * @return the external property name that corresponds to the given <code>enumName</code>
+     * according to the implementation of this {@link EnumNamingStrategy}.
+     *
+     * @since 2.15
+     */
+    public String convertEnumToExternalName(String enumName);
 
 }

src/main/java/com/fasterxml/jackson/databind/annotation/EnumNaming.java

@@ -7,9 +7,24 @@
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+/**
+ * Annotation that can be used to indicate a {@link EnumNamingStrategy}
+ * to use for annotated class.
+ *
+ * @since 2.15
+ */
 @Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE})
 @Retention(RetentionPolicy.RUNTIME)
 @com.fasterxml.jackson.annotation.JacksonAnnotation
 public @interface EnumNaming {
-    public Class<? extends EnumNamingStrategy> value() default EnumNamingStrategy.class;
+
+    /**
+     * @return Type of {@link EnumNamingStrategy} to use, if any. Default value
+     * of <code>EnumNamingStrategy.class</code> means "no strategy specified"
+     * (and may also be used for overriding to remove otherwise applicable
+     * naming strategy)
+     *
+     * @since 2.15
+     */
+    public Class<? extends EnumNamingStrategy> value();
 }

src/main/java/com/fasterxml/jackson/databind/deser/std/EnumDeserializer.java

@@ -9,7 +9,6 @@
 import com.fasterxml.jackson.core.*;
 
 import com.fasterxml.jackson.databind.*;
-import com.fasterxml.jackson.databind.annotation.EnumNaming;
 import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
 import com.fasterxml.jackson.databind.cfg.CoercionAction;
 import com.fasterxml.jackson.databind.cfg.CoercionInputShape;

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

@@ -0,0 +1,104 @@
+package com.fasterxml.jackson.databind.introspect;
+
+import com.fasterxml.jackson.databind.AnnotationIntrospector;
+import com.fasterxml.jackson.databind.EnumNamingStrategy;
+import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.annotation.EnumNaming;
+import com.fasterxml.jackson.databind.cfg.MapperConfig;
+import com.fasterxml.jackson.databind.util.ClassUtil;
+
+/**
+ * Helper class used for aggregating information about all possible
+ * properties of a Enum.
+ *
+ * @since 2.15
+ */
+public class EnumPropertiesCollector {
+    private EnumPropertiesCollector() {}
+
+    /*
+    /**********************************************************
+    /* Public API: main-level collection
+    /**********************************************************
+     */
+
+    /**
+     * Helper method to resolve the an {@link EnumNamingStrategy} for the current {@link MapperConfig}
+     * using {@link AnnotationIntrospector}.
+     *
+     * @return An instance of a subtype of {@link EnumNamingStrategy} specified through
+     * {@link EnumNaming#value()} or null if current Enum class is not annotated with {@link EnumNaming} or
+     * {@link EnumNaming#value()} is set to {@link EnumNamingStrategy} interface itself.
+     * @since 2.15
+     */
+    public static EnumNamingStrategy findEnumNamingStrategy(MapperConfig<?> config, Class<?> handledType) {
+        AnnotatedClass classDef = _findAnnotatedClass(config, handledType);
+        Object namingDef = config.getAnnotationIntrospector().findEnumNamingStrategy(classDef);
+        return _findEnumNamingStrategy(namingDef, config.canOverrideAccessModifiers());
+
+    }
+
+    /*
+    /**********************************************************
+    * Actual Implementation
+    **********************************************************
+    */
+
+    /**
+     * @since 2.15
+     */
+    private static EnumNamingStrategy _findEnumNamingStrategy(Object namingDef, boolean canOverrideAccessModifiers) {
+        if (namingDef == null) {
+            return null;
+        }
+
+        if (namingDef instanceof EnumNamingStrategy) {
+            return (EnumNamingStrategy) namingDef;
+        }
+        // Alas, there's no way to force return type of "either class
+        // X or Y" -- need to throw an exception after the fact
+        if (!(namingDef instanceof Class)) {
+            reportProblem("AnnotationIntrospector returned EnumNamingStrategy definition of type %s"
+                + "; expected type `Class<EnumNamingStrategy>` instead", ClassUtil.classNameOf(namingDef));
+        }
+
+        Class<?> namingClass = (Class<?>) namingDef;
+        // 09-Nov-2015, tatu: Need to consider pseudo-value of STD, which means "use default"
+        if (namingClass == EnumNamingStrategy.class) {
+            return null;
+        }
+
+        if (!EnumNamingStrategy.class.isAssignableFrom(namingClass)) {
+            reportProblem("AnnotationIntrospector returned Class %s; expected `Class<EnumNamingStrategy>`",
+                ClassUtil.classNameOf(namingClass));
+        }
+
+        return (EnumNamingStrategy) ClassUtil.createInstance(namingClass, canOverrideAccessModifiers);
+    }
+
+    /*
+     *********************************************************
+     * Internal methods; helpers
+     **********************************************************
+     */
+
+    /**
+     * @since 2.15
+     */
+    protected static AnnotatedClass _findAnnotatedClass(MapperConfig<?> ctxt, Class<?> handledType) {
+        JavaType javaType = ctxt.constructType(handledType);
+        return AnnotatedClassResolver.resolve(ctxt, javaType, ctxt);
+    }
+
+    /**
+     * @since 2.15
+     */
+    protected static void reportProblem(String msg, Object... args) {
+        if (args.length > 0) {
+            msg = String.format(msg, args);
+        }
+        throw new IllegalArgumentException("Problem with " + msg);
+    }
+
+
+}

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

@@ -349,6 +349,12 @@ public Object findNamingStrategy(AnnotatedClass ac)
         return (ann == null) ? null : ann.value();
     }
 
+    @Override
+    public Object findEnumNamingStrategy(AnnotatedClass ac) {
+        EnumNaming ann = _findAnnotation(ac, EnumNaming.class);
+        return (ann == null) ? null : ann.value();
+    }
+
     @Override
     public String findClassDescription(AnnotatedClass ac) {
         JsonClassDescription ann = _findAnnotation(ac, JsonClassDescription.class);