Deprecate the "withValueStreamOperations" method in favor of "then"

This is consistent with the "then" method on the other conditions.

Naming things is hard.

Author: jeffgbutler

src/main/java/org/mybatis/dynamic/sql/AbstractListValueCondition.java

@@ -24,19 +24,19 @@
 
 public abstract class AbstractListValueCondition<T> implements VisitableCondition<T> {
     protected Collection<T> values;
-    protected UnaryOperator<Stream<T>> valueStreamOperations;
+    protected UnaryOperator<Stream<T>> valueStreamTransformer;
 
     protected AbstractListValueCondition(Collection<T> values) {
         this(values, UnaryOperator.identity());
     }
 
-    protected AbstractListValueCondition(Collection<T> values, UnaryOperator<Stream<T>> valueStreamOperations) {
+    protected AbstractListValueCondition(Collection<T> values, UnaryOperator<Stream<T>> valueStreamTransformer) {
         this.values = new ArrayList<>(Objects.requireNonNull(values));
-        this.valueStreamOperations = Objects.requireNonNull(valueStreamOperations);
+        this.valueStreamTransformer = Objects.requireNonNull(valueStreamTransformer);
     }
 
     public final <R> Stream<R> mapValues(Function<T, R> mapper) {
-        return valueStreamOperations.apply(values.stream()).map(mapper);
+        return valueStreamTransformer.apply(values.stream()).map(mapper);
     }
 
     @Override

src/main/java/org/mybatis/dynamic/sql/where/condition/IsIn.java

@@ -26,8 +26,8 @@
 
 public class IsIn<T> extends AbstractListValueCondition<T> {
 
-    protected IsIn(Collection<T> values, UnaryOperator<Stream<T>> valueStreamOperations) {
-        super(values, valueStreamOperations);
+    protected IsIn(Collection<T> values, UnaryOperator<Stream<T>> valueStreamTransformer) {
+        super(values, valueStreamTransformer);
     }
 
     protected IsIn(Collection<T> values) {
@@ -40,8 +40,35 @@ public String renderCondition(String columnName, Stream<String> placeholders) {
                 + placeholders.collect(Collectors.joining(",", "in (", ")")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
     }
 
-    public IsIn<T> withValueStreamOperations(UnaryOperator<Stream<T>> valueStreamOperations) {
-        return new IsIn<>(values, valueStreamOperations);
+    /**
+     * This method allows you to modify the condition's values before they are placed into the parameter map.
+     * For example, you could filter nulls, or trim strings, etc. This process will run before final rendering of SQL.
+     * If you filter values out of the stream, then final condition will not reference those values. If you filter all
+     * values out of the stream, then the condition will not render.
+     *   
+     * @param valueStreamTransformer a UnaryOperator that will transform the value stream before
+     *     the values are placed in the parameter map
+     * @return new condition with the specified transformer
+     */
+    public IsIn<T> then(UnaryOperator<Stream<T>> valueStreamTransformer) {
+        return new IsIn<>(values, valueStreamTransformer);
+    }
+
+    /**
+     * This method allows you to modify the condition's values before they are placed into the parameter map.
+     * For example, you could filter nulls, or trim strings, etc. This process will run before final rendering of SQL.
+     * If you filter values out of the stream, then final condition will not reference those values. If you filter all
+     * values out of the stream, then the condition will not render.
+     *   
+     * @param valueStreamTransformer a UnaryOperator that will transform the value stream before
+     *     the values are placed in the parameter map
+     * @return new condition with the specified transformer
+     * 
+     * @deprecated See {@link IsIn#then(UnaryOperator)}
+     */
+    @Deprecated
+    public IsIn<T> withValueStreamOperations(UnaryOperator<Stream<T>> valueStreamTransformer) {
+        return then(valueStreamTransformer);
     }
 
     public static <T> IsIn<T> of(Collection<T> values) {

src/main/java/org/mybatis/dynamic/sql/where/condition/IsInCaseInsensitive.java

@@ -29,8 +29,8 @@ protected IsInCaseInsensitive(Collection<String> values) {
         super(values, s -> s.map(StringUtilities::safelyUpperCase));
     }
 
-    protected IsInCaseInsensitive(Collection<String> values, UnaryOperator<Stream<String>> valueStreamOperations) {
-        super(values, StringUtilities.upperCaseAfter(valueStreamOperations));
+    protected IsInCaseInsensitive(Collection<String> values, UnaryOperator<Stream<String>> valueStreamTransformer) {
+        super(values, StringUtilities.upperCaseAfter(valueStreamTransformer));
     }
 
     @Override
@@ -39,8 +39,35 @@ public String renderCondition(String columnName, Stream<String> placeholders) {
                 placeholders.collect(Collectors.joining(",", "in (", ")")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
     }
 
-    public IsInCaseInsensitive withValueStreamOperations(UnaryOperator<Stream<String>> valueStreamOperations) {
-        return new IsInCaseInsensitive(values, valueStreamOperations);
+    /**
+     * This method allows you to modify the condition's values before they are placed into the parameter map.
+     * For example, you could filter nulls, or trim strings, etc. This process will run before final rendering of SQL.
+     * If you filter values out of the stream, then final condition will not reference those values. If you filter all
+     * values out of the stream, then the condition will not render.
+     * 
+     * @param valueStreamTransformer a UnaryOperator that will transform the value stream before
+     *     the values are placed in the parameter map
+     * @return new condition with the specified transformer
+     */
+    public IsInCaseInsensitive then(UnaryOperator<Stream<String>> valueStreamTransformer) {
+        return new IsInCaseInsensitive(values, valueStreamTransformer);
+    }
+
+    /**
+     * This method allows you to modify the condition's values before they are placed into the parameter map.
+     * For example, you could filter nulls, or trim strings, etc. This process will run before final rendering of SQL.
+     * If you filter values out of the stream, then final condition will not reference those values. If you filter all
+     * values out of the stream, then the condition will not render.
+     * 
+     * @param valueStreamTransformer a UnaryOperator that will transform the value stream before
+     *     the values are placed in the parameter map
+     * @return new condition with the specified transformer
+     * 
+     * @deprecated See {@link IsInCaseInsensitive#then(UnaryOperator)}
+     */
+    @Deprecated
+    public IsInCaseInsensitive withValueStreamOperations(UnaryOperator<Stream<String>> valueStreamTransformer) {
+        return then(valueStreamTransformer);
     }
 
     public static IsInCaseInsensitive of(Collection<String> values) {

src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotIn.java

@@ -26,8 +26,8 @@
 
 public class IsNotIn<T> extends AbstractListValueCondition<T> {
 
-    protected IsNotIn(Collection<T> values, UnaryOperator<Stream<T>> valueStreamOperations) {
-        super(values, valueStreamOperations);
+    protected IsNotIn(Collection<T> values, UnaryOperator<Stream<T>> valueStreamTransformer) {
+        super(values, valueStreamTransformer);
     }
 
     protected IsNotIn(Collection<T> values) {
@@ -41,8 +41,35 @@ public String renderCondition(String columnName, Stream<String> placeholders) {
                         Collectors.joining(",", "not in (", ")")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
     }
 
-    public IsNotIn<T> withValueStreamOperations(UnaryOperator<Stream<T>> valueStreamOperations) {
-        return new IsNotIn<>(values, valueStreamOperations);
+    /**
+     * This method allows you to modify the condition's values before they are placed into the parameter map.
+     * For example, you could filter nulls, or trim strings, etc. This process will run before final rendering of SQL.
+     * If you filter values out of the stream, then final condition will not reference those values. If you filter all
+     * values out of the stream, then the condition will not render.
+     * 
+     * @param valueStreamTransformer a UnaryOperator that will transform the value stream before
+     *     the values are placed in the parameter map
+     * @return new condition with the specified transformer
+     */
+    public IsNotIn<T> then(UnaryOperator<Stream<T>> valueStreamTransformer) {
+        return new IsNotIn<>(values, valueStreamTransformer);
+    }
+
+    /**
+     * This method allows you to modify the condition's values before they are placed into the parameter map.
+     * For example, you could filter nulls, or trim strings, etc. This process will run before final rendering of SQL.
+     * If you filter values out of the stream, then final condition will not reference those values. If you filter all
+     * values out of the stream, then the condition will not render.
+     * 
+     * @param valueStreamTransformer a UnaryOperator that will transform the value stream before
+     *     the values are placed in the parameter map
+     * @return new condition with the specified transformer
+     * 
+     * @deprecated See {@link IsNotIn#then(UnaryOperator)}
+     */
+    @Deprecated
+    public IsNotIn<T> withValueStreamOperations(UnaryOperator<Stream<T>> valueStreamTransformer) {
+        return then(valueStreamTransformer);
     }
 
     public static <T> IsNotIn<T> of(Collection<T> values) {

src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotInCaseInsensitive.java

@@ -29,8 +29,8 @@ protected IsNotInCaseInsensitive(Collection<String> values) {
         super(values, s -> s.map(StringUtilities::safelyUpperCase));
     }
 
-    protected IsNotInCaseInsensitive(Collection<String> values, UnaryOperator<Stream<String>> valueStreamOperations) {
-        super(values, StringUtilities.upperCaseAfter(valueStreamOperations));
+    protected IsNotInCaseInsensitive(Collection<String> values, UnaryOperator<Stream<String>> valueStreamTransformer) {
+        super(values, StringUtilities.upperCaseAfter(valueStreamTransformer));
     }
 
     @Override
@@ -40,8 +40,35 @@ public String renderCondition(String columnName, Stream<String> placeholders) {
                         Collectors.joining(",", "not in (", ")")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
     }
 
-    public IsNotInCaseInsensitive withValueStreamOperations(UnaryOperator<Stream<String>> valueStreamOperations) {
-        return new IsNotInCaseInsensitive(values, valueStreamOperations);
+    /**
+     * This method allows you to modify the condition's values before they are placed into the parameter map.
+     * For example, you could filter nulls, or trim strings, etc. This process will run before final rendering of SQL.
+     * If you filter values out of the stream, then final condition will not reference those values. If you filter all
+     * values out of the stream, then the condition will not render.
+     * 
+     * @param valueStreamTransformer a UnaryOperator that will transform the value stream before
+     *     the values are placed in the parameter map
+     * @return new condition with the specified transformer
+     */
+    public IsNotInCaseInsensitive then(UnaryOperator<Stream<String>> valueStreamTransformer) {
+        return new IsNotInCaseInsensitive(values, valueStreamTransformer);
+    }
+
+    /**
+     * This method allows you to modify the condition's values before they are placed into the parameter map.
+     * For example, you could filter nulls, or trim strings, etc. This process will run before final rendering of SQL.
+     * If you filter values out of the stream, then final condition will not reference those values. If you filter all
+     * values out of the stream, then the condition will not render.
+     * 
+     * @param valueStreamTransformer a UnaryOperator that will transform the value stream before
+     *     the values are placed in the parameter map
+     * @return new condition with the specified transformer
+     * 
+     * @deprecated See {@link IsNotInCaseInsensitive#then(UnaryOperator)}
+     */
+    @Deprecated
+    public IsNotInCaseInsensitive withValueStreamOperations(UnaryOperator<Stream<String>> valueStreamTransformer) {
+        return then(valueStreamTransformer);
     }
 
     public static IsNotInCaseInsensitive of(Collection<String> values) {

src/site/markdown/docs/conditions.md

@@ -143,13 +143,13 @@ The following table shows the different supplied In conditions and how they will
 
 If none of these options meet your needs, there is an extension point where you can add your own filter and/or map conditions to the value stream. This gives you great flexibility to alter or filter the value list before the condition is rendered.
 
-The extension point for modifying the value list is the method `withValueStreamOperations(UnaryOperator<Stream<T>>)`. This method accepts a `UnaryOperator<Stream<T>>` in which you can specify map and/or filter operations for the value stream. For example, suppose you wanted to code an "in" condition that accepted a list of strings, but you want to filter out any null or blank string, and you want to trim all strings. This can be accomplished with code like this:
+The extension point for modifying the value list is the method `then(UnaryOperator<Stream<T>>)`. This method accepts a `UnaryOperator<Stream<T>>` in which you can specify map and/or filter operations for the value stream. For example, suppose you wanted to code an "in" condition that accepted a list of strings, but you want to filter out any null or blank string, and you want to trim all strings. This can be accomplished with code like this:
 
 ```java
             SelectStatementProvider selectStatement = select(id, animalName, bodyWeight, brainWeight)
                     .from(animalData)
                     .where(animalName, isIn("  Mouse", "  ", null, "", "Musk shrew  ")
-                            .withValueStreamOperations(s -> s.filter(Objects::nonNull)
+                            .then(s -> s.filter(Objects::nonNull)
                                     .map(String::trim)
                                     .filter(st -> !st.isEmpty())))
                     .orderBy(id)