14562991048

Committed 20 Apr 2025 08:19PM UTC coverage: 55.116% (+1.7%) from 53.367%

Build # 14562991048

Build Type

push

github

Committed by

ljacqu

Commit Message

Merge remote-tracking branch 'origin/master' into dependencies

Run Details

269 of 568 branches covered (47.36%)

212 of 313 new or added lines in 36 files covered. (67.73%)

6 existing lines in 5 files now uncovered.

738 of 1339 relevant lines covered (55.12%)

3.27 hits per line

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

93.02

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

package ch.jalu.wordeval.evaluators.processing;

import ch.jalu.wordeval.dictionary.Word;
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.Service;

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

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

/**
 * Service for evaluators.
 */
@Slf4j
@Service
public class EvaluatorService {

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

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

  /**
   * Processes all words with the given evaluators.
   *
   * @param evaluators the evaluators
   * @param words the words the evaluators should process
   */
  public void processAllWords(EvaluatorCollection evaluators, Collection<Word> words) {
    evaluators.allWordsEvaluators().forEach(evaluator -> evaluator.evaluate(words));
    evaluators.postEvaluators().forEach(evaluator -> evaluator.evaluate(evaluators));
  }

  /**
   * 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;

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

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

ljacqu / wordeval / 14562991048

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