refactor: move duplicate code to shared location

Author: Nylle

src/main/java/com/github/nylle/javafixture/SpecimenFactory.java

@@ -20,9 +20,6 @@
 import java.lang.reflect.Type;
 import java.util.Random;
 import java.util.stream.Collectors;
-import java.util.stream.IntStream;
-
-import static java.util.stream.Collectors.toMap;
 
 public class SpecimenFactory {
 
@@ -127,11 +124,7 @@ private static <T> boolean typeParametersMatch(ClassInfo implementingClass, Spec
     }
 
     private static <T> Type[] resolveTypeArguments(SpecimenType<T> genericType, ClassInfo implementingClass) {
-        var typeParameters = IntStream.range(0, genericType.getGenericTypeArguments().length)
-                .boxed()
-                .collect(toMap(
-                        i -> genericType.getTypeParameterName(i),
-                        i -> SpecimenType.fromClass(genericType.getGenericTypeArgument(i))));
+        var typeParameters = genericType.getTypeParameterNamesAndTypes(x -> x);
 
         return implementingClass.getTypeSignature().getTypeParameters().stream()
                 .map(x -> typeParameters.getOrDefault(x.getName(), null))

src/main/java/com/github/nylle/javafixture/SpecimenType.java

@@ -14,11 +14,14 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.function.Function;
 import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
 import static java.lang.String.format;
 import static java.util.stream.Collectors.toList;
+import static java.util.stream.Collectors.toMap;
 
 public class SpecimenType<T> extends TypeCapture<T> {
 
@@ -96,6 +99,18 @@ public String getTypeParameterName(final int index) {
         return getTypeParameterNames()[index];
     }
 
+    public <A> Map<String, A> getTypeParameterNamesAndTypes(Function<SpecimenType<?>, A> f) {
+        if (!isParameterized()) {
+            return Map.of();
+        }
+
+        return IntStream.range(0, this.getGenericTypeArguments().length)
+                .boxed()
+                .collect(toMap(
+                        i -> this.getTypeParameterName(i),
+                        i -> f.apply(SpecimenType.fromClass(this.getGenericTypeArgument(i)))));
+    }
+
     public Class<?> getComponentType() {
         if (isArray()) {
             return asClass().getComponentType();

src/main/java/com/github/nylle/javafixture/specimen/GenericSpecimen.java

@@ -12,9 +12,6 @@
 import java.lang.annotation.Annotation;
 import java.util.List;
 import java.util.Map;
-import java.util.stream.IntStream;
-
-import static java.util.stream.Collectors.toMap;
 
 public class GenericSpecimen<T> implements ISpecimen<T> {
 
@@ -50,12 +47,7 @@ public GenericSpecimen(SpecimenType<T> type, Context context, SpecimenFactory sp
         this.context = context;
         this.specimenFactory = specimenFactory;
         this.instanceFactory = new InstanceFactory(specimenFactory);
-
-        this.specimens = IntStream.range(0, type.getGenericTypeArguments().length)
-                .boxed()
-                .collect(toMap(
-                        i -> type.getTypeParameterName(i),
-                        i -> specimenFactory.build(SpecimenType.fromClass(type.getGenericTypeArgument(i)))));
+        this.specimens = type.getTypeParameterNamesAndTypes(x -> specimenFactory.build(x));
     }
 
     @Override

src/test/java/com/github/nylle/javafixture/SpecimenTypeTest.java

@@ -335,6 +335,38 @@ void getTypeParameterNames() {
                 .withNoCause();
     }
 
+    @Nested
+    class GetTypeParameterNamesAndTypes {
+
+        @Test
+        void returnsEmptyMapIfNotAParametrizedType() {
+            assertThat(SpecimenType.fromClass(String.class).getTypeParameterNamesAndTypes(x -> x)).isEmpty();
+        }
+
+        @Test
+        void returnsMapOfTypeParameterNamesAndSpecimenTypes() {
+            var sut = new SpecimenType<TestObjectGeneric<String, Optional<Integer>>>() {};
+
+            var actual = sut.getTypeParameterNamesAndTypes(x -> x);
+
+            assertThat(actual).hasSize(2);
+            assertThat(actual.get("T").asClass()).isEqualTo(String.class);
+            assertThat(actual.get("U").asClass()).isEqualTo(Optional.class);
+            assertThat(actual.get("U").getGenericTypeArgument(0)).isEqualTo(Integer.class);
+        }
+
+        @Test
+        void takesAValueMapper() {
+            var sut = new SpecimenType<TestObjectGeneric<String, Optional<Integer>>>() {};
+
+            var actual = sut.getTypeParameterNamesAndTypes(x -> x.asClass());
+
+            assertThat(actual).hasSize(2);
+            assertThat(actual.get("T")).isEqualTo(String.class);
+            assertThat(actual.get("U")).isEqualTo(Optional.class);
+        }
+    }
+
     @Test
     void getComponentType() {
         assertThat(new SpecimenType<int[]>() {}.getComponentType()).isEqualTo(int.class);