14540892325

Committed 18 Apr 2025 07:50PM UTC coverage: 51.4% (-12.1%) from 63.456%

Build # 14540892325

Build Type

push

github

Committed by

ljacqu

Commit Message

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

Run Details

239 of 546 branches covered (43.77%)

93 of 383 new or added lines in 27 files covered. (24.28%)

5 existing lines in 4 files now uncovered.

679 of 1321 relevant lines covered (51.4%)

3.0 hits per line

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

55.56

/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.processing.AllWordsEvaluatorProvider;
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.ArrayListMultimap;
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(AllWordsEvaluatorProvider allWordsEvaluatorProvider) {
    VowelCount vowelCount =
        allWordsEvaluatorProvider.getEvaluator(VowelCount.class, vc -> vc.getLetterType() == LetterType.VOWELS);

    List<WordGroupWithKey> wordGroupsByKey = vowelCount.getResults().stream()
        .filter(entry -> hasVowelsAlphabetically(entry.getWord().getWithoutAccents()))
        .collect(Collectors.groupingBy(WordWithKey::getKey,
            Collectors.mapping(WordWithKey::getWord, 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.getWords().size())
        .thenComparing(group -> group.getKey().length())
        .reversed(); // todo: unit test

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

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

    return filteredResults;
  }
}

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.processing.AllWordsEvaluatorProvider;
6	import ch.jalu.wordeval.evaluators.result.WordGroupWithKey;
7	import ch.jalu.wordeval.evaluators.result.WordWithKey;
8	import ch.jalu.wordeval.language.Language;
9	import ch.jalu.wordeval.language.LetterType;
10	import com.google.common.collect.ArrayListMultimap;
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(AllWordsEvaluatorProvider allWordsEvaluatorProvider) {
36	VowelCount vowelCount =	3✔
37	allWordsEvaluatorProvider.getEvaluator(VowelCount.class, vc -> vc.getLetterType() == LetterType.VOWELS);	10!
38
39	List<WordGroupWithKey> wordGroupsByKey = vowelCount.getResults().stream()	5✔
40	.filter(entry -> hasVowelsAlphabetically(entry.getWord().getWithoutAccents()))	9✔
41	.collect(Collectors.groupingBy(WordWithKey::getKey,	3✔
42	Collectors.mapping(WordWithKey::getWord, Collectors.toSet())))	2✔
43	.entrySet().stream()	3✔
44	.map(e -> new WordGroupWithKey(e.getValue(), e.getKey()))	11✔
45	.toList();	2✔
46
47	results.addAll(wordGroupsByKey);	5✔
48	}	1✔
49
50	private boolean hasVowelsAlphabetically(String word) {
51	int idx = 0;	2✔
52	String curVowel = vowels.get(idx);	6✔
53	for (int i = 0; i < word.length(); ++i) {	8✔
54	String str = word.substring(i, i + 1);	7✔
55	if (vowels.contains(str)) {	5✔
56	if (str.equals(curVowel)) {	4✔
57	idx++;	1✔
58	curVowel = idx >= vowels.size() ? null : vowels.get(idx);	12!
59	} else {
60	return false;	2✔
61	}
62	}
63	}
64	return true;	2✔
65	}
66
67	@Override
68	public ListMultimap<Object, Object> getTopResults(int topScores, int maxLimit) {
NEW 69	Comparator<WordGroupWithKey> comparator = Comparator.comparingInt((WordGroupWithKey group) -> group.getWords().size())	×
NEW 70	.thenComparing(group -> group.getKey().length())	×
NEW 71	.reversed(); // todo: unit test	×
72
NEW 73	List<WordGroupWithKey> sortedResult = results.stream()	×
NEW 74	.sorted(comparator)	×
NEW 75	.toList();	×
76
NEW 77	Set<Integer> uniqueValues = new HashSet<>();	×
NEW 78	ListMultimap<Object, Object> filteredResults = ArrayListMultimap.create();	×
NEW 79	for (WordGroupWithKey wordGroup : sortedResult) {	×
NEW 80	int score = wordGroup.getWords().size();	×
NEW 81	if (uniqueValues.add(score) && uniqueValues.size() > topScores) {	×
NEW 82	break;	×
83	}
NEW 84	List<String> wordList = wordGroup.getWords().stream()	×
NEW 85	.map(Word::getRaw)	×
NEW 86	.toList();	×
NEW 87	filteredResults.put(score, wordList);	×
NEW 88	if (filteredResults.size() >= maxLimit) {	×
NEW 89	break;	×
90	}
NEW 91	}	×
92
NEW 93	return filteredResults;	×
94	}
95	}

ljacqu / wordeval / 14540892325

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