14560448446

Committed 20 Apr 2025 02:30PM UTC coverage: 55.102% (+1.4%) from 53.745%

Build # 14560448446

Build Type

push

github

Committed by

ljacqu

Commit Message

Springify processing of evaluators

Run Details

291 of 596 branches covered (48.83%)

51 of 63 new or added lines in 8 files covered. (80.95%)

57 existing lines in 6 files now uncovered.

756 of 1372 relevant lines covered (55.1%)

3.13 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.37

/src/main/java/ch/jalu/wordeval/evaluators/processing/EvaluatorInitializer.java

package ch.jalu.wordeval.evaluators.processing;

import ch.jalu.wordeval.evaluators.AllWordsEvaluator;
import ch.jalu.wordeval.evaluators.PostEvaluator;
import ch.jalu.wordeval.language.Language;
import lombok.extern.slf4j.Slf4j;
import org.reflections.Reflections;
import org.reflections.scanners.Scanners;
import org.springframework.stereotype.Component;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;

import static com.google.common.collect.Lists.newArrayList;

/**
 * Service for initializing all available evaluators.
 */
@Slf4j
@Component
public class EvaluatorInitializer {

  private static final String EVALUATOR_PACKAGE = "ch.jalu.wordeval.evaluators";

  private final Reflections reflections;

  /**
   * Constructor.
   */
  public EvaluatorInitializer() {
    this.reflections = new Reflections(EVALUATOR_PACKAGE, Scanners.SubTypes);
  }

  /**
   * Creates all possible evaluators from the evaluator package, {@link #EVALUATOR_PACKAGE}, for the given language.
   */
  public EvaluatorCollection createAllEvaluators(Language language) {
    List<AllWordsEvaluator> allWordsEvaluators = new ArrayList<>();
    List<PostEvaluator> postEvaluators = new ArrayList<>();
    ObjectCreator creator = new ObjectCreator(language);

    reflections.getSubTypesOf(AllWordsEvaluator.class).stream()
        .filter(this::isInstantiableClass)
        .forEach(clz -> creator.createObjectsAndSaveToList(clz, allWordsEvaluators));

    reflections.getSubTypesOf(PostEvaluator.class).stream()
        .filter(this::isInstantiableClass)
        .forEach(clz -> creator.createObjectsAndSaveToList(clz, postEvaluators));

    return new EvaluatorCollection(allWordsEvaluators, postEvaluators);
  }

  private boolean isInstantiableClass(Class<?> clazz) {
    return !clazz.isInterface() && !Modifier.isAbstract(clazz.getModifiers());
  }

  private static final class ObjectCreator {

    private final Language[] languageArray;
    private final Locale[] localeArray;

    ObjectCreator(Language language) {
      this.languageArray = new Language[]{ language };
      this.localeArray = new Locale[]{ language.getLocale() };
    }

    @SuppressWarnings("unchecked")
    <T> void createObjectsAndSaveToList(Class<T> clazz, List<? super T> list) {
      log.trace("Creating instances of class '{}'", clazz.getSimpleName());
      Constructor<T> constructor = (Constructor<T>) clazz.getDeclaredConstructors()[0];
      createAndAddObjects(list, constructor, newArrayList(constructor.getParameterTypes()), new ArrayList<>());
    }

    private <T> void createAndAddObjects(List<? super T> instancesList, Constructor<T> constructor,
                                         List<Class<?>> unresolvedDependencies, List<Object> resolvedDependencies) {
      if (unresolvedDependencies.isEmpty()) {
        instancesList.add(newInstance(constructor, resolvedDependencies));
      } else {
        Class<?> dependencyToResolve = unresolvedDependencies.removeFirst();
        Object[] resolvedDependencyValues = resolveDependency(dependencyToResolve);
        for (Object curDependency : resolvedDependencyValues) {
          // Copy lists so each call has its own copy
          List<Class<?>> curUnresolvedDependencies = new ArrayList<>(unresolvedDependencies);
          List<Object> curResolvedDependencies = new ArrayList<>(resolvedDependencies);
          curResolvedDependencies.add(curDependency);
          createAndAddObjects(instancesList, constructor, curUnresolvedDependencies, curResolvedDependencies);
        }
      }
    }

    private Object[] resolveDependency(Class<?> clz) {
      if (Language.class == clz) {
        return languageArray;
      } else if (clz.isEnum()) {
        return clz.getEnumConstants();
      } else if (Locale.class == clz) {
        return localeArray;
      }
      throw new IllegalStateException("Unknown what value to provide for '" + clz + "'");
    }

    private static <T> T newInstance(Constructor<T> constructor, List<Object> arguments) {
      try {
        return constructor.newInstance(arguments.toArray());
      } catch (IllegalAccessException | InstantiationException | InvocationTargetException e) {
        throw new IllegalStateException(e);
      }
    }
  }
}

1	package ch.jalu.wordeval.evaluators.processing;
2
3	import ch.jalu.wordeval.evaluators.AllWordsEvaluator;
4	import ch.jalu.wordeval.evaluators.PostEvaluator;
5	import ch.jalu.wordeval.language.Language;
6	import lombok.extern.slf4j.Slf4j;
7	import org.reflections.Reflections;
8	import org.reflections.scanners.Scanners;
9	import org.springframework.stereotype.Component;
10
11	import java.lang.reflect.Constructor;
12	import java.lang.reflect.InvocationTargetException;
13	import java.lang.reflect.Modifier;
14	import java.util.ArrayList;
15	import java.util.List;
16	import java.util.Locale;
17
18	import static com.google.common.collect.Lists.newArrayList;
19
20	/**
21	* Service for initializing all available evaluators.
22	*/
23	@Slf4j	4✔
24	@Component
25	public class EvaluatorInitializer {
26
27	private static final String EVALUATOR_PACKAGE = "ch.jalu.wordeval.evaluators";
28
29	private final Reflections reflections;
30
31	/**
32	* Constructor.
33	*/
34	public EvaluatorInitializer() {	2✔
35	this.reflections = new Reflections(EVALUATOR_PACKAGE, Scanners.SubTypes);	12✔
36	}	1✔
37
38	/**
39	* Creates all possible evaluators from the evaluator package, {@link #EVALUATOR_PACKAGE}, for the given language.
40	*/
41	public EvaluatorCollection createAllEvaluators(Language language) {
42	List<AllWordsEvaluator> allWordsEvaluators = new ArrayList<>();	4✔
43	List<PostEvaluator> postEvaluators = new ArrayList<>();	4✔
44	ObjectCreator creator = new ObjectCreator(language);	5✔
45
46	reflections.getSubTypesOf(AllWordsEvaluator.class).stream()	7✔
47	.filter(this::isInstantiableClass)	4✔
48	.forEach(clz -> creator.createObjectsAndSaveToList(clz, allWordsEvaluators));	6✔
49
50	reflections.getSubTypesOf(PostEvaluator.class).stream()	7✔
51	.filter(this::isInstantiableClass)	4✔
52	.forEach(clz -> creator.createObjectsAndSaveToList(clz, postEvaluators));	6✔
53
54	return new EvaluatorCollection(allWordsEvaluators, postEvaluators);	6✔
55	}
56
57	private boolean isInstantiableClass(Class<?> clazz) {
58	return !clazz.isInterface() && !Modifier.isAbstract(clazz.getModifiers());	11!
59	}
60
61	private static final class ObjectCreator {
62
63	private final Language[] languageArray;
64	private final Locale[] localeArray;
65
66	ObjectCreator(Language language) {	2✔
67	this.languageArray = new Language[]{ language };	8✔
68	this.localeArray = new Locale[]{ language.getLocale() };	9✔
69	}	1✔
70
71	@SuppressWarnings("unchecked")
72	<T> void createObjectsAndSaveToList(Class<T> clazz, List<? super T> list) {
73	log.trace("Creating instances of class '{}'", clazz.getSimpleName());	5✔
74	Constructor<T> constructor = (Constructor<T>) clazz.getDeclaredConstructors()[0];	5✔
75	createAndAddObjects(list, constructor, newArrayList(constructor.getParameterTypes()), new ArrayList<>());	10✔
76	}	1✔
77
78	private <T> void createAndAddObjects(List<? super T> instancesList, Constructor<T> constructor,
79	List<Class<?>> unresolvedDependencies, List<Object> resolvedDependencies) {
80	if (unresolvedDependencies.isEmpty()) {	3✔
81	instancesList.add(newInstance(constructor, resolvedDependencies));	7✔
82	} else {
83	Class<?> dependencyToResolve = unresolvedDependencies.removeFirst();	4✔
84	Object[] resolvedDependencyValues = resolveDependency(dependencyToResolve);	4✔
85	for (Object curDependency : resolvedDependencyValues) {	16✔
86	// Copy lists so each call has its own copy
87	List<Class<?>> curUnresolvedDependencies = new ArrayList<>(unresolvedDependencies);	5✔
88	List<Object> curResolvedDependencies = new ArrayList<>(resolvedDependencies);	5✔
89	curResolvedDependencies.add(curDependency);	4✔
90	createAndAddObjects(instancesList, constructor, curUnresolvedDependencies, curResolvedDependencies);	6✔
91	}
92	}
93	}	1✔
94
95	private Object[] resolveDependency(Class<?> clz) {
96	if (Language.class == clz) {	3✔
97	return languageArray;	3✔
98	} else if (clz.isEnum()) {	3!
99	return clz.getEnumConstants();	3✔
NEW 100	} else if (Locale.class == clz) {	×
NEW 101	return localeArray;	×
102	}
NEW 103	throw new IllegalStateException("Unknown what value to provide for '" + clz + "'");	×
104	}
105
106	private static <T> T newInstance(Constructor<T> constructor, List<Object> arguments) {
107	try {
108	return constructor.newInstance(arguments.toArray());	5✔
NEW 109	} catch (IllegalAccessException \| InstantiationException \| InvocationTargetException e) {	×
NEW 110	throw new IllegalStateException(e);	×
111	}
112	}
113	}
114	}

ljacqu / wordeval / 14560448446

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous