- r future proofing multiline option

Author: LarsEckart

approvaltests/src/main/java/org/approvaltests/utils/parseinput/ParseInput.java

@@ -12,25 +12,25 @@
 public class ParseInput<OUT>
 {
   private final String                                expected;
-  private final boolean                               multiline;
+  private final ParseInputOptions                     options;
   private final Function1<String, Tuple<String, OUT>> transformer;
-  ParseInput(String expected, Function1<String, Tuple<String, OUT>> transformer, boolean multiline)
+  ParseInput(String expected, Function1<String, Tuple<String, OUT>> transformer, ParseInputOptions options)
   {
     this.expected = expected;
     this.transformer = transformer;
-    this.multiline = multiline;
+    this.options = options;
   }
   public static ParseInput<String> from(String expected)
   {
-    return new ParseInput<String>(expected, s -> new Tuple<>(s, s), false);
+    return new ParseInput<String>(expected, s -> new Tuple<>(s, s), new ParseInputOptions());
   }
   public ParseInput<OUT> multiline()
   {
-    return new ParseInput<>(expected, transformer, true);
+    return new ParseInput<>(expected, transformer, new ParseInputOptions(true));
   }
   public Queryable<Tuple<String, OUT>> parse()
   {
-    Function1<String, Boolean> f = multiline ? s -> s.contains("->") : s -> true;
+    Function1<String, Boolean> f = options.multiline ? s -> s.contains("->") : s -> true;
     return Queryable.as(expected.split("\n")) //
         .where(f) //
         .select(l -> l.split("->")[0].trim()) //
@@ -66,21 +66,33 @@ public static <OUT> Function1<String, OUT> getTransformerForClass(Class<OUT> tar
   // ************* 1 parameter
   public <T1> ParseInputWith1Parameters<T1> withTypes(Class<T1> type1)
   {
-    return ParseInputWith1Parameters.create(expected, type1, multiline);
+    return ParseInputWith1Parameters.create(expected, type1, options);
   }
   public <T1> ParseInputWith1Parameters<T1> transformTo(Function1<String, T1> transformer)
   {
-    return new ParseInputWith1Parameters<>(expected, transformer, multiline);
+    return new ParseInputWith1Parameters<>(expected, transformer, options);
   }
   // ************* 2 parameters
   public <T1, T2> ParseInputWith2Parameters<T1, T2> withTypes(Class<T1> type1, Class<T2> type2)
   {
     return ParseInputWith2Parameters.create(expected, getTransformerForClass(type1), getTransformerForClass(type2),
-        multiline);
+        options);
   }
   public <T1, T2> ParseInputWith2Parameters<T1, T2> transformTo(Function1<String, T1> transformer1,
       Function1<String, T2> transformer2)
   {
-    return ParseInputWith2Parameters.create(expected, transformer1, transformer2, multiline);
+    return ParseInputWith2Parameters.create(expected, transformer1, transformer2, options);
+  }
+  public static class ParseInputOptions
+  {
+    public final boolean multiline;
+    public ParseInputOptions()
+    {
+      this(false);
+    }
+    public ParseInputOptions(boolean multiline)
+    {
+      this.multiline = multiline;
+    }
   }
 }

approvaltests/src/main/java/org/approvaltests/utils/parseinput/ParseInputWith1Parameters.java

@@ -7,22 +7,22 @@
 public class ParseInputWith1Parameters<OUT>
 {
   private final String                 expected;
-  private final boolean                multiline;
+  private final ParseInput.ParseInputOptions options;
   private final Function1<String, OUT> transformer;
-  public ParseInputWith1Parameters(String expected, Function1<String, OUT> transformer, boolean multiline)
+  public ParseInputWith1Parameters(String expected, Function1<String, OUT> transformer, ParseInput.ParseInputOptions options)
   {
     this.expected = expected;
     this.transformer = transformer;
-    this.multiline = multiline;
+    this.options = options;
   }
-  public static <OUT> ParseInputWith1Parameters<OUT> create(String expected, Class<OUT> type1, boolean multiline)
+  public static <OUT> ParseInputWith1Parameters<OUT> create(String expected, Class<OUT> type1, ParseInput.ParseInputOptions multiline)
   {
     return new ParseInputWith1Parameters<>(expected, ParseInput.getTransformerForClass(type1), multiline);
   }
   public <OUT2> ParseInputWith1Parameters<OUT2> transformTo(Function1<OUT, OUT2> transformer1)
   {
     Function1<String, OUT2> transformer2 = (String t) -> transformer1.call(transformer.call(t));
-    return new ParseInputWith1Parameters<>(expected, transformer2, multiline);
+    return new ParseInputWith1Parameters<>(expected, transformer2, options);
   }
   public Queryable<OUT> getInputs()
   {
@@ -31,7 +31,7 @@ public Queryable<OUT> getInputs()
   private ParseInput<OUT> getParseInput()
   {
     Function1<String, Tuple<String, OUT>> transformer = s -> new Tuple<>(s, this.transformer.call(s));
-    return new ParseInput<OUT>(expected, transformer, multiline);
+    return new ParseInput<OUT>(expected, transformer, options);
   }
   public void verifyAll(Function1<OUT, Object> transform)
   {

approvaltests/src/main/java/org/approvaltests/utils/parseinput/ParseInputWith2Parameters.java

@@ -9,36 +9,36 @@ public class ParseInputWith2Parameters<IN1, IN2>
 {
   private final String                             expected;
   private final Function1<String, Tuple<IN1, IN2>> transformer;
-  private final boolean                            multiline;
+  private final ParseInput.ParseInputOptions options;
   public ParseInputWith2Parameters(String expected, Function1<String, Tuple<IN1, IN2>> transformer,
-      boolean multiline)
+      ParseInput.ParseInputOptions options)
   {
     this.expected = expected;
     this.transformer = transformer;
-    this.multiline = multiline;
+    this.options = options;
   }
   public static <IN1, IN2> ParseInputWith2Parameters<IN1, IN2> create(String expected, Function1<String, IN1> t1,
-      Function1<String, IN2> t2, boolean multiline)
+      Function1<String, IN2> t2, ParseInput.ParseInputOptions options)
   {
     Function1<String, Tuple<IN1, IN2>> f = s -> {
       Queryable<String> temp = Queryable.as(s.split(",")).select(String::trim);
       IN1 v1 = t1.call(temp.get(0));
       IN2 v2 = t2.call(temp.get(1));
       return new Tuple<>(v1, v2);
     };
-    return new ParseInputWith2Parameters<>(expected, f, multiline);
+    return new ParseInputWith2Parameters<>(expected, f, options);
   }
   private ParseInput<Tuple<IN1, IN2>> getParseInput()
   {
-    return new ParseInput<>(expected, s -> new Tuple<>(s, transformer.call(s)), multiline);
+    return new ParseInput<>(expected, s -> new Tuple<>(s, transformer.call(s)), options);
   }
   public <OUT> ParseInputWith1Parameters<OUT> transformTo(Function2<IN1, IN2, OUT> transform)
   {
     Function1<String, OUT> f1 = (t) -> {
       Tuple<IN1, IN2> transformed = transformer.call(t);
       return transform.call(transformed.getFirst(), transformed.getSecond());
     };
-    return new ParseInputWith1Parameters<>(expected, f1, multiline);
+    return new ParseInputWith1Parameters<>(expected, f1, options);
   }
   public void verifyAll(Function2<IN1, IN2, Object> transform)
   {