From cf5338f07eb3c325e23a8d56819a28f091ff28ba Mon Sep 17 00:00:00 2001 From: swarren12 <33803336+swarren12@users.noreply.github.com> Date: Wed, 1 Dec 2021 12:28:03 +0000 Subject: [PATCH] Add convenience method for copying out dsl arguments --- .../com/lmax/simpledsl/api/DslParams.java | 10 +- .../com/lmax/simpledsl/internal/DslParam.java | 2 + .../simpledsl/internal/DslParamsImpl.java | 17 +++ .../internal/RepeatingParamGroup.java | 10 ++ .../internal/RepeatingParamValues.java | 10 ++ .../simpledsl/internal/SimpleDslParam.java | 6 + .../simpledsl/internal/DslParamsImplTest.java | 118 ++++++++++++++++++ 7 files changed, 171 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/lmax/simpledsl/api/DslParams.java b/src/main/java/com/lmax/simpledsl/api/DslParams.java index f1f64c6..8158705 100644 --- a/src/main/java/com/lmax/simpledsl/api/DslParams.java +++ b/src/main/java/com/lmax/simpledsl/api/DslParams.java @@ -52,6 +52,14 @@ public interface DslParams extends DslValues */ RepeatingGroup[] valuesAsGroup(String groupName); + /** + * Create a new {@literal array} of arguments that can be re-parsed into a new instance of {@link DslParams}. + * + * @param args the name of the arguments to copy + * @return the new {@literal array} of parameters + */ + String[] copyArgs(String... args); + /** * Create new {@link DslParams}. * @@ -64,7 +72,6 @@ static DslParams create(String[] args, DslArg... arguments) return new DslParamsParser().parse(args, arguments); } - /** * A shorthand way to create a {@link DslParams} instance that accepts a single required parameter and return the * value that was supplied for that parameter. @@ -79,5 +86,4 @@ static String getSingleRequiredParamValue(final String[] args, final String requ .parse(args, new RequiredArg(requiredParamName)) .value(requiredParamName); } - } diff --git a/src/main/java/com/lmax/simpledsl/internal/DslParam.java b/src/main/java/com/lmax/simpledsl/internal/DslParam.java index b029559..6c91399 100644 --- a/src/main/java/com/lmax/simpledsl/internal/DslParam.java +++ b/src/main/java/com/lmax/simpledsl/internal/DslParam.java @@ -25,4 +25,6 @@ abstract class DslParam abstract RepeatingParamGroup asRepeatingParamGroup(); abstract boolean hasValue(); + + abstract String[] rawArgs(); } diff --git a/src/main/java/com/lmax/simpledsl/internal/DslParamsImpl.java b/src/main/java/com/lmax/simpledsl/internal/DslParamsImpl.java index 2599eed..23e05a1 100644 --- a/src/main/java/com/lmax/simpledsl/internal/DslParamsImpl.java +++ b/src/main/java/com/lmax/simpledsl/internal/DslParamsImpl.java @@ -19,8 +19,13 @@ import com.lmax.simpledsl.api.DslParams; import com.lmax.simpledsl.api.RepeatingGroup; +import java.util.HashSet; import java.util.Map; import java.util.Optional; +import java.util.Set; + +import static java.util.Arrays.asList; +import static java.util.Arrays.stream; /** * The internal implementation of {@link DslParams}. @@ -58,6 +63,18 @@ public RepeatingGroup[] valuesAsGroup(final String groupName) return repeatingParamGroup.values(); } + @Override + public String[] copyArgs(final String... argsToCopy) + { + final Set uniqueArgsToCopy = new HashSet<>(asList(argsToCopy)); + return stream(args) + .map(DslArg::getName) + .filter(uniqueArgsToCopy::contains) + .map(this::getDslParam) + .flatMap(param -> stream(param.rawArgs())) + .toArray(String[]::new); + } + @Override public boolean hasValue(final String name) { diff --git a/src/main/java/com/lmax/simpledsl/internal/RepeatingParamGroup.java b/src/main/java/com/lmax/simpledsl/internal/RepeatingParamGroup.java index f7a50f0..7ba14e1 100644 --- a/src/main/java/com/lmax/simpledsl/internal/RepeatingParamGroup.java +++ b/src/main/java/com/lmax/simpledsl/internal/RepeatingParamGroup.java @@ -20,6 +20,8 @@ import java.util.List; +import static java.util.Arrays.stream; + class RepeatingParamGroup extends DslParam { private final String name; @@ -64,4 +66,12 @@ public boolean hasValue() { return !values.isEmpty(); } + + @Override + String[] rawArgs() + { + return values.stream() + .flatMap(val -> stream(val.rawArgs())) + .toArray(String[]::new); + } } diff --git a/src/main/java/com/lmax/simpledsl/internal/RepeatingParamValues.java b/src/main/java/com/lmax/simpledsl/internal/RepeatingParamValues.java index eb52357..3916d0a 100644 --- a/src/main/java/com/lmax/simpledsl/internal/RepeatingParamValues.java +++ b/src/main/java/com/lmax/simpledsl/internal/RepeatingParamValues.java @@ -6,6 +6,8 @@ import java.util.List; import java.util.Map; +import static java.util.Arrays.stream; + class RepeatingParamValues implements RepeatingGroup { private final DslArg[] dslArgs; @@ -47,4 +49,12 @@ private List getValues(final String name) { return name != null ? valuesByName.get(name.toLowerCase()) : null; } + + public String[] rawArgs() + { + return stream(dslArgs) + .flatMap(arg -> getValues(arg.getName()).stream() + .map(val -> arg.getName() + ": " + val)) + .toArray(String[]::new); + } } diff --git a/src/main/java/com/lmax/simpledsl/internal/SimpleDslParam.java b/src/main/java/com/lmax/simpledsl/internal/SimpleDslParam.java index 50ab351..98cb419 100644 --- a/src/main/java/com/lmax/simpledsl/internal/SimpleDslParam.java +++ b/src/main/java/com/lmax/simpledsl/internal/SimpleDslParam.java @@ -53,6 +53,12 @@ boolean hasValue() return !values.isEmpty(); } + @Override + String[] rawArgs() + { + return values.stream().map(val -> name + ": " + val).toArray(String[]::new); + } + /** * Get the value for this parameter. If multiple values are allowed, use {@link #getValues()} instead. * diff --git a/src/test/java/com/lmax/simpledsl/internal/DslParamsImplTest.java b/src/test/java/com/lmax/simpledsl/internal/DslParamsImplTest.java index d1899ec..ba10f90 100644 --- a/src/test/java/com/lmax/simpledsl/internal/DslParamsImplTest.java +++ b/src/test/java/com/lmax/simpledsl/internal/DslParamsImplTest.java @@ -17,11 +17,15 @@ import com.lmax.simpledsl.api.DslArg; import com.lmax.simpledsl.api.DslParams; +import com.lmax.simpledsl.api.OptionalArg; +import com.lmax.simpledsl.api.RepeatingArgGroup; +import com.lmax.simpledsl.api.RequiredArg; import org.junit.jupiter.api.Test; import java.math.BigDecimal; import java.util.Collections; import java.util.HashMap; +import java.util.List; import java.util.Map; import java.util.Optional; @@ -263,4 +267,118 @@ public void shouldReturnOptionalListWhenMultipleParameterValueIsSupplied() assertEquals(Optional.of(asList("value1", "value2")), params.valuesAsOptional("a")); } + + @Test + public void shouldCopyArguments() + { + final DslArg[] args = {new RequiredArg("a"), new RequiredArg("b"), new RequiredArg("c")}; + + final SimpleDslParam aParam = new SimpleDslParam("a", asList("value1", "value2")); + final SimpleDslParam bParam = new SimpleDslParam("b", singletonList("value3")); + final SimpleDslParam cParam = new SimpleDslParam("c", singletonList("value4")); + + final Map rawParams = new HashMap<>(); + rawParams.put("a", aParam); + rawParams.put("b", bParam); + rawParams.put("c", cParam); + + final DslParams params = new DslParamsImpl(args, rawParams); + + assertArrayEquals(new String[]{"a: value1", "a: value2", "b: value3"}, params.copyArgs("a", "b")); + } + + @Test + public void shouldCopyArgumentWhenOptionalArgumentWasNotSupplied() + { + final DslArg[] args = {new RequiredArg("a"), new RequiredArg("b"), new OptionalArg("c")}; + + final SimpleDslParam aParam = new SimpleDslParam("a", asList("value1", "value2")); + final SimpleDslParam bParam = new SimpleDslParam("b", singletonList("value3")); + final SimpleDslParam cParam = new SimpleDslParam("c", emptyList()); + + final Map rawParams = new HashMap<>(); + rawParams.put("a", aParam); + rawParams.put("b", bParam); + rawParams.put("c", cParam); + + final DslParams params = new DslParamsImpl(args, rawParams); + + assertArrayEquals(new String[]{"a: value1", "a: value2"}, params.copyArgs("a", "c")); + } + + @Test + public void shouldCopyArgumentIncludingARepeatingGroup() + { + final RequiredArg groupArg = new RequiredArg("c"); + final DslArg[] args = { + new RequiredArg("a"), + new RequiredArg("b"), + new RepeatingArgGroup(groupArg) + }; + + final SimpleDslParam aParam = new SimpleDslParam("a", asList("value1", "value2")); + final SimpleDslParam bParam = new SimpleDslParam("b", singletonList("value3")); + final RepeatingParamGroup gParam = new RepeatingParamGroup("c", singletonList( + new RepeatingParamValues(new DslArg[]{groupArg}, Collections.singletonMap("c", singletonList("value3"))) + )); + + final Map rawParams = new HashMap<>(); + rawParams.put("a", aParam); + rawParams.put("b", bParam); + rawParams.put("c", gParam); + + final DslParams params = new DslParamsImpl(args, rawParams); + + assertArrayEquals(new String[]{"a: value1", "a: value2", "c: value3"}, params.copyArgs("a", "c")); + } + + @Test + public void shouldCopyArgumentIncludingARepeatingGroupWithMultipleArguments() + { + final RequiredArg groupArg = new RequiredArg("c"); + final RequiredArg otherGroupArg = new RequiredArg("d"); + final DslArg[] args = { + new RequiredArg("a"), + new RequiredArg("b"), + new RepeatingArgGroup(groupArg, otherGroupArg) + }; + + final SimpleDslParam aParam = new SimpleDslParam("a", asList("value1", "value2")); + final SimpleDslParam bParam = new SimpleDslParam("b", singletonList("value3")); + + final Map> rawGroupParams = new HashMap<>(); + rawGroupParams.put("c", singletonList("value3")); + rawGroupParams.put("d", asList("value4", "value5")); + final RepeatingParamGroup gParam = new RepeatingParamGroup("c", singletonList( + new RepeatingParamValues(new DslArg[]{groupArg, otherGroupArg}, rawGroupParams) + )); + + final Map rawParams = new HashMap<>(); + rawParams.put("a", aParam); + rawParams.put("b", bParam); + rawParams.put("c", gParam); + + final DslParams params = new DslParamsImpl(args, rawParams); + + assertArrayEquals(new String[]{"a: value1", "a: value2", "c: value3", "d: value4", "d: value5"}, params.copyArgs("a", "c")); + } + + @Test + public void shouldCopyArgumentsOnlyOnceEvenIfSpecifiedMultipleTimes() + { + final DslArg[] args = {new RequiredArg("a"), new RequiredArg("b"), new RequiredArg("c")}; + + final SimpleDslParam aParam = new SimpleDslParam("a", asList("value1", "value2")); + final SimpleDslParam bParam = new SimpleDslParam("b", singletonList("value3")); + final SimpleDslParam cParam = new SimpleDslParam("c", emptyList()); + + final Map rawParams = new HashMap<>(); + rawParams.put("a", aParam); + rawParams.put("b", bParam); + rawParams.put("c", cParam); + + final DslParams params = new DslParamsImpl(args, rawParams); + + assertArrayEquals(new String[]{"a: value1", "a: value2"}, params.copyArgs("a", "a", "a")); + } }