summaryrefslogtreecommitdiff
path: root/src/main
diff options
context:
space:
mode:
Diffstat (limited to 'src/main')
-rw-r--r--src/main/java/bjc/inflexion/v2/CategoricalNounInflection.java24
-rw-r--r--src/main/java/bjc/inflexion/v2/CompoundNounInflection.java106
-rw-r--r--src/main/java/bjc/inflexion/v2/Nouns.java136
3 files changed, 227 insertions, 39 deletions
diff --git a/src/main/java/bjc/inflexion/v2/CategoricalNounInflection.java b/src/main/java/bjc/inflexion/v2/CategoricalNounInflection.java
index 597b2a3..5cddc5e 100644
--- a/src/main/java/bjc/inflexion/v2/CategoricalNounInflection.java
+++ b/src/main/java/bjc/inflexion/v2/CategoricalNounInflection.java
@@ -31,23 +31,20 @@ public class CategoricalNounInflection implements NounInflection {
private InflectionAffix modernPlural;
private InflectionAffix classicalPlural;
- private boolean preferClassical;
-
/**
* Create a new categorical inflection.
*
* @param singlar
* The affix for the singular form.
+ *
* @param modrnPlural
* The affix for the modern plural.
+ *
* @param classiclPlural
* The affix for the classical plural.
- * @param prefrClassical
- * Whether or not the classical plural should be
- * preferred.
*/
public CategoricalNounInflection(InflectionAffix singlar, InflectionAffix modrnPlural,
- InflectionAffix classiclPlural, boolean prefrClassical) {
+ InflectionAffix classiclPlural) {
if(singlar == null)
throw new NullPointerException("Singular form must not be null");
else if(modrnPlural == null && classiclPlural == null)
@@ -56,7 +53,6 @@ public class CategoricalNounInflection implements NounInflection {
singular = singlar;
modernPlural = modrnPlural;
classicalPlural = classiclPlural;
- preferClassical = prefrClassical;
}
@Override
@@ -115,18 +111,10 @@ public class CategoricalNounInflection implements NounInflection {
@Override
public String pluralize(String singlar) {
if(singular.hasAffix(singlar)) {
- if(preferClassical) {
- if(classicalPlural == null) {
- return modernPlural.affix(singular.deaffix(singlar));
- } else {
- return classicalPlural.affix(singular.deaffix(singlar));
- }
+ if(modernPlural == null) {
+ return classicalPlural.affix(singular.deaffix(singlar));
} else {
- if(modernPlural == null) {
- return classicalPlural.affix(singular.deaffix(singlar));
- } else {
- return modernPlural.affix(singular.deaffix(singlar));
- }
+ return modernPlural.affix(singular.deaffix(singlar));
}
} else if(matchesPlural(singlar)) {
return singlar;
diff --git a/src/main/java/bjc/inflexion/v2/CompoundNounInflection.java b/src/main/java/bjc/inflexion/v2/CompoundNounInflection.java
index f82604e..afed0f8 100644
--- a/src/main/java/bjc/inflexion/v2/CompoundNounInflection.java
+++ b/src/main/java/bjc/inflexion/v2/CompoundNounInflection.java
@@ -26,6 +26,8 @@ import java.util.regex.Pattern;
*
*/
public class CompoundNounInflection implements NounInflection {
+ private static final String TOSTRING_FMT = "CompoundNounInflection [compoundMatcher=%s, singularPattern=%s,"
+ + " modernPluralPattern=%s, classicalPluralPattern=%s, hasPreposition=%s]";
/*
* Data stores for use.
*/
@@ -39,13 +41,16 @@ public class CompoundNounInflection implements NounInflection {
private String modernPluralPattern;
private String classicalPluralPattern;
- private boolean preferClassical;
-
/*
* Whether or not this inflection takes a preposition.
*/
private boolean hasPreposition;
+ /*
+ * Whether or not there is a scratch word in place.
+ */
+ private boolean hasScratch;
+
/**
* TODO fill in documentation.
*
@@ -55,20 +60,20 @@ public class CompoundNounInflection implements NounInflection {
* @param singularPattern
* @param modernPluralPattern
* @param classicalPluralPattern
- * @param preferClassical
* @param hasPreposition
+ * @param hasScrtch
*/
public CompoundNounInflection(Nouns nounDB, Prepositions prepositionDB, Pattern compoundMatcher,
String singularPattern, String modernPluralPattern, String classicalPluralPattern,
- boolean preferClassical, boolean hasPreposition) {
+ boolean hasPreposition, boolean hasScrtch) {
this.nounDB = nounDB;
this.prepositionDB = prepositionDB;
this.compoundMatcher = compoundMatcher;
this.singularPattern = singularPattern;
this.modernPluralPattern = modernPluralPattern;
this.classicalPluralPattern = classicalPluralPattern;
- this.preferClassical = preferClassical;
this.hasPreposition = hasPreposition;
+ hasScratch = hasScrtch;
}
@Override
@@ -108,9 +113,14 @@ public class CompoundNounInflection implements NounInflection {
@Override
public String singularize(String plural) {
Matcher matcher = compoundMatcher.matcher(plural);
- Noun actNoun = nounDB.getNoun(matcher.group("noun"));
+ Noun actNoun = getNoun(matcher);
- if(hasPreposition) {
+ if(hasPreposition && hasScratch) {
+ return String.format(singularPattern, actNoun.singular(), matcher.group("preposition"),
+ matcher.group("scratch"));
+ } else if(hasScratch) {
+ return String.format(singularPattern, actNoun.singular(), matcher.group("scratch"));
+ } else if(hasPreposition) {
return String.format(singularPattern, actNoun.singular(), matcher.group("preposition"));
} else {
return String.format(singularPattern, actNoun.singular());
@@ -122,13 +132,17 @@ public class CompoundNounInflection implements NounInflection {
Matcher matcher = compoundMatcher.matcher(singular);
Noun actNoun = getNoun(matcher);
- /*
- * TODO adapt this to take preferClassical into account.
- */
- if(hasPreposition) {
- return String.format(modernPluralPattern, actNoun.plural(), matcher.group("preposition"));
+ String patt = modernPluralPattern == null ? classicalPluralPattern : modernPluralPattern;
+
+ if(hasPreposition && hasScratch) {
+ return String.format(patt, actNoun.plural(), matcher.group("preposition"),
+ matcher.group("scratch"));
+ } else if(hasScratch) {
+ return String.format(patt, actNoun.plural(), matcher.group("scratch"));
+ } else if(hasPreposition) {
+ return String.format(patt, actNoun.plural(), matcher.group("preposition"));
} else {
- return String.format(modernPluralPattern, actNoun.plural());
+ return String.format(patt, actNoun.plural());
}
}
@@ -139,7 +153,12 @@ public class CompoundNounInflection implements NounInflection {
Matcher matcher = compoundMatcher.matcher(singular);
Noun actNoun = getNoun(matcher);
- if(hasPreposition) {
+ if(hasPreposition && hasScratch) {
+ return String.format(modernPluralPattern, actNoun.modernPlural(), matcher.group("preposition"),
+ matcher.group("scratch"));
+ } else if(hasScratch) {
+ return String.format(modernPluralPattern, actNoun.modernPlural(), matcher.group("scratch"));
+ } else if(hasPreposition) {
return String.format(modernPluralPattern, actNoun.modernPlural(), matcher.group("preposition"));
} else {
return String.format(modernPluralPattern, actNoun.modernPlural());
@@ -148,12 +167,18 @@ public class CompoundNounInflection implements NounInflection {
@Override
public String pluralizeClassical(String singular) {
- if(modernPluralPattern == null) return pluralizeModern(singular);
+ if(classicalPluralPattern == null) return pluralizeModern(singular);
Matcher matcher = compoundMatcher.matcher(singular);
Noun actNoun = getNoun(matcher);
- if(hasPreposition) {
+ if(hasPreposition && hasScratch) {
+ return String.format(classicalPluralPattern, actNoun.classicalPlural(),
+ matcher.group("preposition"), matcher.group("scratch"));
+ } else if(hasScratch) {
+ return String.format(classicalPluralPattern, actNoun.classicalPlural(),
+ matcher.group("scratch"));
+ } else if(hasPreposition) {
return String.format(classicalPluralPattern, actNoun.classicalPlural(),
matcher.group("preposition"));
} else {
@@ -167,4 +192,53 @@ public class CompoundNounInflection implements NounInflection {
Noun actNoun = nounDB.getNoun(matcher.group("noun"));
return actNoun;
}
+
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+
+ result = prime * result + ((classicalPluralPattern == null) ? 0 : classicalPluralPattern.hashCode());
+ result = prime * result + ((compoundMatcher == null) ? 0 : compoundMatcher.hashCode());
+ result = prime * result + (hasPreposition ? 1231 : 1237);
+ result = prime * result + ((modernPluralPattern == null) ? 0 : modernPluralPattern.hashCode());
+ result = prime * result + ((singularPattern == null) ? 0 : singularPattern.hashCode());
+
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if(this == obj) return true;
+ if(obj == null) return false;
+ if(!(obj instanceof CompoundNounInflection)) return false;
+
+ CompoundNounInflection other = (CompoundNounInflection) obj;
+
+ if(singularPattern == null) {
+ if(other.singularPattern != null) return false;
+ } else if(!singularPattern.equals(other.singularPattern)) return false;
+
+ if(classicalPluralPattern == null) {
+ if(other.classicalPluralPattern != null) return false;
+ } else if(!classicalPluralPattern.equals(other.classicalPluralPattern)) return false;
+
+ if(hasPreposition != other.hasPreposition) return false;
+
+ if(modernPluralPattern == null) {
+ if(other.modernPluralPattern != null) return false;
+ } else if(!modernPluralPattern.equals(other.modernPluralPattern)) return false;
+
+ if(compoundMatcher == null) {
+ if(other.compoundMatcher != null) return false;
+ } else if(!compoundMatcher.equals(other.compoundMatcher)) return false;
+
+ return true;
+ }
+
+ @Override
+ public String toString() {
+ return String.format(TOSTRING_FMT, compoundMatcher, singularPattern, modernPluralPattern,
+ classicalPluralPattern, hasPreposition);
+ }
} \ No newline at end of file
diff --git a/src/main/java/bjc/inflexion/v2/Nouns.java b/src/main/java/bjc/inflexion/v2/Nouns.java
index 6645d5c..3a97be3 100644
--- a/src/main/java/bjc/inflexion/v2/Nouns.java
+++ b/src/main/java/bjc/inflexion/v2/Nouns.java
@@ -16,6 +16,7 @@
package bjc.inflexion.v2;
import java.io.InputStream;
+import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
@@ -32,6 +33,8 @@ import static bjc.inflexion.v2.InflectionAffixes.*;
public class Nouns {
private static final DefaultNounInflection DEFAULT_INFLECTION = new DefaultNounInflection();
+ private Prepositions prepositionDB;
+
private Map<String, NounInflection> userIrregulars;
private List<NounInflection> userInflections;
@@ -40,8 +43,13 @@ public class Nouns {
/**
* Create a new empty noun DB.
+ *
+ * @param prepDB
+ * The source for prepositions.
*/
- public Nouns() {
+ public Nouns(Prepositions prepDB) {
+ prepositionDB = prepDB;
+
userIrregulars = new HashMap<>();
userInflections = new LinkedList<>();
@@ -91,7 +99,12 @@ public class Nouns {
if(ln.startsWith("#")) continue;
if(ln.equals("")) continue;
- handleLine(ln);
+ if(ln.contains("-")) {
+ handleLine(ln);
+ handleLine(ln.replace('-', ' '));
+ } else {
+ handleLine(ln);
+ }
}
}
}
@@ -128,7 +141,9 @@ public class Nouns {
classicalPlural = null;
}
- if(singular.startsWith("*")) {
+ if(singular.contains("(SING)")) {
+ handleCompoundPlural(singular, modernPlural, classicalPlural);
+ } else if(singular.startsWith("*")) {
handleCompletePlural(singular, modernPlural, classicalPlural);
} else if(singular.startsWith("-")) {
handleIncompletePlural(singular, modernPlural, classicalPlural);
@@ -137,6 +152,117 @@ public class Nouns {
}
}
+ private void handleCompoundPlural(String singular, String modernPlural, String classicalPlural) {
+ String actSingular = singular;
+ String actModern = modernPlural == null ? "" : modernPlural;
+ String actClassical = classicalPlural == null ? "" : classicalPlural;
+
+ String singularPatt = actSingular.replaceAll(Pattern.quote("(SING)"), "(?<noun>\\\\w+)");
+ String modernPatt = actModern.replaceAll(Pattern.quote("(PL)"), "(?<noun>\\\\w+)");
+ String classicalPatt = actClassical.replaceAll(Pattern.quote("(PL)"), "(?<noun>\\\\w+)");
+
+ actSingular = actSingular.replaceAll(Pattern.quote("(SING)"), "%1\\$s");
+ actModern = actModern.replaceAll(Pattern.quote("(PL)"), "%1\\$s");
+ actClassical = actClassical.replaceAll(Pattern.quote("(PL)"), "%1\\$s");
+
+ List<CompoundNounInflection> inflections = new ArrayList<>(3);
+
+ if(singular.contains("(PREP)")) {
+ handleCompoundPreposition(actSingular, actModern, actClassical, singularPatt, modernPatt,
+ classicalPatt, inflections);
+ } else {
+ handleCompound(actSingular, actModern, actClassical, singularPatt, modernPatt, classicalPatt,
+ inflections);
+ }
+
+ for(NounInflection inf : inflections) {
+ predefinedInflections.add(inf);
+ }
+ }
+
+ private void handleCompound(String actSingular, String actModern, String actClassical, String singularPatt,
+ String modernPatt, String classicalPatt, List<CompoundNounInflection> inflections) {
+ actModern = actModern.equals("") ? null : actModern;
+ actClassical = actClassical.equals("") ? null : actClassical;
+
+ CompoundNounInflection singularInflection = new CompoundNounInflection(this, prepositionDB,
+ Pattern.compile(singularPatt), actSingular, actModern, actClassical, false, false);
+
+ inflections.add(singularInflection);
+
+ if(!modernPatt.equals("")) {
+ CompoundNounInflection modernInflection = new CompoundNounInflection(this, prepositionDB,
+ Pattern.compile(modernPatt), actSingular, actModern, actClassical, false,
+ false);
+
+ inflections.add(modernInflection);
+ }
+
+ if(!classicalPatt.equals("")) {
+ CompoundNounInflection classicalInflection = new CompoundNounInflection(this, prepositionDB,
+ Pattern.compile(classicalPatt), actSingular, actModern, actClassical, false,
+ false);
+
+ inflections.add(classicalInflection);
+ }
+ }
+
+ private void handleCompoundPreposition(String actSingular, String actModern, String actClassical,
+ String singularPatt, String modernPatt, String classicalPatt,
+ List<CompoundNounInflection> inflections) {
+ singularPatt = singularPatt.replaceAll(Pattern.quote("(PREP)"), "(?<preposition>\\\\w+)");
+ modernPatt = modernPatt.replaceAll(Pattern.quote("(PREP)"), "(?<preposition>\\\\w+)");
+ classicalPatt = classicalPatt.replaceAll(Pattern.quote("(PREP)"), "(?<preposition>\\\\w+)");
+
+ actSingular = actSingular.replaceAll(Pattern.quote("(PREP)"), "%2\\$s");
+ actModern = actModern.replaceAll(Pattern.quote("(PREP)"), "%2\\$s");
+ actClassical = actClassical.replaceAll(Pattern.quote("(PREP)"), "%2\\$s");
+
+ if(singularPatt.contains("*")) {
+ singularPatt = singularPatt.replaceAll(Pattern.quote("*"), "(?<scratch>\\\\w+)");
+ modernPatt = modernPatt.replaceAll(Pattern.quote("*"), "(?<scratch>\\\\w+)");
+ classicalPatt = classicalPatt.replaceAll(Pattern.quote("*"), "(?<scratch>\\\\w+)");
+
+ actSingular = actSingular.replaceAll(Pattern.quote("*"), "%3\\$s");
+ actModern = actModern.replaceAll(Pattern.quote("*"), "%3\\$s");
+ actClassical = actClassical.replaceAll(Pattern.quote("*"), "%3\\$s");
+
+ actModern = actModern.equals("") ? null : actModern;
+ actClassical = actClassical.equals("") ? null : actClassical;
+
+ addCompoundInflections(actSingular, actModern, actClassical, singularPatt, modernPatt,
+ classicalPatt, inflections, true);
+ } else {
+ addCompoundInflections(actSingular, actModern, actClassical, singularPatt, modernPatt,
+ classicalPatt, inflections, false);
+ }
+ }
+
+ private void addCompoundInflections(String actSingular, String actModern, String actClassical,
+ String singularPatt, String modernPatt, String classicalPatt,
+ List<CompoundNounInflection> inflections, boolean hasScratch) {
+ CompoundNounInflection singularInflection = new CompoundNounInflection(this, prepositionDB,
+ Pattern.compile(singularPatt), actSingular, actModern, actClassical, true, hasScratch);
+
+ inflections.add(singularInflection);
+
+ if(!modernPatt.equals("")) {
+ CompoundNounInflection modernInflection = new CompoundNounInflection(this, prepositionDB,
+ Pattern.compile(modernPatt), actSingular, actModern, actClassical, true,
+ hasScratch);
+
+ inflections.add(modernInflection);
+ }
+
+ if(!classicalPatt.equals("")) {
+ CompoundNounInflection classicalInflection = new CompoundNounInflection(this, prepositionDB,
+ Pattern.compile(classicalPatt), actSingular, actModern, actClassical, true,
+ hasScratch);
+
+ inflections.add(classicalInflection);
+ }
+ }
+
private void handleIncompletePlural(String singular, String modernPlural, String classicalPlural) {
InflectionAffix singularAffix = incomplete(singular.substring(1));
@@ -147,7 +273,7 @@ public class Nouns {
if(classicalPlural != null) classicalAffix = incomplete(classicalPlural.substring(1));
CategoricalNounInflection inflection = new CategoricalNounInflection(singularAffix, modernAffix,
- classicalAffix, false);
+ classicalAffix);
predefinedInflections.add(inflection);
}
@@ -162,7 +288,7 @@ public class Nouns {
if(classicalPlural != null) classicalAffix = complete(classicalPlural.substring(1));
CategoricalNounInflection inflection = new CategoricalNounInflection(singularAffix, modernAffix,
- classicalAffix, false);
+ classicalAffix);
predefinedInflections.add(inflection);
}
generated by cgit v1.2.3 (git 2.25.1) at 2026-05-10 05:12:08 +0000