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

36.36

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

package ch.jalu.wordeval.evaluators.impl;

import ch.jalu.wordeval.dictionary.Word;
import ch.jalu.wordeval.evaluators.AllWordsEvaluator;
import ch.jalu.wordeval.evaluators.export.EvaluatorExportUtil;
import ch.jalu.wordeval.evaluators.result.WordGroupWithKey;
import ch.jalu.wordeval.util.StreamUtils;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.ListMultimap;
import com.google.common.collect.Multimaps;
import com.google.common.collect.SetMultimap;
import lombok.Getter;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * Groups words which only differ in diacritics which are not considered
 * distinct letters in the language, such as {des, dés, dès} in French or
 * {schon, schön} in German.
 */
public class DiacriticHomonyms implements AllWordsEvaluator {

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

  @Override
  public void evaluate(Collection<Word> words) {
    SetMultimap<String, Word> wordsByNoAccentRep = words.stream()
        .sorted(Comparator.comparing(w -> Character.isUpperCase(w.getRaw().charAt(0))))
        .filter(StreamUtils.distinctByKey(Word::getLowercase))
        .collect(Multimaps.toMultimap(
            Word::getWithoutAccents,
            word -> word,
            HashMultimap::create));

    Multimaps.asMap(wordsByNoAccentRep).forEach((wordRep, wordsInGroup) -> {
      if (wordsInGroup.size() > 1) {
        results.add(new WordGroupWithKey(wordsInGroup, wordRep));
      }
    });
  }

  @Override
  public String getId() {
    return "group.homonymsByDiacritic";
  }

  @Override
  public ListMultimap<Object, Object> getTopResults(int topScores, int maxLimit) {
    Comparator<WordGroupWithKey> comparator = Comparator.comparingInt((WordGroupWithKey group) -> group.words().size())
        .thenComparing(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.words().size();
      if (uniqueValues.add(score) && uniqueValues.size() > topScores) {
        break;
      }
      List<String> wordList = wordGroup.words().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.AllWordsEvaluator;
5	import ch.jalu.wordeval.evaluators.export.EvaluatorExportUtil;
6	import ch.jalu.wordeval.evaluators.result.WordGroupWithKey;
7	import ch.jalu.wordeval.util.StreamUtils;
8	import com.google.common.collect.HashMultimap;
9	import com.google.common.collect.ListMultimap;
10	import com.google.common.collect.Multimaps;
11	import com.google.common.collect.SetMultimap;
12	import lombok.Getter;
13
14	import java.util.ArrayList;
15	import java.util.Collection;
16	import java.util.Comparator;
17	import java.util.HashSet;
18	import java.util.List;
19	import java.util.Set;
20
21	/**
22	* Groups words which only differ in diacritics which are not considered
23	* distinct letters in the language, such as {des, dés, dès} in French or
24	* {schon, schön} in German.
25	*/
26	public class DiacriticHomonyms implements AllWordsEvaluator {	2✔
27
28	@Getter	6✔
29	private final List<WordGroupWithKey> results = new ArrayList<>();
30
31	@Override
32	public void evaluate(Collection<Word> words) {
33	SetMultimap<String, Word> wordsByNoAccentRep = words.stream()	3✔
34	.sorted(Comparator.comparing(w -> Character.isUpperCase(w.getRaw().charAt(0))))	10✔
35	.filter(StreamUtils.distinctByKey(Word::getLowercase))	5✔
36	.collect(Multimaps.toMultimap(	4✔
37	Word::getWithoutAccents,
38	word -> word,	2✔
39	HashMultimap::create));
40
41	Multimaps.asMap(wordsByNoAccentRep).forEach((wordRep, wordsInGroup) -> {	5✔
42	if (wordsInGroup.size() > 1) {	4✔
43	results.add(new WordGroupWithKey(wordsInGroup, wordRep));	9✔
44	}
45	});	1✔
46	}	1✔
47
48	@Override
49	public String getId() {
50	return "group.homonymsByDiacritic";	×
51	}
52
53	@Override
54	public ListMultimap<Object, Object> getTopResults(int topScores, int maxLimit) {
NEW 55	Comparator<WordGroupWithKey> comparator = Comparator.comparingInt((WordGroupWithKey group) -> group.words().size())	×
NEW 56	.thenComparing(group -> group.key().length())	×
UNCOV 57	.reversed(); // todo: unit test	×
58
59	List<WordGroupWithKey> sortedResult = results.stream()	×
60	.sorted(comparator)	×
61	.toList();	×
62
63	Set<Integer> uniqueValues = new HashSet<>();	×
64	ListMultimap<Object, Object> filteredResults = EvaluatorExportUtil.newListMultimap();	×
65	for (WordGroupWithKey wordGroup : sortedResult) {	×
NEW 66	int score = wordGroup.words().size();	×
67	if (uniqueValues.add(score) && uniqueValues.size() > topScores) {	×
68	break;	×
69	}
NEW 70	List<String> wordList = wordGroup.words().stream()	×
71	.map(Word::getRaw)	×
72	.toList();	×
73	filteredResults.put(score, wordList);	×
74	if (filteredResults.size() >= maxLimit) {	×
75	break;	×
76	}
77	}	×
78
79	return filteredResults;	×
80	}
81	}

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