Replace Template input/output Map with Values

Author: mvollmary

README.md

@@ -27,7 +27,7 @@ Token token = Token.of("[a-zA-Z]+");
 Template template = Template.of("Hello ${name}!")
     .withToken("name", token);
 
-Map<String, String> values = Map.of("name", "World");
+Values values = Values.of("name", "World");
 String output = template.format(values);
 
 System.out.println(output);
@@ -43,7 +43,7 @@ Token token = Token.of("[a-zA-Z]+");
 Template template = Template.of("Hello ${name}!")
     .withToken("name", token);
 
-Map<String, String> data = template.parse("Hello World!");
+Values data = template.parse("Hello World!");
 
 System.out.println(data);
 ```

src/main/java/io/github/noncat_lang/Template.java

@@ -1,7 +1,5 @@
 package io.github.noncat_lang;
 
-import java.util.Map;
-
 import io.github.noncat_lang.internal.TemplateImpl;
 
 public interface Template {
@@ -12,10 +10,10 @@ static Template of(String templateString) {
 
   Template withToken(String field, Token token);
 
-  String format(Map<String, String> values);
+  String format(Values values);
 
-  String unparse(Map<String, String> values);
+  String unparse(Values values);
 
-  Map<String, String> parse(String value);
+  Values parse(String value);
 
 }

src/main/java/io/github/noncat_lang/Values.java

@@ -0,0 +1,34 @@
+package io.github.noncat_lang;
+
+import java.util.Map;
+import java.util.Optional;
+
+import io.github.noncat_lang.internal.ValuesImpl;
+
+public interface Values {
+
+  static Values create() {
+    return of();
+  }
+
+  static Values of() {
+    return ValuesImpl.of();
+  }
+
+  static Values of(String field, String value) {
+    return of().set(field, value);
+  }
+
+  static Values of(Map<String, String> values) {
+    return of().setAll(values);
+  }
+
+  Values set(String field, String value);
+
+  Values setAll(Map<String, String> values);
+
+  Optional<String> get(String field);
+
+  int size();
+
+}

src/main/java/io/github/noncat_lang/internal/DecodingImpl.java

@@ -1,13 +1,10 @@
 package io.github.noncat_lang.internal;
 
 import io.github.noncat_lang.Decoding;
-import lombok.AccessLevel;
-import lombok.AllArgsConstructor;
 import lombok.NonNull;
-import lombok.experimental.FieldDefaults;
+import lombok.Value;
 
-@AllArgsConstructor(staticName = "of")
-@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
+@Value(staticConstructor = "of")
 public final class DecodingImpl implements Decoding {
   @NonNull
   String regex;

src/main/java/io/github/noncat_lang/internal/EncodingImpl.java

@@ -1,13 +1,10 @@
 package io.github.noncat_lang.internal;
 
 import io.github.noncat_lang.Encoding;
-import lombok.AccessLevel;
-import lombok.AllArgsConstructor;
 import lombok.NonNull;
-import lombok.experimental.FieldDefaults;
+import lombok.Value;
 
-@AllArgsConstructor(staticName = "of")
-@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
+@Value(staticConstructor = "of")
 public final class EncodingImpl implements Encoding {
   @NonNull
   String regex;

src/main/java/io/github/noncat_lang/internal/TemplateImpl.java

@@ -17,15 +17,13 @@
 import io.github.noncat_lang.TemplateParser.ElementContext;
 import io.github.noncat_lang.TemplateParser.TemplateContext;
 import io.github.noncat_lang.Token;
+import io.github.noncat_lang.Values;
 import io.github.noncat_lang.exceptions.MissingTokenException;
 import io.github.noncat_lang.exceptions.MissingValueException;
-import lombok.AccessLevel;
-import lombok.AllArgsConstructor;
 import lombok.NonNull;
-import lombok.experimental.FieldDefaults;
+import lombok.Value;
 
-@AllArgsConstructor(access = AccessLevel.PRIVATE)
-@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
+@Value
 public final class TemplateImpl implements Template {
   TemplateContext parseTree;
   Map<String, Token> tokens = new HashMap<>();
@@ -49,27 +47,27 @@ public TemplateImpl withToken(@NonNull String field, @NonNull Token token) {
   }
 
   @Override
-  public String format(@NonNull Map<String, String> values) {
+  public String format(@NonNull Values values) {
     return unparse(values);
   }
 
   @Override
-  public String unparse(@NonNull Map<String, String> values) {
+  public String unparse(@NonNull Values values) {
     return parseTree.element().stream().map(element -> unparseElement(element, values)).collect(Collectors.joining());
   }
 
-  private String unparseElement(ElementContext element, Map<String, String> values) {
+  private String unparseElement(ElementContext element, Values values) {
     ArgContext arg = element.arg();
     return arg == null ? element.TEXT().getText() : unparseArg(arg, values);
   }
 
-  private String unparseArg(ArgContext arg, @NonNull Map<String, String> values) {
+  private String unparseArg(ArgContext arg, @NonNull Values values) {
     String id = getId(arg);
     Token token = tokens.get(id);
     if (token == null) {
       throw new MissingTokenException(String.format("Token for field '%s' is missing", id));
     }
-    String value = values.get(id);
+    String value = values.get(id).orElse(null);
     if (value == null) {
       throw new MissingValueException(String.format("Value for field '%s' is missing", id));
     }
@@ -78,14 +76,14 @@ private String unparseArg(ArgContext arg, @NonNull Map<String, String> values) {
   }
 
   @Override
-  public Map<String, String> parse(@NonNull String value) {
+  public Values parse(@NonNull String value) {
     String pattern = parseTree.element().stream().map(this::parseElement).collect(Collectors.joining());
     Matcher matcher = Pattern.compile(pattern).matcher(value);
     if (!matcher.matches()) {
       throw new IllegalArgumentException(
           String.format("Error during parsing: value '%s' does not match pattern '%s'", value, pattern));
     }
-    return decodeAllToken(matcher);
+    return Values.of(decodeAllToken(matcher));
   }
 
   private Map<String, String> decodeAllToken(Matcher matcher) {

src/main/java/io/github/noncat_lang/internal/TokenImpl.java

@@ -9,17 +9,12 @@
 import io.github.noncat_lang.Decoding;
 import io.github.noncat_lang.Encoding;
 import io.github.noncat_lang.Token;
-import lombok.AccessLevel;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
 import lombok.NonNull;
-import lombok.experimental.FieldDefaults;
+import lombok.Value;
 
-@AllArgsConstructor(access = AccessLevel.PRIVATE)
-@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
+@Value
 public final class TokenImpl implements Token {
   @NonNull
-  @Getter
   String regex;
   List<Encoding> encodings = new ArrayList<>();
   List<Decoding> decodings = new ArrayList<>();

src/main/java/io/github/noncat_lang/internal/ValuesImpl.java

@@ -0,0 +1,36 @@
+package io.github.noncat_lang.internal;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+import io.github.noncat_lang.Values;
+import lombok.Value;
+
+@Value(staticConstructor = "of")
+public final class ValuesImpl implements Values {
+  Map<String, String> data = new HashMap<>();
+
+  @Override
+  public Values set(String field, String value) {
+    data.put(field, value);
+    return this;
+  }
+
+  @Override
+  public Values setAll(Map<String, String> values) {
+    data.putAll(values);
+    return this;
+  }
+
+  @Override
+  public Optional<String> get(String field) {
+    return Optional.ofNullable(data.get(field));
+  }
+
+  @Override
+  public int size() {
+    return data.size();
+  }
+
+}

src/test/java/io/github/noncat_lang/TemplateTest.java

@@ -22,7 +22,7 @@ void formatSimple() {
     Token token = Token.of("[a-zA-Z]+");
     Template template = Template.of("Hello ${world}!").withToken("world", token);
     // when
-    Map<String, String> values = Map.of("world", "LangSec");
+    Values values = Values.of("world", "LangSec");
     String result = template.format(values);
     // then
     assertThat(result).isEqualTo("Hello LangSec!");
@@ -44,7 +44,7 @@ void unparse(String regex, String templateString, String field, String value, St
     Token token = Token.of(regex);
     Template template = Template.of(templateString).withToken(field, token);
     // when
-    Map<String, String> values = Map.of(field, value);
+    Values values = Values.of(field, value);
     String result = template.unparse(values);
     // then
     assertThat(result).isEqualTo(expected);
@@ -57,9 +57,9 @@ void parse(String regex, String templateString, String field, String expected, S
     Token token = Token.of(regex);
     Template template = Template.of(templateString).withToken(field, token);
     // when
-    Map<String, String> result = template.parse(value);
+    Values result = template.parse(value);
     // then
-    assertThat(result).containsEntry(field, expected);
+    assertThat(result.get(field)).hasValue(expected);
   }
 
   @Test
@@ -68,7 +68,7 @@ void unparseMultipleFields() {
     Token token = Token.of("[a-zA-Z]+");
     Template template = Template.of("${a}, ${b}!").withToken("a", token).withToken("b", token);
     // when
-    Map<String, String> values = Map.of("a", "foo", "b", "bar");
+    Values values = Values.of(Map.of("a", "foo", "b", "bar"));
     String result = template.unparse(values);
     // then
     assertThat(result).isEqualTo("foo, bar!");
@@ -80,7 +80,7 @@ void unparseWithEncoding() {
     Token token = Token.of("'[a-zA-Z]+'").withEncoding(Encoding.of(".+", "'$0'"));
     Template template = Template.of("Hello ${world}!").withToken("world", token);
     // when
-    Map<String, String> values = Map.of("world", "LangSec");
+    Values values = Values.of("world", "LangSec");
     String result = template.unparse(values);
     // then
     assertThat(result).isEqualTo("Hello 'LangSec'!");
@@ -92,9 +92,10 @@ void parseMultipleFields() {
     Token token = Token.of("[a-zA-Z]+");
     Template template = Template.of("${a}, ${b}!").withToken("a", token).withToken("b", token);
     // when
-    Map<String, String> result = template.parse("foo, bar!");
+    Values result = template.parse("foo, bar!");
     // then
-    assertThat(result).containsEntry("a", "foo").containsEntry("b", "bar");
+    assertThat(result.get("a")).hasValue("foo");
+    assertThat(result.get("b")).hasValue("bar");
   }
 
   @Test
@@ -103,23 +104,23 @@ void parseWithDecoding() {
     Token token = Token.of("'[a-zA-Z]+'").withDecoding(Decoding.of("'", ""));
     Template template = Template.of("Hello ${world}!").withToken("world", token);
     // when
-    Map<String, String> result = template.parse("Hello 'LangSec'!");
+    Values result = template.parse("Hello 'LangSec'!");
     // then
-    assertThat(result).containsEntry("world", "LangSec");
+    assertThat(result.get("world")).hasValue("LangSec");
   }
 
   @Test
   void unparseWithMissingToken() {
     Template template = Template.of("${any}");
-    Map<String, String> values = Map.of("any", "any");
+    Values values = Values.of("any", "any");
     assertThatThrownBy(() -> template.unparse(values)).isExactlyInstanceOf(MissingTokenException.class)
         .hasMessage("Token for field 'any' is missing");
   }
 
   @Test
   void unparseWithMissingValue() {
     Template template = Template.of("${any}").withToken("any", Token.of("[a-z]+"));
-    Map<String, String> values = Map.of();
+    Values values = Values.of();
     assertThatThrownBy(() -> template.unparse(values)).isExactlyInstanceOf(MissingValueException.class)
         .hasMessage("Value for field 'any' is missing");
   }

src/test/java/io/github/noncat_lang/ValuesTest.java

@@ -0,0 +1,65 @@
+package io.github.noncat_lang;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Map;
+
+import org.junit.jupiter.api.Test;
+
+class ValuesTest {
+
+  @Test
+  void empty() {
+    // given
+    // when
+    Values values = Values.of();
+    // then
+    assertThat(values.size()).isEqualTo(0);
+  }
+
+  @Test
+  void OptionalEmptyWhenFieldNotFound() {
+    // given
+    // when
+    Values values = Values.create();
+    // then
+    assertThat(values.get("nope")).isEmpty();
+  }
+
+  void initializedWithData() {
+    // given
+    // when
+    Values values = Values.of("foo", "bar");
+    // then
+    assertThat(values.get("foo")).hasValue("bar");
+  }
+
+  void initializedFromMap() {
+    // given
+    // when
+    Values values = Values.of(Map.of("foo", "bar"));
+    // then
+    assertThat(values.get("foo")).hasValue("bar");
+  }
+
+  @Test
+  void setData() {
+    // given
+    Values values = Values.of();
+    // when
+    values.set("foo", "bar");
+    // then
+    assertThat(values.get("foo")).hasValue("bar");
+  }
+
+  @Test
+  void setDataFromMap() {
+    // given
+    Values values = Values.of();
+    // when
+    values.setAll(Map.of("foo", "bar"));
+    // then
+    assertThat(values.get("foo")).hasValue("bar");
+  }
+
+}