Merge branch 'release/1.3'

Author: jtnelson

.version

@@ -1 +1 @@
-1.3.0
+1.3.1

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+#### Version 1.3.1 (TBD)
+* Fixed some bugs related to serializing and deserializing some built-in `Transformers`.
+* Added missing transformers to ensure values are handled as Strings.
+
 #### Version 1.3.0 (November 23, 2018)
 * Added the `ScriptedTransformer` framework. `ScriptedTransformer` is abstract class that can be extended to provide transformation logic via a script that is compatible with the Java script engine platform. Right now, javascript is the supported language for writing transformer scripts.
 * Added support for Transformer serialization. The rules of serialization are:

build.gradle

@@ -50,7 +50,7 @@ artifacts {
 }
 
 // Set the version for all Concourse dependencies
-ext.concourseVersion = '0.9.3'
+ext.concourseVersion = '0.9.4'
 
 repositories {
     mavenCentral()
@@ -69,7 +69,7 @@ repositories {
 }
 
 dependencies {
-    compile group: 'com.cinchapi', name: 'accent4j', version: '1.4.0', changing:true
+    compile group: 'com.cinchapi', name: 'accent4j', version: '1.5.1', changing:true
     compile group: 'com.cinchapi', name: 'concourse-driver-java', version: concourseVersion, changing:true // needed for util classes...
     compile group: 'com.google.code.findbugs', name: 'jsr305', version:'2.0.1'
     compile group: 'com.google.guava', name:'guava', version:'25.1-jre'

src/main/java/com/cinchapi/etl/TransformerSerializationFactory.java

@@ -30,16 +30,20 @@
 import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
 
+import javax.annotation.Nullable;
+
 import com.cinchapi.common.base.CheckedExceptions;
 import com.cinchapi.common.base.Verify;
 import com.cinchapi.common.io.ByteBuffers;
 import com.cinchapi.common.reflect.Reflection;
 import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
 import com.google.common.primitives.Ints;
 
 /**
@@ -63,6 +67,19 @@ public static TransformerSerializationFactory instance() {
         return INSTANCE;
     }
 
+    /**
+     * Return a list of potential factory methods that could produced a
+     * {@link Transformer} from the provided {@code params}.
+     * 
+     * @param params
+     * @return the potential factory methods
+     */
+    private static List<Method> getPotentialFactoryMethods(Object... params) {
+        return Arrays.stream(Transformers.class.getDeclaredMethods())
+                .filter(method -> Reflection.isCallableWith(method, params))
+                .collect(Collectors.toList());
+    }
+
     /**
      * Serialize the {@code object} into a {@link ByteBuffer}.
      * 
@@ -114,8 +131,27 @@ private static <T> T getSerializedObject(ByteBuffer bytes) {
      * intentionally kept local to this instance of the factory.
      * </p>
      */
-    private final Map<String, Class<? extends Transformer>> lambdas = Maps
-            .newHashMap();
+    private final Map<String, Class<? extends Transformer>> lambdas = new HashMap<String, Class<? extends Transformer>>() {
+
+        private static final long serialVersionUID = -407507799832599951L;
+
+        @Override
+        public Class<? extends Transformer> put(String key,
+                Class<? extends Transformer> value) {
+            if(Arrays.stream(Transformers.class.getDeclaredMethods())
+                    .filter(method -> method.getName().equals(key))
+                    .count() == 1) {
+                // Don't cache overloaded methods because the associations
+                // between the called method name and the lambda class would get
+                // mixed up with the method that actually produces the lambda
+                return super.put(key, value);
+            }
+            else {
+                return null;
+            }
+        }
+
+    };
 
     private TransformerSerializationFactory() {}
 
@@ -199,26 +235,41 @@ public ByteBuffer serialize(Transformer transformer) {
                 }
                 // Go through each of the Transformers factories and try to
                 // guess which method produced the #transformer
-                List<Method> candidates = Arrays
-                        .stream(Transformers.class.getDeclaredMethods())
-                        .filter(method -> Reflection.isCallableWith(method,
-                                params))
-                        .collect(Collectors.toList());
-                Method method = null;
-                for (Method candidate : candidates) {
-                    candidate.setAccessible(true);
-                    Class<? extends Transformer> clazz = lambdas
-                            .get(candidate.getName());
-                    if(clazz == null) {
-                        Transformer t = (Transformer) candidate.invoke(null,
-                                params);
-                        clazz = t.getClass();
-                        lambdas.put(candidate.getName(), clazz);
-                    }
-                    if(clazz.equals(transformer.getClass())) {
-                        method = candidate;
-                        break;
+                List<Method> candidates = getPotentialFactoryMethods(params);
+                Method method = getFactoryMethod(transformer, candidates,
+                        params);
+                if(method == null) {
+                    // Handle corner case of the factories take arrays as
+                    // parameters and convert them to collections
+                    boolean retry = false;
+                    for (int i = 0; i < params.length; ++i) {
+                        Object param = params[i];
+                        if(param instanceof Collection) {
+                            Class<?> type = null;
+                            Collection<?> cparam = (Collection<?>) param;
+                            for (Object item : cparam) {
+                                // Get the actual type of the collection to
+                                // create the array correctly
+                                type = type == null || item.getClass() == type
+                                        ? item.getClass()
+                                        : Reflection.getClosestCommonAncestor(
+                                                type, item.getClass());
+                            }
+                            Object[] array = (Object[]) java.lang.reflect.Array
+                                    .newInstance(type, cparam.size());
+                            Iterator<?> it = cparam.iterator();
+                            for (int j = 0; j < cparam.size(); ++j) {
+                                array[j] = it.next();
+                            }
+                            params[i] = array;
+                            retry = true;
+                        }
                     }
+                    candidates = retry ? getPotentialFactoryMethods(params)
+                            : candidates;
+                    method = retry
+                            ? getFactoryMethod(transformer, candidates, params)
+                            : method;
                 }
                 Verify.that(method != null,
                         "Cannot serialize transformer using technique "
@@ -257,6 +308,44 @@ public ByteBuffer serialize(Transformer transformer) {
         return serialized;
     }
 
+    /**
+     * Return the factory method from amongst the {@code candidates} that
+     * produced the {@code transformer} using the provided {@code params}
+     * 
+     * @param transformer
+     * @param candidates
+     * @param params
+     * @return the factory method for the {@link Transformer}
+     * @throws ReflectiveOperationException
+     */
+    @Nullable
+    private Method getFactoryMethod(Transformer transformer,
+            List<Method> candidates, Object... params)
+            throws ReflectiveOperationException {
+        Method method = null;
+        for (Method candidate : candidates) {
+            candidate.setAccessible(true);
+            Class<? extends Transformer> clazz = lambdas
+                    .get(candidate.getName());
+            try {
+                if(clazz == null) {
+                    Transformer t = (Transformer) candidate.invoke(null,
+                            params);
+                    clazz = t.getClass();
+                    lambdas.put(candidate.getName(), clazz);
+                }
+                if(clazz.equals(transformer.getClass())) {
+                    method = candidate;
+                    break;
+                }
+            }
+            catch (IllegalArgumentException e) {
+                continue;
+            }
+        }
+        return method;
+    }
+
     /**
      * The possible serialization techniques.
      *

src/main/java/com/cinchapi/etl/Transformers.java

@@ -202,26 +202,6 @@ public static Transformer keyMap(Map<String, String> map) {
         };
     }
 
-    /**
-     * Return a {@link Transformer} that replaces whitespace characters with an
-     * underscore in keys.
-     * 
-     * @return the {@link Transformer}
-     */
-    public static Transformer keyWhitespaceToUnderscore() {
-        return keyReplaceChars(ImmutableMap.of(' ', '_'));
-    }
-
-    /**
-     * Return a {@link Transformer} that removes all whitespace characters from
-     * a key.
-     * 
-     * @return the {@link Transformer}
-     */
-    public static Transformer keyRemoveWhitespace() {
-        return keyRemoveInvalidChars(Character::isWhitespace);
-    }
-
     /**
      * Return a {@link Transformer} that removes all the character in the
      * {@code invalid} collection.
@@ -269,6 +249,16 @@ public static Transformer keyRemoveInvalidChars(
         };
     }
 
+    /**
+     * Return a {@link Transformer} that removes all whitespace characters from
+     * a key.
+     * 
+     * @return the {@link Transformer}
+     */
+    public static Transformer keyRemoveWhitespace() {
+        return keyRemoveInvalidChars(Character::isWhitespace);
+    }
+
     /**
      * Return a {@link Transformer} that replaces all the character keys in the
      * {@code replacements} mapping with their associated character values in
@@ -366,6 +356,16 @@ public static Transformer keyValueStripQuotes() {
         return keyValueRemoveQuotes();
     }
 
+    /**
+     * Return a {@link Transformer} that replaces whitespace characters with an
+     * underscore in keys.
+     * 
+     * @return the {@link Transformer}
+     */
+    public static Transformer keyWhitespaceToUnderscore() {
+        return keyReplaceChars(ImmutableMap.of(' ', '_'));
+    }
+
     /**
      * Return a {@link Transformer} that does not perform any key or value
      * transformations.
@@ -388,10 +388,6 @@ public static Transformer nullSafe(Transformer transformer) {
                 : null;
     }
 
-    public static Transformer valueRemoveIfEmpty() {
-        return valueRemoveIf(Empty.ness());
-    }
-
     /**
      * Return a {@link Transformer} that will cause a key/value pair to be
      * "removed" if the value is described by the provided {@code adjective}.
@@ -408,21 +404,6 @@ public static Transformer removeValuesThatAre(Adjective adjective) {
         return valueRemoveIf(adjective);
     }
 
-    /**
-     * Return a {@link Transformer} that will cause a key/value pair to be
-     * "removed" if the value is described by the provided {@code adjective}.
-     * <p>
-     * Removal is accomplished by returning an empty map for the transformation.
-     * </p>
-     * 
-     * @param adjective
-     * @return the {@link Transformer}
-     */
-    public static Transformer valueRemoveIf(Adjective adjective) {
-        return (key, value) -> adjective.describes(value) ? ImmutableMap.of()
-                : null;
-    }
-
     /**
      * Return a {@link Transformer} that, For EVERY key, transform values to a
      * {@link Boolean} if possible. If the value cannot be transformed, an
@@ -564,6 +545,41 @@ public static Transformer valueAsResolvableLinkInstruction(String... keys) {
         }
     }
 
+    /**
+     * Return a {@link Transformer} that, for EVERY key, transforms values to a
+     * {@link String}.
+     * 
+     * @return the {@link Transformer}
+     */
+    public static Transformer valueAsString() {
+        return (key, value) -> value instanceof String ? null
+                : Transformation.to(key, value.toString());
+    }
+
+    /**
+     * Return a {@link Transformer} that, for the specified {@code key}as,
+     * transforms values to a {@link String}.
+     * 
+     * @param keys
+     * @return the {@link Transformer}
+     */
+    public static Transformer valueAsString(String... keys) {
+        if(keys.length == 0) {
+            return valueAsString();
+        }
+        else {
+            Set<String> _keys = Arrays.stream(keys).collect(Collectors.toSet());
+            return (key, value) -> {
+                if(_keys.contains(key)) {
+                    return valueAsString().transform(key, value);
+                }
+                else {
+                    return null;
+                }
+            };
+        }
+    }
+
     /**
      * Return a {@link Transformer} that, For EVERY key, transform values to a
      * {@link Number} if possible. If the value cannot be transformed, an
@@ -687,6 +703,25 @@ public static Transformer valueNullifyIfEmpty(Empty empty) {
         };
     }
 
+    /**
+     * Return a {@link Transformer} that will cause a key/value pair to be
+     * "removed" if the value is described by the provided {@code adjective}.
+     * <p>
+     * Removal is accomplished by returning an empty map for the transformation.
+     * </p>
+     * 
+     * @param adjective
+     * @return the {@link Transformer}
+     */
+    public static Transformer valueRemoveIf(Adjective adjective) {
+        return (key, value) -> adjective.describes(value) ? ImmutableMap.of()
+                : null;
+    }
+
+    public static Transformer valueRemoveIfEmpty() {
+        return valueRemoveIf(Empty.ness());
+    }
+
     /**
      * Return a {@link Transformer} that splits a String value into multiple
      * strings that are all mapped from the original key.