Remove "then" conditions on some In conditions

The case insensitive in conditions are actually
specializations of the regular in conditions and not
intended to be extended.

Author: jeffgbutler

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

@@ -25,12 +25,8 @@
 
 public class IsInCaseInsensitive extends AbstractListValueCondition<String> {
 
-    protected IsInCaseInsensitive(Collection<String> values) {
-        super(values, s -> s.map(StringUtilities::safelyUpperCase));
-    }
-
     protected IsInCaseInsensitive(Collection<String> values, UnaryOperator<Stream<String>> valueStreamTransformer) {
-        super(values, StringUtilities.upperCaseAfter(valueStreamTransformer));
+        super(values, valueStreamTransformer);
     }
 
     @Override
@@ -39,21 +35,7 @@ public String renderCondition(String columnName, Stream<String> placeholders) {
                 placeholders.collect(Collectors.joining(",", "in (", ")")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
     }
 
-    /**
-     * 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);
-    }
-
     public static IsInCaseInsensitive of(Collection<String> values) {
-        return new IsInCaseInsensitive(values);
+        return new IsInCaseInsensitive(values, s -> s.map(StringUtilities::safelyUpperCase));
     }
 }

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

@@ -15,16 +15,21 @@
  */
 package org.mybatis.dynamic.sql.where.condition;
 
+import org.mybatis.dynamic.sql.util.StringUtilities;
+
 import java.util.Collection;
 import java.util.Objects;
+import java.util.function.UnaryOperator;
+import java.util.stream.Stream;
 
 public class IsInCaseInsensitiveWhenPresent extends IsInCaseInsensitive {
 
-    protected IsInCaseInsensitiveWhenPresent(Collection<String> values) {
-        super(values, s -> s.filter(Objects::nonNull));
+    protected IsInCaseInsensitiveWhenPresent(Collection<String> values, UnaryOperator<Stream<String>> valueStreamTransformer) {
+        super(values, valueStreamTransformer);
     }
 
     public static IsInCaseInsensitiveWhenPresent of(Collection<String> values) {
-        return new IsInCaseInsensitiveWhenPresent(values);
+        return new IsInCaseInsensitiveWhenPresent(values,
+                s -> s.filter(Objects::nonNull).map(StringUtilities::safelyUpperCase));
     }
 }

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

@@ -25,12 +25,8 @@
 
 public class IsNotInCaseInsensitive extends AbstractListValueCondition<String> {
 
-    protected IsNotInCaseInsensitive(Collection<String> values) {
-        super(values, s -> s.map(StringUtilities::safelyUpperCase));
-    }
-
     protected IsNotInCaseInsensitive(Collection<String> values, UnaryOperator<Stream<String>> valueStreamTransformer) {
-        super(values, StringUtilities.upperCaseAfter(valueStreamTransformer));
+        super(values, valueStreamTransformer);
     }
 
     @Override
@@ -40,21 +36,7 @@ public String renderCondition(String columnName, Stream<String> placeholders) {
                         Collectors.joining(",", "not in (", ")")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
     }
 
-    /**
-     * 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);
-    }
-
     public static IsNotInCaseInsensitive of(Collection<String> values) {
-        return new IsNotInCaseInsensitive(values);
+        return new IsNotInCaseInsensitive(values, s -> s.map(StringUtilities::safelyUpperCase));
     }
 }

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

@@ -15,16 +15,20 @@
  */
 package org.mybatis.dynamic.sql.where.condition;
 
+import org.mybatis.dynamic.sql.util.StringUtilities;
+
 import java.util.Collection;
 import java.util.Objects;
+import java.util.function.UnaryOperator;
+import java.util.stream.Stream;
 
 public class IsNotInCaseInsensitiveWhenPresent extends IsNotInCaseInsensitive {
 
-    protected IsNotInCaseInsensitiveWhenPresent(Collection<String> values) {
-        super(values, s -> s.filter(Objects::nonNull));
+    protected IsNotInCaseInsensitiveWhenPresent(Collection<String> values, UnaryOperator<Stream<String>> valueStreamTransformer) {
+        super(values, valueStreamTransformer);
     }
 
     public static IsNotInCaseInsensitiveWhenPresent of(Collection<String> values) {
-        return new IsNotInCaseInsensitiveWhenPresent(values);
+        return new IsNotInCaseInsensitiveWhenPresent(values, s -> s.filter(Objects::nonNull).map(StringUtilities::safelyUpperCase));
     }
 }

src/test/java/examples/animal/data/OptionalConditionsWithPredicatesAnimalDataTest.java

@@ -514,25 +514,6 @@ void testValueStreamTransformerWithCustomCondition() {
         }
     }
 
-    @Test
-    void testIsInCaseInsensitiveWhenWithSomeValues() {
-        try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
-            AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class);
-            SelectStatementProvider selectStatement = select(id, animalName, bodyWeight, brainWeight)
-                    .from(animalData)
-                    .where(animalName, isInCaseInsensitive("mouse", null, "musk shrew").then(s -> s.filter(Objects::nonNull)))
-                    .orderBy(id)
-                    .build()
-                    .render(RenderingStrategies.MYBATIS3);
-            List<AnimalData> animals = mapper.selectMany(selectStatement);
-            assertAll(
-                    () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where upper(animal_name) in (#{parameters.p1,jdbcType=VARCHAR},#{parameters.p2,jdbcType=VARCHAR}) order by id"),
-                    () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(4)
-            );
-        }
-    }
-
     @Test
     void testIsInCaseInsensitiveWhenWithNoValues() {
         try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
@@ -613,26 +594,6 @@ void testIsNotInCaseInsensitiveWhenWithValue() {
         }
     }
 
-    @Test
-    void testIsNotInCaseInsensitiveWhenWithSomeValues() {
-        try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
-            AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class);
-            SelectStatementProvider selectStatement = select(id, animalName, bodyWeight, brainWeight)
-                    .from(animalData)
-                    .where(animalName, isNotInCaseInsensitive("mouse", null, "musk shrew").then(s -> s.filter(Objects::nonNull)))
-                    .and(id, isLessThanOrEqualTo(10))
-                    .orderBy(id)
-                    .build()
-                    .render(RenderingStrategies.MYBATIS3);
-            List<AnimalData> animals = mapper.selectMany(selectStatement);
-            assertAll(
-                    () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where upper(animal_name) not in (#{parameters.p1,jdbcType=VARCHAR},#{parameters.p2,jdbcType=VARCHAR}) and id <= #{parameters.p3,jdbcType=INTEGER} order by id"),
-                    () -> assertThat(animals).hasSize(8),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
-            );
-        }
-    }
-
     @Test
     void testIsNotInCaseInsensitiveWhenWithNoValues() {
         try (SqlSession sqlSession = sqlSessionFactory.openSession()) {