proj_name stringclasses 131
values | relative_path stringlengths 30 228 | class_name stringlengths 1 68 | func_name stringlengths 1 48 | masked_class stringlengths 78 9.82k | func_body stringlengths 46 9.61k | len_input int64 29 2.01k | len_output int64 14 1.94k | total int64 55 2.05k | relevant_context stringlengths 0 38.4k |
|---|---|---|---|---|---|---|---|---|---|
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/WordRepeatBeginningRule.java | WordRepeatBeginningRule | match | class WordRepeatBeginningRule extends TextLevelRule {
public WordRepeatBeginningRule(ResourceBundle messages, Language language) {
super(messages);
super.setCategory(Categories.REPETITIONS_STYLE.getCategory(messages));
setLocQualityIssueType(ITSIssueType.Style);
}
@Override
public String getId()... |
String lastToken = "";
String beforeLastToken = "";
List<RuleMatch> ruleMatches = new ArrayList<>();
int pos = 0;
AnalyzedSentence prevSentence = null;
for (AnalyzedSentence sentence : sentences) {
if (isSentenceException(sentence)) {
prevSentence = null;
continue;
}... | 416 | 625 | 1,041 | <methods>public void <init>() ,public void <init>(java.util.ResourceBundle) ,public int estimateContextForSureMatch() ,public org.languagetool.rules.RuleMatch[] match(List<org.languagetool.AnalyzedSentence>, org.languagetool.markup.AnnotatedText) throws java.io.IOException,public abstract org.languagetool.rules.RuleMat... |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/WordRepeatRule.java | WordRepeatRule | match | class WordRepeatRule extends Rule {
public WordRepeatRule(ResourceBundle messages, Language language) {
super(messages);
super.setCategory(Categories.MISC.getCategory(messages));
setLocQualityIssueType(ITSIssueType.Duplication);
}
/**
* Implement this method to return <code>true</code> if there's... |
List<RuleMatch> ruleMatches = new ArrayList<>();
AnalyzedTokenReadings[] tokens = getSentenceWithImmunization(sentence).getTokensWithoutWhitespace();
String prevToken = "";
// we start from token 1, token no. 0 is guaranteed to be SENT_START
for (int i = 1; i < tokens.length; i++) {
String to... | 946 | 271 | 1,217 | <methods>public void <init>() ,public void <init>(java.util.ResourceBundle) ,public void addTags(List<java.lang.String>) ,public void addToneTags(List<java.lang.String>) ,public int estimateContextForSureMatch() ,public List<org.languagetool.tagging.disambiguation.rules.DisambiguationPatternRule> getAntiPatterns() ,pub... |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/YMDDateHelper.java | YMDDateHelper | parseDate | class YMDDateHelper {
public YMDDateHelper() {
}
public Map<String, String> parseDate(Map<String, String> args) {<FILL_FUNCTION_BODY>}
public RuleMatch correctDate(RuleMatch match, Map<String, String> args) {
String year = args.get("year");
String month = args.get("month");
String day = args.get(... |
String dateString = args.get("date");
if (dateString == null) {
throw new IllegalArgumentException("Missing key 'date'");
}
String[] parts = dateString.split("-");
if (parts.length != 3) {
throw new RuntimeException("Expected date in format 'yyyy-mm-dd': '" + dateString + "'");
}
... | 240 | 136 | 376 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/bitext/DifferentLengthRule.java | DifferentLengthRule | match | class DifferentLengthRule extends BitextRule {
private static final int MAX_SKEW = 250;
private static final int MIN_SKEW = 30;
public DifferentLengthRule() {
setLocQualityIssueType(ITSIssueType.Length);
}
@Override
public String getDescription() {
return "Check if translation length is similar ... |
if (isLengthDifferent(sourceText.getText(), targetText.getText())) {
AnalyzedTokenReadings[] tokens = targetText.getTokens();
int endPos = tokens[tokens.length - 1].getStartPos() + tokens[tokens.length - 1].getToken().length();
return new RuleMatch[] { new RuleMatch(this, targetText, 0, endPo... | 284 | 117 | 401 | <methods>public non-sealed void <init>() ,public final List<org.languagetool.bitext.StringPair> getCorrectBitextExamples() ,public final List<org.languagetool.rules.bitext.IncorrectBitextExample> getIncorrectBitextExamples() ,public abstract java.lang.String getMessage() ,public static List<Class<? extends org.language... |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/bitext/IncorrectBitextExample.java | IncorrectBitextExample | toString | class IncorrectBitextExample {
private final StringPair example;
private final List<String> corrections;
public IncorrectBitextExample(StringPair example) {
this(example, Collections.emptyList());
}
/**
* @since 2.9
*/
public IncorrectBitextExample(StringPair example, List<String> corrections) ... |
return example.getSource() + "/ " + example.getTarget() + " " + corrections;
| 234 | 26 | 260 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/ngrams/GoogleToken.java | GoogleToken | getGoogleTokens | class GoogleToken {
final String token;
final int startPos;
final int endPos;
final Set<AnalyzedToken> posTags;
GoogleToken(String token, int startPos, int endPos) {
this(token, startPos, endPos, Collections.emptySet());
}
GoogleToken(String token, int startPos, int endPos, Set<AnalyzedToken> posTa... |
List<GoogleToken> result = new ArrayList<>();
if (addStartToken) {
result.add(new GoogleToken(LanguageModel.GOOGLE_SENTENCE_START, 0, 0));
}
List<String> tokens = wordTokenizer.tokenize(sentence.getText());
int startPos = 0;
for (String token : tokens) {
if (!StringTools.isWhitespac... | 736 | 200 | 936 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/ngrams/GoogleTokenUtil.java | GoogleTokenUtil | getGoogleTokensForString | class GoogleTokenUtil {
public static List<String> getGoogleTokensForString(String sentence, boolean addStartToken, Language language) {<FILL_FUNCTION_BODY>}
} |
List<String> tokens = new LinkedList<>();
for (GoogleToken token : GoogleToken.getGoogleTokens(sentence, addStartToken, language.getWordTokenizer())) {
tokens.add(token.token);
}
return tokens;
| 48 | 65 | 113 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/AbstractTokenBasedRule.java | TokenHint | equals | class TokenHint {
final boolean inflected;
final String[] lowerCaseValues;
final int tokenIndex;
private TokenHint(boolean inflected, Set<String> possibleValues, int tokenIndex) {
this.inflected = inflected;
this.tokenIndex = tokenIndex;
lowerCaseValues = possibleValues.stream().map(S... |
if (this == o) return true;
if (!(o instanceof TokenHint)) return false;
TokenHint tokenHint = (TokenHint) o;
return inflected == tokenHint.inflected &&
tokenIndex == tokenHint.tokenIndex &&
Arrays.equals(lowerCaseValues, tokenHint.lowerCaseValues);
| 535 | 92 | 627 | <methods>public void <init>(java.lang.String, java.lang.String, org.languagetool.Language, List<org.languagetool.rules.patterns.PatternToken>, boolean, java.lang.String) ,public void <init>(java.lang.String, java.lang.String, org.languagetool.Language, List<org.languagetool.rules.patterns.PatternToken>, boolean) ,publi... |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/ApostropheTypeFilter.java | ApostropheTypeFilter | acceptRuleMatch | class ApostropheTypeFilter extends RuleFilter {
@Override
public RuleMatch acceptRuleMatch(RuleMatch match, Map<String, String> arguments, int patternTokenPos,
AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions) throws IOException {<FILL_FUNCTION_BODY>}
} |
String wordFrom = getRequired("wordFrom", arguments);
boolean hasTypographicalApostrophe = getRequired("hasTypographicalApostrophe", arguments).equalsIgnoreCase("true");
if (wordFrom != null) {
int posWord = 0;
if (wordFrom.equals("marker")) {
while (posWord < patternTokens.length && pa... | 81 | 273 | 354 | <methods>public non-sealed void <init>() ,public abstract org.languagetool.rules.RuleMatch acceptRuleMatch(org.languagetool.rules.RuleMatch, Map<java.lang.String,java.lang.String>, int, org.languagetool.AnalyzedTokenReadings[], List<java.lang.Integer>) throws java.io.IOException,public boolean matches(Map<java.lang.Str... |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/CaseConversionHelper.java | CaseConversionHelper | convertCase | class CaseConversionHelper {
private CaseConversionHelper() {
}
/**
* Converts case of the string token according to match element attributes.
* @param s Token to be converted.
* @param sample the sample string used to determine how the original string looks like (used only on case preservation)
* @... |
if (StringTools.isEmpty(s)) {
return s;
}
String token = s;
switch (conversion) {
case NONE:
break;
case PRESERVE:
if (StringTools.startsWithUppercase(sample)) {
if (StringTools.isAllUppercase(sample)) {
token = token.toUpperCase(Locale.ENGLISH);
... | 131 | 334 | 465 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/ConsistencyPatternRuleTransformer.java | ConsistencyPatternRule | match | class ConsistencyPatternRule extends TextLevelRule {
protected final Language ruleLanguage;
ConsistencyPatternRule(List<AbstractPatternRule> rules, Language lang) {
this.rules = Collections.unmodifiableList(rules);
this.ruleLanguage = lang;
setPremium(rules.stream().anyMatch(r -> r.isPremium... |
Map<String, Integer> countFeatures = new HashMap<>();
int offsetChars = 0;
List<RuleMatch> matches = new ArrayList<>();
for (AnalyzedSentence s : sentences) {
List<RuleMatch> sentenceMatches = new ArrayList<>();
for (AbstractPatternRule rule : rules) {
RuleMatch[] ru... | 315 | 671 | 986 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/EquivalenceTypeLocator.java | EquivalenceTypeLocator | equals | class EquivalenceTypeLocator {
private final String feature;
private final String type;
EquivalenceTypeLocator(String feature, String type) {
this.feature = feature;
this.type = type;
}
@Override
public int hashCode() {
return Objects.hash(feature, type);
}
@Override
public boolean equ... |
if (this == o) { return true; }
if (o == null) { return false; }
if (getClass() != o.getClass()) {
return false;
}
EquivalenceTypeLocator other = (EquivalenceTypeLocator) o;
return Objects.equals(feature, other.feature)
&& Objects.equals(type, other.type);
| 117 | 100 | 217 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/FalseFriendRuleHandler.java | FalseFriendRuleHandler | characters | class FalseFriendRuleHandler extends XMLRuleHandler {
// Definitions of values in XML files:
private static final String TRANSLATION = "translation";
private final ResourceBundle englishMessages;
private final ResourceBundle messages;
private final MessageFormat formatter;
private final Language textLangu... |
String s = new String(buf, offset, len);
if (inToken && inPattern) {
elements.append(s);
} else if (inCorrectExample) {
correctExample.append(s);
} else if (inIncorrectExample) {
incorrectExample.append(s);
} else if (inTranslation) {
translation.append(s);
}
| 1,854 | 100 | 1,954 | <methods>public void <init>() ,public void error(org.xml.sax.SAXParseException) throws org.xml.sax.SAXException,public List<org.languagetool.rules.patterns.AbstractPatternRule> getRules() ,public void setDocumentLocator(org.xml.sax.Locator) ,public void warning(org.xml.sax.SAXParseException) throws org.xml.sax.SAXExcep... |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/FalseFriendRuleLoader.java | FalseFriendRuleLoader | getRules | class FalseFriendRuleLoader extends DefaultHandler {
private final String falseFriendHint;
private final String falseFriendSugg;
public FalseFriendRuleLoader(Language motherTongue) {
ResourceBundle messages = JLanguageTool.getDataBroker().getResourceBundle(JLanguageTool.MESSAGE_BUNDLE, motherTongue.getLocal... |
FalseFriendRuleHandler handler = new FalseFriendRuleHandler(
textLanguage, motherTongue, falseFriendHint);
SAXParserFactory factory = SAXParserFactory.newInstance();
SAXParser saxParser = factory.newSAXParser();
saxParser.getXMLReader().setFeature(
"http://apache.org/xml/features/no... | 385 | 490 | 875 | <methods>public void <init>() ,public void characters(char[], int, int) throws org.xml.sax.SAXException,public void endDocument() throws org.xml.sax.SAXException,public void endElement(java.lang.String, java.lang.String, java.lang.String) throws org.xml.sax.SAXException,public void endPrefixMapping(java.lang.String) th... |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/IgnoreWhitespaceFilter.java | IgnoreWhitespaceFilter | acceptNode | class IgnoreWhitespaceFilter implements LSParserFilter {
@Override
public short acceptNode(Node nodeArg) {<FILL_FUNCTION_BODY>}
@Override
public short startElement(Element elementArg) {
return LSParserFilter.FILTER_ACCEPT;
}
@Override
public int getWhatToShow() {
return Node.NOTATION_NODE;
}
... |
String textContent = nodeArg.getTextContent();
if (textContent.trim().isEmpty()) {
return LSParserFilter.FILTER_REJECT;
} else {
return LSParserFilter.FILTER_ACCEPT;
}
| 109 | 65 | 174 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/Match.java | Match | createState | class Match {
/** Possible string case conversions. **/
public enum CaseConversion {
NONE, STARTLOWER, STARTUPPER, ALLLOWER, ALLUPPER, PRESERVE, FIRSTUPPER, NOTASHKEEL
}
public enum IncludeRange {
NONE, FOLLOWING, ALL
}
private final String posTag;
private final boolean suppressMisspelled;
pr... |
MatchState state = new MatchState(this, synthesizer);
state.setToken(token);
return state;
| 1,584 | 33 | 1,617 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/PasswordAuthenticator.java | PasswordAuthenticator | getPasswordAuthentication | class PasswordAuthenticator extends Authenticator {
@Override
@Nullable
protected PasswordAuthentication getPasswordAuthentication() {<FILL_FUNCTION_BODY>}
} |
if (getRequestingURL() == null) {
return null;
}
String userInfo = getRequestingURL().getUserInfo();
if (StringTools.isEmpty(userInfo)) {
return null;
}
String[] parts = userInfo.split(":");
if (parts.length != 2) {
throw new RuntimeException("Invalid userInfo format, expe... | 47 | 145 | 192 | <methods>public void <init>() ,public static java.net.Authenticator getDefault() ,public static java.net.PasswordAuthentication requestPasswordAuthentication(java.net.InetAddress, int, java.lang.String, java.lang.String, java.lang.String) ,public static java.net.PasswordAuthentication requestPasswordAuthentication(java... |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/PatternRuleId.java | PatternRuleId | toString | class PatternRuleId {
private final String id;
private final String subId;
/**
* @param id the rule id
*/
public PatternRuleId(String id) {
Validate.notEmpty(id, "id must be set");
this.id = id;
this.subId = null;
}
/**
* @param id the rule id
* @param subId the sub id of a rulegr... |
if (subId != null) {
return id + "[" + subId + "]";
} else {
return id;
}
| 293 | 41 | 334 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/PatternRuleLoader.java | PatternRuleLoader | getRules | class PatternRuleLoader extends DefaultHandler {
private boolean relaxedMode = false;
/**
* @param file XML file with pattern rules
*/
public final List<AbstractPatternRule> getRules(File file, Language lang) throws IOException {<FILL_FUNCTION_BODY>}
/**
* If set to true, don't throw an exception if... |
try (InputStream inputStream = Files.newInputStream(file.toPath())) {
PatternRuleLoader ruleLoader = new PatternRuleLoader();
return ruleLoader.getRules(inputStream, file.getAbsolutePath(), lang);
}
| 411 | 62 | 473 | <methods>public void <init>() ,public void characters(char[], int, int) throws org.xml.sax.SAXException,public void endDocument() throws org.xml.sax.SAXException,public void endElement(java.lang.String, java.lang.String, java.lang.String) throws org.xml.sax.SAXException,public void endPrefixMapping(java.lang.String) th... |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/PatternRuleXmlCreator.java | PatternRuleXmlCreator | toXML | class PatternRuleXmlCreator {
/**
* Return the given pattern rule as an indented XML string.
* @since 2.3
*/
public final String toXML(PatternRuleId ruleId, Language language) {<FILL_FUNCTION_BODY>}
private Document getDocument(InputStream is) throws InstantiationException, IllegalAccessException, Clas... |
List<String> filenames = language.getRuleFileNames();
XPath xpath = XPathFactory.newInstance().newXPath();
for (String filename : filenames) {
try (InputStream is = JLanguageTool.getDataBroker().getAsStream(filename)) {
Document doc = getDocument(is);
Node ruleNode = (Node) xpath.eval... | 674 | 528 | 1,202 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/PatternTokenBuilder.java | PatternTokenBuilder | build | class PatternTokenBuilder {
private String token;
private String posTag;
private boolean marker = true;
private boolean matchInflectedForms = false;
private boolean caseSensitive;
private boolean regexp;
private boolean negation;
private boolean isWhiteSpaceSet = false;
private boolean isWhiteSpaceBe... |
PatternToken patternToken;
patternToken = new PatternToken(token, caseSensitive, regexp, matchInflectedForms);
if (posTag != null) {
patternToken.setPosToken(new PatternToken.PosToken(posTag, regexp, false));
}
if (isWhiteSpaceSet) {
patternToken.setWhitespaceBefore(isWhiteSpaceBefore);... | 1,037 | 282 | 1,319 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/PatternTokenMatcher.java | PatternTokenMatcher | addMemberAndGroup | class PatternTokenMatcher {
private final PatternToken basePatternToken;
private PatternToken patternToken;
private List<PatternTokenMatcher> andGroup;
private boolean[] andGroupCheck;
public PatternTokenMatcher(PatternToken patternToken) {
basePatternToken = patternToken;
this.patternToken = baseP... |
if (patternToken.hasAndGroup()) {
List<PatternTokenMatcher> andGroupList = andGroup;
for (int i = 0; i < andGroupList.size(); i++) {
if (!andGroupCheck[i + 1]) {
PatternTokenMatcher testAndGroup = andGroupList.get(i);
if (testAndGroup.isMatched(token)) {
andGroup... | 928 | 124 | 1,052 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/RegexAntiPatternFilter.java | RegexAntiPatternFilter | acceptRuleMatch | class RegexAntiPatternFilter extends RegexRuleFilter {
@Nullable
@Override
public RuleMatch acceptRuleMatch(RuleMatch match, Map<String, String> arguments, AnalyzedSentence sentenceObj, Matcher patternMatcher) {<FILL_FUNCTION_BODY>}
} |
String antiPatternStr = arguments.get("antipatterns");
if (antiPatternStr == null) {
throw new RuntimeException("Missing 'antiPatterns:' in 'args' in <filter> of rule " + match.getRule().getFullId());
}
String[] antiPatterns = antiPatternStr.split("\\|");
for (String antiPattern : antiPattern... | 72 | 229 | 301 | <methods>public non-sealed void <init>() ,public abstract org.languagetool.rules.RuleMatch acceptRuleMatch(org.languagetool.rules.RuleMatch, Map<java.lang.String,java.lang.String>, org.languagetool.AnalyzedSentence, java.util.regex.Matcher) <variables> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/RegexRuleFilterCreator.java | RegexRuleFilterCreator | getFilter | class RegexRuleFilterCreator {
/**
* @param className fully qualified class Name of a class implementing {@link RegexRuleFilter}
*/
public RegexRuleFilter getFilter(String className) {<FILL_FUNCTION_BODY>}
} |
try {
Class<?> aClass = JLanguageTool.getClassBroker().forName(className);
Constructor<?>[] constructors = aClass.getConstructors();
if (constructors.length != 1) {
throw new RuntimeException("Constructor of filter class '"
+ className + "' must have exactly one constructo... | 67 | 323 | 390 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/RegexRuleFilterEvaluator.java | RegexRuleFilterEvaluator | getResolvedArguments | class RegexRuleFilterEvaluator {
private final RegexRuleFilter filter;
public RegexRuleFilterEvaluator(RegexRuleFilter filter) {
this.filter = filter;
}
@Nullable
public RuleMatch runFilter(String filterArgs, RuleMatch ruleMatch, AnalyzedSentence sentenceObj, Matcher patternMatcher) {
Map<String,St... |
Map<String,String> result = new HashMap<>();
String[] arguments = filterArgs.split("\\s+");
for (String arg : arguments) {
int delimPos = arg.indexOf(':');
if (delimPos == -1) {
throw new RuntimeException("Invalid syntax for key/value, expected 'key:value', got: '" + arg + "'");
}... | 164 | 149 | 313 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/RepeatedPatternRuleTransformer.java | RepeatedPatternRule | match | class RepeatedPatternRule extends TextLevelRule {
protected final Language ruleLanguage;
RepeatedPatternRule(List<AbstractPatternRule> rules, Language lang) {
this.rules = Collections.unmodifiableList(rules);
this.ruleLanguage = lang;
setPremium(rules.stream().anyMatch(r -> r.isPremium()... |
List<RuleMatch> matches = new ArrayList<>();
int offsetChars = 0;
int offsetTokens = 0;
int prevFromToken = 0;
int prevMatches = 0;
List<Integer> distancesBetweenMatches = new ArrayList<>();
// we need to adjust offsets since each pattern rule returns offsets relative to the s... | 426 | 564 | 990 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/RuleFilter.java | FakeRule | getRequired | class FakeRule extends Rule {
@Override public String getId() { return "FAKE-RULE-FOR-FILTER"; }
@Override public String getDescription() { return "<none>"; }
@Override public RuleMatch[] match(AnalyzedSentence sentence) throws IOException { return new RuleMatch[0]; }
}
protected String getRequired(Str... |
String result = map.get(key);
if (result == null) {
throw new IllegalArgumentException("Missing key '" + key + "'");
}
return result;
| 111 | 46 | 157 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/RuleFilterCreator.java | RuleFilterCreator | getFilter | class RuleFilterCreator {
/**
* @param className fully qualified class Name of a class implementing {@link RuleFilter}
*/
public RuleFilter getFilter(String className) {<FILL_FUNCTION_BODY>}
} |
try {
Class<?> aClass = JLanguageTool.getClassBroker().forName(className);
Constructor<?>[] constructors = aClass.getConstructors();
if (constructors.length != 1) {
throw new RuntimeException("Constructor of filter class '"
+ className + "' must have exactly one constructo... | 61 | 317 | 378 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/RuleFilterEvaluator.java | RuleFilterEvaluator | getResolvedArguments | class RuleFilterEvaluator {
private static final Pattern WHITESPACE = Pattern.compile("\\s+");
private final RuleFilter filter;
public RuleFilterEvaluator(RuleFilter filter) {
this.filter = filter;
}
@Nullable
public RuleMatch runFilter(String filterArgs, RuleMatch ruleMatch, AnalyzedTokenReadings[]... |
Map<String,String> result = new HashMap<>();
String[] arguments = WHITESPACE.split(filterArgs);
for (String arg : arguments) {
int delimPos = arg.indexOf(':');
if (delimPos == -1) {
throw new RuntimeException("Invalid syntax for key/value, expected 'key:value', got: '" + arg + "'");
... | 382 | 362 | 744 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/RuleSet.java | RuleSet | rulesForSentence | class RuleSet {
private volatile Set<String> ruleIds;
/**
* @return all rules in this set, not filtered
*/
public abstract List<Rule> allRules();
/**
* @return all rules from {@link #allRules} that might be applicable to the given sentence.
*/
public abstract List<Rule> rulesForSentence(Analyzed... |
BitSet included = new BitSet();
included.or(unclassified);
if (!byLemma.isEmpty()) {
for (String lemma : sentence.getLemmaSet()) {
BitSet set = byLemma.get(lemma);
if (set != null) {
included.or(set);
}
}
}
fo... | 1,050 | 151 | 1,201 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/Substrings.java | Substrings | checkCanReplaceRegex | class Substrings {
final String[] substrings;
private final int minLength;
/** Whether the first of {@link #substrings} must occur at the matched fragment start */
final boolean mustStart;
/** Whether the last of {@link #substrings} must occur at the matched fragment end */
final boolean mustEnd;
Subst... |
if (mustStart || mustEnd) {
String prefix = mustStart ? substrings[0] : "";
String suffix = mustEnd ? substrings[substrings.length - 1] : "";
if (regexp.startsWith(prefix) &&
regexp.endsWith(suffix) &&
regexp.length() == prefix.length() + suffix.length() + 2 &&
regex... | 1,550 | 225 | 1,775 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/UnifierConfiguration.java | UnifierConfiguration | setEquivalence | class UnifierConfiguration {
/**
* A Map for storing the equivalence types for features. Features are
* specified as Strings, and map into types defined as maps from Strings to
* Elements.
*/
private final Map<EquivalenceTypeLocator, PatternToken> equivalenceTypes;
/**
* A Map that stores all poss... |
EquivalenceTypeLocator typeKey = new EquivalenceTypeLocator(feature, type);
if (equivalenceTypes.containsKey(typeKey)) {
return;
}
equivalenceTypes.put(typeKey, elem);
List<String> lTypes;
if (equivalenceFeatures.containsKey(feature)) {
lTypes = equivalenceFeatures.get(feature... | 413 | 150 | 563 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/bitext/BitextPatternRule.java | BitextPatternRule | match | class BitextPatternRule extends BitextRule {
private final AbstractPatternRule srcRule;
private final AbstractPatternRule trgRule;
BitextPatternRule(AbstractPatternRule src, AbstractPatternRule trg) {
srcRule = src;
trgRule = trg;
}
public AbstractPatternRule getSrcRule() {
return srcRu... |
if (srcRule.match(sourceSentence).length > 0) {
return trgRule.match(targetSentence);
}
return new RuleMatch[0];
| 338 | 47 | 385 | <methods>public non-sealed void <init>() ,public final List<org.languagetool.bitext.StringPair> getCorrectBitextExamples() ,public final List<org.languagetool.rules.bitext.IncorrectBitextExample> getIncorrectBitextExamples() ,public abstract java.lang.String getMessage() ,public static List<Class<? extends org.language... |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/bitext/BitextPatternRuleHandler.java | BitextPatternRuleHandler | setExample | class BitextPatternRuleHandler extends PatternRuleHandler {
private static final String SOURCE = "source";
private static final String TARGET = "target";
private static final String SRC_EXAMPLE = "srcExample";
private static final String TRG_EXAMPLE = "trgExample";
private final List<BitextPatternRule> rule... |
IncorrectExample example = null;
if (inCorrectExample) {
example = new IncorrectExample(correctExample.toString());
} else if (inIncorrectExample) {
if (exampleCorrection != null) {
List<String> corrections = new ArrayList<>(Arrays.asList(exampleCorrection.toString().split("\\|")));
... | 1,255 | 244 | 1,499 | <methods>public void <init>() ,public void <init>(java.lang.String) ,public void <init>(java.lang.String, org.languagetool.Language) ,public void characters(char[], int, int) ,public void endElement(java.lang.String, java.lang.String, java.lang.String) throws org.xml.sax.SAXException,public org.xml.sax.InputSource reso... |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/bitext/BitextPatternRuleLoader.java | BitextPatternRuleLoader | getRules | class BitextPatternRuleLoader extends DefaultHandler {
public final List<BitextPatternRule> getRules(InputStream is, String filename) throws IOException {<FILL_FUNCTION_BODY>}
} |
List<BitextPatternRule> rules;
try {
BitextPatternRuleHandler handler = new BitextPatternRuleHandler();
SAXParserFactory factory = SAXParserFactory.newInstance();
SAXParser saxParser = factory.newSAXParser();
saxParser.getXMLReader().setFeature("http://apache.org/xml/features/nonvalidat... | 53 | 165 | 218 | <methods>public void <init>() ,public void characters(char[], int, int) throws org.xml.sax.SAXException,public void endDocument() throws org.xml.sax.SAXException,public void endElement(java.lang.String, java.lang.String, java.lang.String) throws org.xml.sax.SAXException,public void endPrefixMapping(java.lang.String) th... |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/patterns/bitext/FalseFriendsAsBitextLoader.java | FalseFriendsAsBitextLoader | getFalseFriendsAsBitext | class FalseFriendsAsBitextLoader {
public List<BitextPatternRule> getFalseFriendsAsBitext(
String filename, Language motherTongue,
Language language) throws ParserConfigurationException,
SAXException, IOException {<FILL_FUNCTION_BODY>}
} |
FalseFriendRuleLoader ruleLoader = new FalseFriendRuleLoader(motherTongue);
List<BitextPatternRule> bRules = new ArrayList<>();
List<AbstractPatternRule> rules1 = ruleLoader.getRules(
JLanguageTool.getDataBroker().getFromRulesDirAsStream(filename),
motherTongue, language);
List<... | 77 | 297 | 374 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/spelling/CachingWordListLoader.java | CachingWordListLoader | load | class CachingWordListLoader {
// Speed up the server use case, where rules get initialized for every call.
private static final LoadingCache<String, List<String>> cache = CacheBuilder.newBuilder()
.expireAfterWrite(10, TimeUnit.MINUTES)
.build(new CacheLoader<String, List<String>>() {
@Override... |
List<String> result = new ArrayList<>();
if (!JLanguageTool.getDataBroker().resourceExists(fileInClassPath)) {
return result;
}
List<String> lines = JLanguageTool.getDataBroker().getFromResourceDirAsLines(fileInClassPath);
for (String line : lines) {
... | 158 | 146 | 304 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/spelling/ForeignLanguageChecker.java | ForeignLanguageChecker | check | class ForeignLanguageChecker {
private static final float ERROR_THRESHOLD = 0.45f;
private static final int MIN_SENTENCE_THRESHOLD = 3;
private static final int MAX_SCORING_LANGUAGES = 5;
public static final String NO_FOREIGN_LANG_DETECTED = "NO_FOREIGN_LANG_DETECTED";
private final String languageShortCod... |
float errorRatio = (float) matchesSoFar / sentenceLength;
if (sentenceLength >= MIN_SENTENCE_THRESHOLD && errorRatio >= ERROR_THRESHOLD) {
LanguageIdentifier langIdent = LanguageIdentifierService.INSTANCE.getInitialized();
if (langIdent != null) {
//for now, we just use the result if also i... | 266 | 486 | 752 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/spelling/RuleWithLanguage.java | RuleWithLanguage | equals | class RuleWithLanguage {
private final Rule rule;
private final Language language;
public RuleWithLanguage(Rule rule, Language language) {
this.rule = Objects.requireNonNull(rule);
this.language = Objects.requireNonNull(language);
}
public Language getLanguage() {
return language;
}
publ... |
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
RuleWithLanguage that = (RuleWithLanguage) o;
return Objects.equals(rule, that.rule) && Objects.equals(language, that.language);
| 161 | 75 | 236 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/spelling/VagueSpellChecker.java | VagueSpellChecker | getSpellingCheckRule | class VagueSpellChecker {
private final static Map<Language, Rule> langToRule = new HashMap<>();
private final static Map<Language, Dictionary> langToDict = new HashMap<>();
public boolean isValidWord(String word, Language lang) {
Rule rule = langToRule.get(lang);
if (rule == null) {
Rule tempRu... |
JLanguageTool lt = new JLanguageTool(lang);
SpellingCheckRule spellRule = null;
for (Rule r : lt.getAllActiveRules()) {
if (r instanceof HunspellRule || r instanceof MorfologikSpellerRule) {
spellRule = (SpellingCheckRule) r;
// TODO: what if there's more than one spell rule?
... | 740 | 181 | 921 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/spelling/hunspell/DumontsHunspellDictionary.java | DumontsHunspellDictionary | add | class DumontsHunspellDictionary implements HunspellDictionary {
private final Hunspell hunspell;
private boolean closed = false;
public DumontsHunspellDictionary(Path dictionary, Path affix) {
try {
hunspell = new Hunspell(dictionary,affix);
} catch (UnsatisfiedLinkError e) {
throw new Runtim... |
if (closed) {
throw new RuntimeException("Attempt to use hunspell instance after closing");
}
hunspell.add(word);
| 366 | 41 | 407 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/spelling/hunspell/Hunspell.java | LanguageAndPath | equals | class LanguageAndPath {
private final Path dictionary;
private final Path affix;
LanguageAndPath(Path dictionary, Path affix) {
this.dictionary = Objects.requireNonNull(dictionary);
this.affix = Objects.requireNonNull(affix);
}
@Override
public boolean equals(Object o) {<FILL_FUNCTIO... |
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
LanguageAndPath that = (LanguageAndPath) o;
return Objects.equals(dictionary, that.dictionary) &&
Objects.equals(affix, that.affix);
| 130 | 81 | 211 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/spelling/morfologik/MorfologikSpeller.java | MorfologikSpeller | getFrequency | class MorfologikSpeller {
// Speed up the server use case, where rules get initialized for every call.
// See https://github.com/morfologik/morfologik-stemming/issues/69 for confirmation that
// Dictionary is thread-safe:
private static final LoadingCache<String, Dictionary> dictCache = CacheBuilder.newBuild... |
int freq = speller.getFrequency(word);
if (freq == 0 && !word.equals(word.toLowerCase())) {
freq = speller.getFrequency(word.toLowerCase());
}
return freq;
| 1,924 | 66 | 1,990 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/spelling/morfologik/suggestions_ordering/DetailedDamerauLevenstheinDistance.java | Replace | apply | class Replace extends EditOperation {
@Override
public String apply(String s) {<FILL_FUNCTION_BODY>}
} |
if (s.length() == 0) {
return null;
}
int i = random.nextInt(s.length());
char c = randomChar(random);
if (i == 0) {
return "" + c + s.substring(1);
} else if (i == s.length() - 1) {
return s.substring(0, i) + c;
} else {
return s.substring(0, ... | 38 | 135 | 173 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/spelling/multitoken/MultitokenSpellerFilter.java | MultitokenSpellerFilter | acceptRuleMatch | class MultitokenSpellerFilter extends RuleFilter {
/* Provide suggestions for misspelled multitoken expressions, usually proper nouns*/
@Override
public RuleMatch acceptRuleMatch(RuleMatch match, Map<String, String> arguments, int patternTokenPos,
AnalyzedTokenReadings[] patte... |
if (Arrays.stream(patternTokens).allMatch(x -> x.isIgnoredBySpeller())) {
return null;
}
String underlinedError = match.getOriginalErrorStr();
Language lang = ((PatternRule) match.getRule()).getLanguage();
// check the spelling for some languages in a different way
boolean areTokensAccept... | 222 | 764 | 986 | <methods>public non-sealed void <init>() ,public abstract org.languagetool.rules.RuleMatch acceptRuleMatch(org.languagetool.rules.RuleMatch, Map<java.lang.String,java.lang.String>, int, org.languagetool.AnalyzedTokenReadings[], List<java.lang.Integer>) throws java.io.IOException,public boolean matches(Map<java.lang.Str... |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/spelling/suggestions/SuggestionsChanges.java | Report | run | class Report implements Runnable {
private final BufferedWriter reportWriter;
Report(BufferedWriter reportWriter) {
this.reportWriter = reportWriter;
}
@Override
public void run() {<FILL_FUNCTION_BODY>}
} |
if (reportWriter == null) {
return;
}
try {
StringBuilder report = new StringBuilder();
report.append("Overall report:\n\n");
SuggestionChangesExperiment best = null;
int bestId = -1;
double bestAccuracy = 0.0;
int experimentId = 0;
fo... | 71 | 922 | 993 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/spelling/symspell/implementation/ChunkArray.java | ChunkArray | add | class ChunkArray<T>
{
private static int chunkSize = 4096;//this must be a power of 2, otherwise can't optimize row and col functions
private static int divShift = 12; // number of bits to shift right to do division by chunkSize (the bit position of chunkSize)
public SuggestionStage.Node[][] values; ... |
if (count == capacity()) {
Node[][] newValues = Arrays.copyOf(values, values.length + 1);
newValues[values.length] = new Node[chunkSize];
values = newValues;
}
values[row(count)][col(count)] = value;
count++;
return count - 1;
| 427 | 91 | 518 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/spelling/symspell/implementation/EditDistance.java | EditDistance | DamerauLevenshteinDistance | class EditDistance {
public enum DistanceAlgorithm{
Damerau
}
private String baseString;
private DistanceAlgorithm algorithm;
private int[] v0;
private int[] v2;
/// <summary>Create a new EditDistance object.</summary>
/// <param name="baseString">The base string to which other s... |
if (baseString == null) return string2 == null ? 0 : string2.length(); //string2 ?? "").Length;
if (string2 == null || string2.isEmpty()) return baseString.length();
if(maxDistance == 0) return baseString.equals(string2) ? 0 : -1;
// if strings of different lengths, ensure shorter stri... | 578 | 1,198 | 1,776 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/spelling/symspell/implementation/SuggestItem.java | SuggestItem | compareTo | class SuggestItem implements Comparator<SuggestItem>, Comparable<SuggestItem>
{
/// <summary>The suggested correctly spelled word.</summary>
public String term;
/// <summary>Edit distance between searched for word and suggestion.</summary>
public int distance;
/// <summary>Frequency of suggestion in... |
// order by distance ascending, then by frequency count descending
if (this.distance == other.distance) return Long.compare(other.count, this.count);
return Integer.compare(this.distance, other.distance);
| 444 | 58 | 502 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/spelling/symspell/implementation/SuggestionStage.java | Entry | add | class Entry {
public int count;
public int first;
Entry(int count, int first) {
this.count = count;
this.first = first;
}
}
public Map<Integer, Entry> deletes; // {get; set; }
public ChunkArray<Node> nodes;
/// <summary>Create a new instance of Sym... |
Entry entry = deletes.getOrDefault(deleteHash, new Entry(0, -1));
int next = entry.first;
entry.count++;
entry.first = nodes.count;
deletes.put(deleteHash, entry);
nodes.add(new Node(suggestion, next));
| 324 | 78 | 402 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/rules/translation/TranslationEntry.java | TranslationEntry | toString | class TranslationEntry {
private final List<String> l1;
private final List<String> l2;
private final int itemCount;
public TranslationEntry(List<String> l1, List<String> l2, int itemCount) {
this.l1 = Objects.requireNonNull(l1);
this.l2 = Objects.requireNonNull(l2);
this.itemCount = itemCount;
}... |
//return l1 + " -> " + l2 + " (itemCount: "+ itemCount + ")";
return l1 + " -> " + l2;
| 321 | 44 | 365 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/synthesis/SynthesizerTools.java | SynthesizerTools | loadWords | class SynthesizerTools {
private SynthesizerTools() {
// static methods only, no public constructor
}
public static List<String> loadWords(InputStream stream) {<FILL_FUNCTION_BODY>}
} |
List<String> result = new ArrayList<>();
try (Scanner scanner = new Scanner(stream, "UTF-8")) {
while (scanner.hasNextLine()) {
String line = scanner.nextLine().trim();
if (line.isEmpty() || line.charAt(0) == '#') { // ignore empty lines and comments
continue;
}
... | 65 | 114 | 179 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/tagging/CombiningTagger.java | CombiningTagger | tag | class CombiningTagger implements WordTagger {
private final WordTagger tagger1;
private final WordTagger tagger2;
private final WordTagger removalTagger;
private final boolean overwriteWithSecondTagger;
public CombiningTagger(WordTagger tagger1, WordTagger tagger2, boolean overwriteWithSecondTagger) {
t... |
List<TaggedWord> result = new ArrayList<>();
result.addAll(tagger2.tag(word));
if (!(overwriteWithSecondTagger && result.size() > 0)) {
result.addAll(tagger1.tag(word));
}
if (removalTagger != null) {
List<TaggedWord> removalTags = removalTagger.tag(word);
result.removeAll(removal... | 438 | 121 | 559 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/tagging/ManualTagger.java | ManualTagger | tag | class ManualTagger implements WordTagger {
private final static String DEFAULT_SEPARATOR = "\t";
private static final int OFFSET_SHIFT = 8;
private static final int MAX_LENGTH = (1 << OFFSET_SHIFT) - 1;
private static final int MAX_OFFSET = (1 << 32 - OFFSET_SHIFT) - 1;
private static final int ENTRY_SIZE = ... |
int value = map.getInt(word);
if (value == 0) {
return Collections.emptyList();
}
int offset = (value >>> OFFSET_SHIFT) * ENTRY_SIZE;
int length = value & MAX_LENGTH;
List<TaggedWord> result = new ArrayList<>(length);
for (int i = 0; i < length; i++) {
result.add(new TaggedWord... | 1,116 | 148 | 1,264 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/tagging/MorfologikTagger.java | MorfologikTagger | tag | class MorfologikTagger implements WordTagger {
private final URL dictUrl;
private Dictionary dictionary;
private boolean internTags;
public MorfologikTagger(String dictPath) {
this(JLanguageTool.getDataBroker().getFromResourceDirAsUrl(Objects.requireNonNull(dictPath)));
}
MorfologikTagger(URL dictU... |
List<TaggedWord> result = new ArrayList<>();
try {
IStemmer dictLookup = new DictionaryLookup(getDictionary());
List<WordData> lookup = dictLookup.lookup(word);
for (WordData wordData : lookup) {
String tag = wordData.getTag() == null ? null : wordData.getTag().toString();
// ... | 356 | 281 | 637 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/tagging/TaggedWord.java | TaggedWord | equals | class TaggedWord {
private final String lemma;
private final String posTag;
public TaggedWord(String lemma, String posTag) {
this.lemma = lemma;
this.posTag = posTag;
}
public String getLemma() {
return lemma;
}
public String getPosTag() {
return posTag;
}
@Override
public Strin... |
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
TaggedWord other = (TaggedWord) o;
return Objects.equals(lemma, other.lemma) && Objects.equals(posTag, other.posTag);
| 180 | 77 | 257 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/tagging/disambiguation/rules/DisambiguatedExample.java | DisambiguatedExample | toString | class DisambiguatedExample {
private final String example;
private final String input;
private final String output;
public DisambiguatedExample(String example) {
this(example, null, null);
}
/**
* @param example Example sentence
* @param input Ambiguous forms of a token (specify in 'word[lemm... |
return example + ": " + input + " -> " + output;
| 300 | 21 | 321 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/tagging/disambiguation/rules/DisambiguationRuleLoader.java | DisambiguationRuleLoader | getRules | class DisambiguationRuleLoader extends DefaultHandler {
public final List<DisambiguationPatternRule> getRules(InputStream stream, Language language, String xmlPath)
throws ParserConfigurationException, SAXException, IOException {<FILL_FUNCTION_BODY>}
} |
DisambiguationRuleHandler handler = new DisambiguationRuleHandler(language, xmlPath);
SAXParserFactory factory = SAXParserFactory.newInstance();
SAXParser saxParser = factory.newSAXParser();
if (JLanguageTool.isCustomPasswordAuthenticatorUsed()) {
Tools.setPasswordAuthenticator();
}
sax... | 69 | 113 | 182 | <methods>public void <init>() ,public void characters(char[], int, int) throws org.xml.sax.SAXException,public void endDocument() throws org.xml.sax.SAXException,public void endElement(java.lang.String, java.lang.String, java.lang.String) throws org.xml.sax.SAXException,public void endPrefixMapping(java.lang.String) th... |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/tagging/disambiguation/rules/XmlRuleDisambiguator.java | XmlRuleDisambiguator | disambiguate | class XmlRuleDisambiguator extends AbstractDisambiguator {
private static final String DISAMBIGUATION_FILE = "disambiguation.xml";
private static final String GLOBAL_DISAMBIGUATION_FILE = "disambiguation-global.xml";
private final RuleSet disambiguationRules;
public XmlRuleDisambiguator(Language language) ... |
for (Rule rule : disambiguationRules.rulesForSentence(sentence)) {
if (checkCanceled != null && checkCanceled.checkCancelled()) {
break;
}
sentence = ((DisambiguationPatternRule) rule).replace(sentence);
}
return sentence;
| 671 | 81 | 752 | <methods>public non-sealed void <init>() ,public org.languagetool.AnalyzedSentence preDisambiguate(org.languagetool.AnalyzedSentence) <variables> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/tagging/xx/DemoTagger.java | DemoTagger | tag | class DemoTagger implements Tagger {
@Override
public List<AnalyzedTokenReadings> tag(List<String> sentenceTokens) {<FILL_FUNCTION_BODY>}
@Override
public AnalyzedTokenReadings createNullToken(String token, int startPos) {
return new AnalyzedTokenReadings(new AnalyzedToken(token, null, null), startPos);
... |
List<AnalyzedTokenReadings> tokenReadings = new ArrayList<>();
for (String word : sentenceTokens) {
List<AnalyzedToken> l = new ArrayList<>();
// a real tagger would need to assign a POS tag
// in the next line instead of null:
l.add(new AnalyzedToken(word, null, null));
tokenRead... | 144 | 120 | 264 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/tokenizers/SRXSentenceTokenizer.java | SRXSentenceTokenizer | setSingleLineBreaksMarksParagraph | class SRXSentenceTokenizer implements SentenceTokenizer {
private final SrxDocument srxDocument;
private final Language language;
private String parCode;
/**
* Build a sentence tokenizer based on the rules in the {@code segment.srx} file
* that comes with LanguageTool.
*/
public SRXSentenceTokeniz... |
if (lineBreakParagraphs) {
parCode = "_one";
} else {
parCode = "_two";
}
| 408 | 38 | 446 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/tokenizers/SrxTools.java | SrxTools | createSrxDocument | class SrxTools {
private SrxTools() {
}
static SrxDocument createSrxDocument(String path) {<FILL_FUNCTION_BODY>}
static List<String> tokenize(String text, SrxDocument srxDocument, String code) {
List<String> segments = new ArrayList<>();
TextIterator textIterator = new SrxTextIterator(srxDocument, co... |
try {
try (
InputStream inputStream = JLanguageTool.getDataBroker().getFromResourceDirAsStream(path);
BufferedReader srxReader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))
) {
Map<String, Object> parserParameters = new HashMap<>();
par... | 140 | 173 | 313 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/tools/ConfidenceKey.java | ConfidenceKey | equals | class ConfidenceKey {
private final Language lang;
private final String ruleId;
public ConfidenceKey(Language lang, String ruleId) {
this.lang = Objects.requireNonNull(lang);
this.ruleId = Objects.requireNonNull(ruleId);
}
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Overr... |
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
ConfidenceKey that = (ConfidenceKey) o;
return Objects.equals(lang, that.lang) && Objects.equals(ruleId, that.ruleId);
| 168 | 77 | 245 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/tools/ContextTools.java | ContextTools | getContext | class ContextTools {
private int contextSize = 40;
private boolean escapeHtml = true;
private String errorMarkerStart = "<b><font bgcolor=\"#ff8b8b\">";
private String errorMarkerEnd = "</font></b>";
public ContextTools() {
}
public String getContext(int fromPos, int toPos, String contents) {<FILL_FUNC... |
// calculate context region:
int startContent = fromPos - contextSize;
String prefix = "...";
String postfix = "...";
if (startContent < 0) {
prefix = "";
startContent = 0;
}
int endContent = toPos + contextSize;
int textLength = contents.length();
if (endContent > textL... | 787 | 409 | 1,196 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/tools/DiffsAsMatches.java | DiffsAsMatches | getPseudoMatches | class DiffsAsMatches {
public List<PseudoMatch> getPseudoMatches(String original, String revised) {<FILL_FUNCTION_BODY>}
} |
List<PseudoMatch> matches = new ArrayList<>();
List<String> origList = DiffRowGenerator.SPLITTER_BY_WORD.apply(original);
List<String> revList = DiffRowGenerator.SPLITTER_BY_WORD.apply(revised);
List<AbstractDelta<String>> inlineDeltas = DiffUtils.diff(origList, revList, DiffRowGenerator.DEFAULT_EQUALI... | 49 | 1,106 | 1,155 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/tools/InterruptibleCharSequence.java | InterruptibleCharSequence | charAt | class InterruptibleCharSequence implements CharSequence {
private final CharSequence inner;
public InterruptibleCharSequence(CharSequence inner) {
super();
this.inner = inner;
}
public char charAt(int index) {<FILL_FUNCTION_BODY>}
public int length() {
return inner.length();
}
public Char... |
if (Thread.interrupted()) {
throw new RuntimeException(new InterruptedException());
}
return inner.charAt(index);
| 159 | 38 | 197 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/tools/LtThreadPoolExecutor.java | LtThreadPoolExecutor | afterExecute | class LtThreadPoolExecutor extends ThreadPoolExecutor {
private static final Gauge maxQueueSize = Gauge.build("languagetool_threadpool_max_queue_size", "Queue capacity by threadpool")
.labelNames("pool").register();
private static final Gauge queueSize = Gauge.build("languagetool_threadpool_queue_size", "Queue... |
super.afterExecute(r, t);
// inherited from removed StoppingThreadPoolExecutor in org.languagetool.server.Server
if (t != null && t instanceof OutOfMemoryError) {
// we prefer to stop instead of being in an unstable state:
//noinspection CallToPrintStackTrace
t.printStackTrace();
S... | 591 | 100 | 691 | <methods>public void <init>(int, int, long, java.util.concurrent.TimeUnit, BlockingQueue<java.lang.Runnable>) ,public void <init>(int, int, long, java.util.concurrent.TimeUnit, BlockingQueue<java.lang.Runnable>, java.util.concurrent.ThreadFactory) ,public void <init>(int, int, long, java.util.concurrent.TimeUnit, Block... |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/tools/LtThreadPoolFactory.java | LtRejectedExecutionHandler | getFixedThreadPoolExecutor | class LtRejectedExecutionHandler extends ThreadPoolExecutor.AbortPolicy {
@Override
public void rejectedExecution(Runnable runnable, ThreadPoolExecutor threadPoolExecutor) {
String pool = ((LtThreadPoolExecutor) threadPoolExecutor).getName();
rejectedTasks.labels(pool).inc();
log.warn(Logging... |
ThreadPoolExecutor value = executorServices.get(identifier);
if (value == null) {
log.debug(LoggingTools.SYSTEM, "Request: " + identifier + " not found, returning default pool");
return Optional.of(defaultPool);
} else {
return Optional.of(value);
}
| 566 | 82 | 648 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/tools/MostlySingularMultiMap.java | MostlySingularMultiMap | getList | class MostlySingularMultiMap<K, V> {
private final Object2ObjectOpenHashMap<K, Object> map;
public MostlySingularMultiMap(Map<K, List<V>> contents) {
map = new Object2ObjectOpenHashMap<>(contents.size());
for (Map.Entry<K, List<V>> entry : contents.entrySet()) {
List<V> value = entry.getValue();
... |
Object o = map.get(key);
//noinspection unchecked
return o == null ? null :
o instanceof Object[] ? Arrays.asList((V[]) o) :
Collections.singletonList((V) o);
| 181 | 63 | 244 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-core/src/main/java/org/languagetool/tools/PseudoMatch.java | PseudoMatch | toString | class PseudoMatch {
private final List<String> replacements;
private final int fromPos;
private final int toPos;
PseudoMatch(String replacement, int fromPos, int toPos) {
this.replacements = new ArrayList<>();
this.replacements.add(replacement);
this.fromPos = fromPos;
this.toPos = toPos;
}
... |
return String.valueOf(this.fromPos) + "-" + String.valueOf(this.toPos) + "-" + this.replacements.toString();
| 198 | 44 | 242 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/CorrectLinePrinter.java | CorrectLinePrinter | main | class CorrectLinePrinter {
public static void main(String[] args) throws IOException {<FILL_FUNCTION_BODY>}
} |
if (args.length != 2) {
System.out.println("Usage: " + CorrectLinePrinter.class.getSimpleName() + " <file> <langCode>");
System.exit(1);
}
List<String> lines = Files.readAllLines(Paths.get(args[0]));
JLanguageTool lt = new JLanguageTool(Languages.getLanguageForShortCode(args[1]));
lt.ac... | 37 | 195 | 232 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/DuplicateRemover.java | DuplicateRemover | main | class DuplicateRemover {
public static void main(String[] args) throws IOException {<FILL_FUNCTION_BODY>}
} |
if (args.length != 1) {
System.out.println("Usage: " + DuplicateRemover.class.getSimpleName() + " <file>");
System.exit(1);
}
List<String> lines = Files.readAllLines(Paths.get(args[0]));
Set<String> seenBefore = new HashSet<>();
for (String line : lines) {
line = line.trim();
... | 36 | 193 | 229 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/DutchWordSplitter.java | DutchWordSplitter | main | class DutchWordSplitter {
public static void main(String[] args) throws IOException {<FILL_FUNCTION_BODY>}
} |
// exported as documented at https://dev.languagetool.org/developing-a-tagger-dictionary,
// then taking only the full form: awk '{print $1}' dictionary-nl.dump
String filename = "/home/dnaber/lt/dictionary-nl.dump";
MorfologikMultiSpeller speller = new MorfologikMultiSpeller("/nl/spelling/nl_NL.dict",... | 37 | 406 | 443 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/EmptyLuceneIndexCreator.java | EmptyLuceneIndexCreator | main | class EmptyLuceneIndexCreator {
private EmptyLuceneIndexCreator() {
}
public static void main(String[] args) throws IOException {<FILL_FUNCTION_BODY>}
} |
if (args.length != 1) {
System.out.println("Usage: " + EmptyLuceneIndexCreator.class.getSimpleName() + " <indexPath>");
System.exit(1);
}
Analyzer analyzer = new StandardAnalyzer();
IndexWriterConfig config = new IndexWriterConfig(analyzer);
Directory directory = FSDirectory.open(new Fi... | 56 | 215 | 271 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/ExampleSentencePrinter.java | ExampleSentencePrinter | run | class ExampleSentencePrinter {
private static final int MAX_BLOCK_SIZE = 5000;
private void run(Language lang) {<FILL_FUNCTION_BODY>}
public static void main(String[] args) {
ExampleSentencePrinter prg = new ExampleSentencePrinter();
prg.run(Languages.getLanguageForShortCode("de"));
}
} |
File basePath = new File("/home/dnaber/lt/git/languagetool/languagetool-language-modules");
if (!basePath.exists()) {
throw new RuntimeException("basePath does not exist: " + basePath);
}
JLanguageTool tool = new JLanguageTool(lang);
System.out.println("<html>");
System.out.println("<head... | 105 | 461 | 566 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/ExportGermanNouns.java | ExportGermanNouns | getSortedWords | class ExportGermanNouns {
private static final String DICT_FILENAME = "/de/german.dict";
private static final String ADDED_DICT_FILENAME = "languagetool-language-modules/de/src/main/resources/org/languagetool/resource/de/added.txt";
private ExportGermanNouns() {
}
private List<String> getSortedWords() ... |
Set<String> words1 = getBinaryDictWords();
Set<String> words2 = getAddedDictWords();
List<String> sortedWords = new ArrayList<>();
sortedWords.addAll(words1);
sortedWords.addAll(words2);
Collections.sort(sortedWords);
return sortedWords;
| 854 | 92 | 946 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/FalseFriendExporter.java | FalseFriendExporter | main | class FalseFriendExporter {
private final static String filename =
"/home/dnaber/lt/git/languagetool/languagetool-core/src/main/resources/org/languagetool/rules/false-friends.xml";
public static void main(String[] args) throws IOException {<FILL_FUNCTION_BODY>}
private static void listRuleMessages... |
Language l1 = Languages.getLanguageForShortCode("nl");
Language l2 = Languages.getLanguageForShortCode("en");
listRuleMessages(l1, l2);
//listRuleMessages(l2, l1);
| 243 | 62 | 305 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/FilterFileByLanguage.java | FilterFileByLanguage | main | class FilterFileByLanguage {
private final static String fastTextBinary = "/home/languagetool/fasttext/fasttext";
private final static String fastTextModel = "/home/languagetool/fasttext/lid.176.bin";
private final static String nGramData = "/home/languagetool/model_ml50_new.zip";
private final static float sk... |
if (args.length != 2) {
System.out.println("Usage: " + FilterFileByLanguage.class.getSimpleName() + " <langCode> <file>");
System.exit(1);
}
String expectedLang = args[0];
File input = new File(args[1]);
File output = new File(input.getAbsoluteFile() + ".filtered");
LanguageIdentifi... | 149 | 395 | 544 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/Fuzzer.java | Fuzzer | run | class Fuzzer {
private final static String[] charList = "0,.-".split("");
private void run() throws IOException {<FILL_FUNCTION_BODY>}
String fuzz(Random rnd, int length) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < charList.length; i++) {
int randomPos = rnd.nextInt(charList.len... |
Random rnd = new Random(231);
for (Language language : Languages.get()) {
JLanguageTool lt = new JLanguageTool(language);
String text = fuzz(rnd, 1000);
long t1 = System.currentTimeMillis();
System.out.println(language.getShortCode() + " with text length of " + text.length() + "...");
... | 191 | 172 | 363 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/FuzzerForAnalysis.java | FuzzerForAnalysis | run | class FuzzerForAnalysis extends Fuzzer {
private void run() throws IOException {<FILL_FUNCTION_BODY>}
public static void main(String[] args) throws IOException {
new FuzzerForAnalysis().run();
}
} |
for (int i = 0; i < 10; i++) {
System.out.println("-----------------------");
Random rnd = new Random(i);
for (Language language : Languages.get()) {
JLanguageTool lt = new JLanguageTool(language);
Chunker chunker = language.getChunker();
if (chunker != null) {
S... | 66 | 280 | 346 | <methods>public non-sealed void <init>() ,public static void main(java.lang.String[]) throws java.io.IOException<variables>private static final java.lang.String[] charList |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/GenderWordFinder.java | GenderWordFinder | main | class GenderWordFinder {
public static void main(String[] args) throws IOException {<FILL_FUNCTION_BODY>}
} |
if (args.length != 1) {
System.out.println("Usage: " + GenderWordFinder.class.getSimpleName() + " <file>");
System.exit(1);
}
List<String> lines = Files.readAllLines(Paths.get(args[0]));
Set<String> candidates = new HashSet<>();
for (String line : lines) {
if (line.endsWith("e")) ... | 37 | 358 | 395 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/GermanCaseAmbiguityFinder.java | GermanCaseAmbiguityFinder | main | class GermanCaseAmbiguityFinder {
private static final String NGRAMS = "/home/dnaber/data/google-ngram-index/de";
public static void main(String[] args) throws IOException {<FILL_FUNCTION_BODY>}
} |
LuceneLanguageModel lm = new LuceneLanguageModel(new File(NGRAMS));
Dictionary dictionary = Dictionary.read(JLanguageTool.getDataBroker().getFromResourceDirAsUrl("/de/german.dict"));
DictionaryLookup dl = new DictionaryLookup(dictionary);
Map<String,String> lc = new HashMap<>();
Map<String,String> ... | 70 | 577 | 647 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/GermanElLeAdjectives.java | GermanElLeAdjectives | main | class GermanElLeAdjectives {
public static void main(String[] args) throws IOException {<FILL_FUNCTION_BODY>}
} |
List<String> lines = Files.readAllLines(Paths.get(args[0]));
Set<String> elWords = new HashSet<>();
for (String line : lines) {
line = line.trim();
if (line.endsWith("el")) {
elWords.add(line);
}
}
for (String line : lines) {
if (line.endsWith("le") && elWords.contai... | 39 | 146 | 185 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/GermanOldSpellingFinder.java | GermanOldSpellingFinder | main | class GermanOldSpellingFinder {
public static void main(String[] args) throws IOException {<FILL_FUNCTION_BODY>}
public static void main2(String[] args) throws IOException {
GermanyGerman lang = new GermanyGerman();
Synthesizer synth = lang.getSynthesizer();
String tmpWord = "hintergießen";
String... |
GermanyGerman lang = new GermanyGerman();
Synthesizer synth = lang.getSynthesizer();
List<String> words = Files.readAllLines(Paths.get(args[0]));
int i = 0;
for (String word : words) {
if (i++ % 1000 == 0) {
System.out.println(i + "...");
}
if (!word.matches("^[a-zöäü].*")... | 158 | 253 | 411 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/InvalidGermanVerbFinder.java | InvalidGermanVerbFinder | main | class InvalidGermanVerbFinder {
private static final String SPELLING_FILE = "/home/dnaber/lt/git/languagetool/languagetool-language-modules/de/src/main/resources/org/languagetool/resource/de/hunspell/spelling.txt";
private static final String NGRAM_DIR = "/home/dnaber/data/google-ngram-index/de/";
private static... |
LuceneLanguageModel lm = new LuceneLanguageModel(new File(NGRAM_DIR));
List<String> lines = Files.readAllLines(Paths.get(SPELLING_FILE));
for (String line : lines) {
if (line.startsWith("#")) {
continue;
}
if (line.contains("_")) {
line = line.replaceFirst("#.*", "");
... | 154 | 173 | 327 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/MissingEnglishPosFinder.java | MissingEnglishPosFinder | main | class MissingEnglishPosFinder {
public static void main(String[] args) throws IOException {<FILL_FUNCTION_BODY>}
private static boolean noTag(AnalyzedTokenReadings atr) {
return !atr.isTagged();
}
} |
if (args.length != 2) {
System.out.println("Usage: " + MissingEnglishPosFinder.class.getSimpleName() + " <file> <ngram_dir>");
System.exit(1);
}
List<String> lines = Files.readAllLines(Paths.get(args[0]));
//List<String> lines = Arrays.asList("bike", "nicexxx");
LuceneLanguageModel lm =... | 69 | 404 | 473 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/MissingGermanCompoundAdjectiveFinder.java | MissingGermanCompoundAdjectiveFinder | main | class MissingGermanCompoundAdjectiveFinder {
public static void main(String[] args) throws IOException {<FILL_FUNCTION_BODY>}
/*public static void main2(String[] args) throws IOException {
List<String> lines = Files.readAllLines(Paths.get("/tmp/x"));
GermanSpellerRule speller = new GermanSpellerRule(JLang... |
List<String> lines = Files.readAllLines(Paths.get(args[0]));
Tagger tagger = new GermanyGerman().getTagger();
Set<String> printed = new HashSet<>();
int j = 0;
int splitCount = 0;
GermanWordSplitter splitter = new GermanWordSplitter(false);
for (String line : lines) {
if (!StringTools... | 156 | 535 | 691 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/MissingGermanCompoundsFinder.java | MissingGermanCompoundsFinder | run | class MissingGermanCompoundsFinder {
private final GermanSpellerRule germanSpeller;
public MissingGermanCompoundsFinder() {
germanSpeller = new GermanSpellerRule(JLanguageTool.getMessageBundle(), new GermanyGerman());
}
public static void main(String[] args) throws IOException {
if (args.length != 1)... |
System.out.println("# compound words not accepted by LT speller");
BufferedReader reader = getReaderForFilename(filename);
String line;
GermanWordSplitter splitter = new GermanWordSplitter(false);
Map<String,Integer> firstPartCount = new HashMap<>();
while ((line = reader.readLine()) != null) {... | 337 | 426 | 763 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/MissingGermanPosFinder.java | MissingGermanPosFinder | main | class MissingGermanPosFinder {
public static void main(String[] args) throws IOException {<FILL_FUNCTION_BODY>}
} |
if (args.length != 2) {
System.out.println("Usage: " + MissingGermanPosFinder.class.getSimpleName() + " <file> <ngram_dir>");
System.exit(1);
}
List<String> lines = Files.readAllLines(Paths.get(args[0]));
//List<String> lines = Arrays.asList("Bundesrepublik", "Landwirtschaft", "Perl", "Haus... | 39 | 415 | 454 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/MissingGermanPosForms.java | MissingGermanPosForms | main | class MissingGermanPosForms {
public static void main(String[] args) throws IOException {<FILL_FUNCTION_BODY>}
} |
List<String> lines = Files.readAllLines(Paths.get("/home/dnaber/lt/git/languagetool/languagetool-language-modules/de/src/main/resources/org/languagetool/resource/de/hunspell/de_DE.dic"));
//List<String> lines = Arrays.asList("Beige", "Zoom", "Perl", "Haus", "Drücke", "Wisch");
GermanTagger tagger = new Ger... | 38 | 302 | 340 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/MissingGermanWords.java | MissingGermanWords | listMissingWords | class MissingGermanWords {
private final String filename;
private final boolean outputCombinedListing;
private final GermanSpellerRule germanSpeller;
private final GermanTagger germanTagger;
private final MorfologikAmericanSpellerRule englishSpeller;
public MissingGermanWords(String filename) throws IOExc... |
BufferedReader reader = getReaderForFilename(filename);
String line;
while ((line = reader.readLine()) != null) {
String word = wordFromLine(line);
boolean knownBySpeller = isKnownByGermanSpeller(word);
boolean knownByTagger = isKnownByGermanTagger(word);
if ((!knownBySpeller || !kn... | 954 | 221 | 1,175 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/MissingPortuguesePosFinder.java | MissingPortuguesePosFinder | getOccurrences | class MissingPortuguesePosFinder {
public static void main(String[] args) throws IOException {
if (args.length != 2) {
System.out.println("Usage: " + MissingPortuguesePosFinder.class.getSimpleName() + " <file> <gaia_file>");
System.out.println(" <gaia_file> is e.g. pt_br_wordlist.xml from https://g... |
List<String> lines = Files.readAllLines(gaiaXmlFile.toPath());
Map<String,Integer> map = new HashMap<>();
Pattern p = Pattern.compile("<w f=\"(\\d+)\" flags=\".*?\">(.*?)</w>");
for (String line : lines) {
line = line.trim();
if (line.startsWith("<w ")) {
Matcher matcher = p.matcher... | 577 | 254 | 831 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/MissingRussianPosFinder.java | MissingRussianPosFinder | main | class MissingRussianPosFinder {
public static void main(String[] args) throws IOException {<FILL_FUNCTION_BODY>}
private static boolean noTag(AnalyzedTokenReadings atr) {
return !atr.isTagged();
}
} |
if (args.length != 1) {
System.out.println("Usage: " + MissingRussianPosFinder.class.getSimpleName() + " <file> ");
System.exit(1);
}
List<String> lines = Files.readAllLines(Paths.get(args[0]));
RussianTagger tagger = new RussianTagger();
for (String word : lines) {
int origCount ... | 69 | 325 | 394 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/NGramLangIdentifierPerformanceTest.java | NGramLangIdentifierPerformanceTest | testPerformance | class NGramLangIdentifierPerformanceTest {
private static final File ngramZip = new File("/home/languagetool/ngram-lang-id/model_ml50_new.zip");
private static final Path input = Paths.get("/home/dnaber/data/corpus/tatoeba/20191014/sentences_shuf.txt");
private static final int limit = 10_000;
public void tes... |
System.out.println("Loading ngrams...");
NGramDetector ngram = new NGramDetector(ngramZip, 50);
System.out.println("Loaded.");
int i = 0;
double totalMillis = 0;
long totalLength = 0;
long totalRuns = 0;
System.out.println("Loading input...");
List<String> lines = Files.readAllLines... | 175 | 533 | 708 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/NoSuggestionRuleList.java | NoSuggestionRuleList | main | class NoSuggestionRuleList {
// format: rule_id,match_propability_as_float (and optionally more columns)
// e.g.:
// MORFOLOGIK_RULE_NL_NL,0.596809797834639
// EINDE_ZIN_ONVERWACHT,0.2137227907162415
private final static String POPULARITY_FILE = "/home/dnaber/Downloads/rule_matches_nl_1w_detailed.csv"; //... |
if (args.length < 1) {
System.out.println("Usage: " + NoSuggestionRuleList.class.getSimpleName() + " <langCodes>");
System.exit(1);
}
Map<String,Float> popularity = new HashMap<>();
if (POPULARITY_FILE != null) {
List<String> lines = Files.readAllLines(Paths.get(POPULARITY_FILE));
... | 308 | 734 | 1,042 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/ProhibitComparator.java | ProhibitComparator | main | class ProhibitComparator {
public static void main(String[] args) throws IOException {<FILL_FUNCTION_BODY>}
private static boolean hasPrefixLine(String word, List<String> expanded2) {
for (String line : expanded2) {
if (line.endsWith(".*") && word.startsWith(line.substring(0, line.length()-2))) {
... |
if (args.length != 2) {
System.out.println("Usage: " + ProhibitComparator.class.getName() + " <oldFile> <newFile>");
System.exit(1);
}
List<String> expanded1 = getExpandedLines(args[0]);
List<String> expanded2 = getExpandedLines(args[1]);
System.out.println("Words removed in " + args[1... | 273 | 195 | 468 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/RegexExpander.java | RegexExpander | main | class RegexExpander {
private final static List<String> entities = Arrays.asList(
" <!ENTITY conjuncoes_coordenativas \"(?:e(?:ntão|ntretanto)?|p(?:ois|orém|or(?:t|qu)anto)|mas|ou|nem|contudo|logo|todavia)\">");
private final static String wordListFile = "/home/dnaber/lt/pt-words.txt";
private fina... |
//Pattern tempP = Pattern.compile("(?:e(?:stere|ur|g)|(?:cent|sac)r|a(?:str|udi)|t(?:erm|urb)|f(?:il|ot)|i(?:ntr|d)|bronc|labi|mon|vas|zo)o");
//System.out.println(tempP.matcher("estereo").matches());
//System.exit(0);
List<String> lines = Files.readAllLines(Paths.get(wordListFile));
for (String s ... | 235 | 562 | 797 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/RuleActivityOverview.java | RuleActivityOverview | run | class RuleActivityOverview {
private static final int PAST_DAYS = 365/2;
RuleActivityOverview() {
}
private void run() {<FILL_FUNCTION_BODY>}
int getActivityFor(Language lang, int pastDays) {
try {
Calendar past = GregorianCalendar.getInstance();
past.add(Calendar.DAY_OF_MONTH, -pastDays);... |
System.out.println("Commits per language in the last " + PAST_DAYS + " days");
System.out.println("Date: " + new SimpleDateFormat("yyyy-MM-dd").format(new Date()));
List<String> sortedLanguages = new ArrayList<>();
for (Language element : Languages.get()) {
sortedLanguages.add(element.getNam... | 693 | 202 | 895 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/RuleDetails.java | RuleDetails | main | class RuleDetails {
private final List<Rule> rules;
public RuleDetails(Language lang, @Nullable String ngramPath) throws IOException {
JLanguageTool lt = new JLanguageTool(lang);
if (ngramPath != null) {
lt.activateLanguageModelRules(new File(ngramPath));
}
rules = lt.getAllRules();
}
@... |
Options options = new Options();
options.addRequiredOption("l", "language", true, "Language for rules");
options.addRequiredOption("f", "file", true, "Input file");
options.addRequiredOption("o", "output", true, "Output file");
options.addRequiredOption("c", "column", true, "Column in input file");... | 190 | 690 | 880 | <no_super_class> |
languagetool-org_languagetool | languagetool/languagetool-dev/src/main/java/org/languagetool/dev/SentenceChecker.java | SentenceChecker | run | class SentenceChecker {
private static final int BATCH_SIZE = 1000;
private void run(Language language, File file) throws IOException {<FILL_FUNCTION_BODY>}
public static void main(String[] args) throws IOException {
if (args.length != 2) {
System.err.println("Usage: " + SentenceChecker.class.getSi... |
JLanguageTool lt = new JLanguageTool(language);
try (Scanner scanner = new Scanner(file)) {
int count = 0;
long startTime = System.currentTimeMillis();
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
lt.check(line);
if (++count % BATCH_SIZE == 0) {
... | 174 | 166 | 340 | <no_super_class> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.