Fix a few pluralization bugs.

Now, just have to support character classes in suffix rules.

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);
 	}