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

56.52

/src/main/java/ch/jalu/wordeval/evaluators/impl/AllVowelsAlphabetically.java

package ch.jalu.wordeval.evaluators.impl;

import ch.jalu.wordeval.dictionary.Word;
import ch.jalu.wordeval.evaluators.PostEvaluator;
import ch.jalu.wordeval.evaluators.export.EvaluatorExportUtil;
import ch.jalu.wordeval.evaluators.processing.EvaluatorCollection;
import ch.jalu.wordeval.evaluators.result.WordGroupWithKey;
import ch.jalu.wordeval.evaluators.result.WordWithKey;
import ch.jalu.wordeval.language.Language;
import ch.jalu.wordeval.language.LetterType;
import com.google.common.collect.ListMultimap;
import lombok.Getter;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * Finds words with all vowels that appear alphabetically, such as "arbeidsonrust".
 */
public class AllVowelsAlphabetically implements PostEvaluator {

  private final List<String> vowels;
  @Getter
  private final List<WordGroupWithKey> results = new ArrayList<>();

  public AllVowelsAlphabetically(Language language) {
    vowels = language.getVowels();
  }

  @Override
  public void evaluate(EvaluatorCollection evaluators) {
    VowelCount vowelCount = evaluators.getWordEvaluatorOrThrow(VowelCount.class,
        vc -> vc.getLetterType() == LetterType.VOWELS);

    List<WordGroupWithKey> wordGroupsByKey = vowelCount.getResults().stream()
        .filter(entry -> entry.key().length() > 1)
        .filter(entry -> hasVowelsAlphabetically(entry.word().getWithoutAccents()))
        .collect(Collectors.groupingBy(WordWithKey::key,
            Collectors.mapping(WordWithKey::word, Collectors.toSet())))
        .entrySet().stream()
        .map(e -> new WordGroupWithKey(e.getValue(), e.getKey()))
        .toList();

    results.addAll(wordGroupsByKey);
  }

  private boolean hasVowelsAlphabetically(String word) {
    int idx = 0;
    String curVowel = vowels.get(idx);
    for (int i = 0; i < word.length(); ++i) {
      String str = word.substring(i, i + 1);
      if (vowels.contains(str)) {
        if (str.equals(curVowel)) {
          idx++;
          curVowel = idx >= vowels.size() ? null : vowels.get(idx);
        } else {
          return false;
        }
      }
    }
    return true;
  }

  @Override
  public ListMultimap<Object, Object> getTopResults(int topScores, int maxLimit) {
    Comparator<WordGroupWithKey> comparator = Comparator.comparingInt((WordGroupWithKey group) -> group.key().length())
        .reversed(); // todo: unit test

    List<WordGroupWithKey> sortedResult = results.stream()
        .sorted(comparator)
        .toList();

    Set<Integer> uniqueValues = new HashSet<>();
    ListMultimap<Object, Object> filteredResults = EvaluatorExportUtil.newListMultimap();
    for (WordGroupWithKey wordGroup : sortedResult) {
      int score = wordGroup.key().length();
      if (uniqueValues.add(score) && uniqueValues.size() > topScores) {
        break;
      }
      List<String> wordList = wordGroup.words().stream()
          .map(Word::getRaw)
          .toList();
      filteredResults.put(wordGroup.key(), wordList);
      if (filteredResults.size() >= maxLimit) {
        break;
      }
    }

    return filteredResults;
  }

  @Override
  public String getId() {
    return "vowels.alphabetical";
  }
}

1	package ch.jalu.wordeval.evaluators.impl;
2
3	import ch.jalu.wordeval.dictionary.Word;
4	import ch.jalu.wordeval.evaluators.PostEvaluator;
5	import ch.jalu.wordeval.evaluators.export.EvaluatorExportUtil;
6	import ch.jalu.wordeval.evaluators.processing.EvaluatorCollection;
7	import ch.jalu.wordeval.evaluators.result.WordGroupWithKey;
8	import ch.jalu.wordeval.evaluators.result.WordWithKey;
9	import ch.jalu.wordeval.language.Language;
10	import ch.jalu.wordeval.language.LetterType;
11	import com.google.common.collect.ListMultimap;
12	import lombok.Getter;
13
14	import java.util.ArrayList;
15	import java.util.Comparator;
16	import java.util.HashSet;
17	import java.util.List;
18	import java.util.Set;
19	import java.util.stream.Collectors;
20
21	/**
22	* Finds words with all vowels that appear alphabetically, such as "arbeidsonrust".
23	*/
24	public class AllVowelsAlphabetically implements PostEvaluator {
25
26	private final List<String> vowels;
27	@Getter	5✔
28	private final List<WordGroupWithKey> results = new ArrayList<>();
29
30	public AllVowelsAlphabetically(Language language) {	2✔
31	vowels = language.getVowels();	4✔
32	}	1✔
33
34	@Override
35	public void evaluate(EvaluatorCollection evaluators) {
36	VowelCount vowelCount = evaluators.getWordEvaluatorOrThrow(VowelCount.class,	6✔
37	vc -> vc.getLetterType() == LetterType.VOWELS);	7!
38
39	List<WordGroupWithKey> wordGroupsByKey = vowelCount.getResults().stream()	4✔
40	.filter(entry -> entry.key().length() > 1)	12✔
41	.filter(entry -> hasVowelsAlphabetically(entry.word().getWithoutAccents()))	9✔
42	.collect(Collectors.groupingBy(WordWithKey::key,	3✔
43	Collectors.mapping(WordWithKey::word, Collectors.toSet())))	2✔
44	.entrySet().stream()	3✔
45	.map(e -> new WordGroupWithKey(e.getValue(), e.getKey()))	11✔
46	.toList();	2✔
47
48	results.addAll(wordGroupsByKey);	5✔
49	}	1✔
50
51	private boolean hasVowelsAlphabetically(String word) {
52	int idx = 0;	2✔
53	String curVowel = vowels.get(idx);	6✔
54	for (int i = 0; i < word.length(); ++i) {	8✔
55	String str = word.substring(i, i + 1);	7✔
56	if (vowels.contains(str)) {	5✔
57	if (str.equals(curVowel)) {	4✔
58	idx++;	1✔
59	curVowel = idx >= vowels.size() ? null : vowels.get(idx);	12!
60	} else {
61	return false;	2✔
62	}
63	}
64	}
65	return true;	2✔
66	}
67
68	@Override
69	public ListMultimap<Object, Object> getTopResults(int topScores, int maxLimit) {
NEW 70	Comparator<WordGroupWithKey> comparator = Comparator.comparingInt((WordGroupWithKey group) -> group.key().length())	×
71	.reversed(); // todo: unit test	×
72
73	List<WordGroupWithKey> sortedResult = results.stream()	×
74	.sorted(comparator)	×
75	.toList();	×
76
77	Set<Integer> uniqueValues = new HashSet<>();	×
78	ListMultimap<Object, Object> filteredResults = EvaluatorExportUtil.newListMultimap();	×
79	for (WordGroupWithKey wordGroup : sortedResult) {	×
NEW 80	int score = wordGroup.key().length();	×
81	if (uniqueValues.add(score) && uniqueValues.size() > topScores) {	×
82	break;	×
83	}
NEW 84	List<String> wordList = wordGroup.words().stream()	×
85	.map(Word::getRaw)	×
86	.toList();	×
NEW 87	filteredResults.put(wordGroup.key(), wordList);	×
88	if (filteredResults.size() >= maxLimit) {	×
89	break;	×
90	}
91	}	×
92
93	return filteredResults;	×
94	}
95
96	@Override
97	public String getId() {
98	return "vowels.alphabetical";	×
99	}
100	}

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