Cleanup

1 files changed, 184 insertions, 123 deletions

diff --git a/src/main/java/bjc/inflexion/nouns/Nouns.java b/src/main/java/bjc/inflexion/nouns/Nouns.java
index d63b704..aeb2f2f 100644
--- a/src/main/java/bjc/inflexion/nouns/Nouns.java
+++ b/src/main/java/bjc/inflexion/nouns/Nouns.java
@@ -28,34 +28,41 @@ import java.util.Scanner;
 import java.util.regex.Pattern;
 
 /**
- * @author EVE
+ * Utilities for doing things with nouns.
  *
+ * @author EVE
  */
 public class Nouns {
+	/* The default inflection. */
 	private static final DefaultNounInflection DEFAULT_INFLECTION = new
-	DefaultNounInflection();
+		DefaultNounInflection();
 
+	/* Database of prepositions. */
 	private final Prepositions prepositionDB;
-
+	
+	/* User defined irregular inflections.   */
 	private final Map<String, NounInflection>   userIrregulars;
+	/* User defined categorical inflections. */
 	private final List<NounInflection>          userInflections;
 
+	/* Predefined irregular inflections.   */
 	private final Map<String, NounInflection>   predefinedIrregulars;
+	/* Predefined categorical inflections. */
 	private final List<NounInflection>          predefinedInflections;
 
 	/**
 	 * Create a new empty noun DB.
 	 *
 	 * @param prepDB
-	 *                The source for prepositions.
+	 * 	The source for prepositions.
 	 */
 	public Nouns(final Prepositions prepDB) {
 		prepositionDB = prepDB;
 
-		userIrregulars = new HashMap<>();
+		userIrregulars  = new HashMap<>();
 		userInflections = new LinkedList<>();
 
-		predefinedIrregulars = new HashMap<>();
+		predefinedIrregulars  = new HashMap<>();
 		predefinedInflections = new LinkedList<>();
 	}
 
@@ -63,12 +70,13 @@ public class Nouns {
 	 * Retrieve a noun with its inflection from the database of inflections.
 	 *
 	 * @param noun
-	 *                The noun to retrieve.
+	 * 	The noun to retrieve.
 	 *
-	 * @return The noun with its inflection.
+	 * @return
+	 * 	The noun with its inflection.
 	 *
 	 * @throws InflectionException
-	 *                 If the noun matched no inflection.
+	 * 	If the noun matched no inflection.
 	 */
 	public Noun getNoun(final String noun) {
 		if (userIrregulars.containsKey(noun)) return new Noun(noun, userIrregulars.get(noun));
@@ -77,8 +85,9 @@ public class Nouns {
 			if (inflect.matches(noun)) return new Noun(noun, inflect);
 		}
 
-		if (predefinedIrregulars.containsKey(noun)) return new Noun(noun,
-			                predefinedIrregulars.get(noun));
+		if (predefinedIrregulars.containsKey(noun)) {
+			return new Noun(noun, predefinedIrregulars.get(noun));
+		}
 
 		for (final NounInflection inflect : predefinedInflections) {
 			if (inflect.matches(noun)) return new Noun(noun, inflect);
@@ -91,24 +100,19 @@ public class Nouns {
 	 * Load the contents of the stream into this DB.
 	 *
 	 * @param stream
-	 *                The stream to load from.
+	 * 	The stream to load from.
 	 */
 	public void loadFromStream(final InputStream stream) {
 		try (Scanner scn = new Scanner(stream)) {
 			while (scn.hasNextLine()) {
 				final String ln = scn.nextLine().trim();
 
-				/*
-				 * Ignore comments and blank lines.
-				 */
-				if (ln.startsWith("#")) {
-					continue;
-				}
-
-				if (ln.equals("")) {
+				/* Ignore comments and blank lines. */
+				if (ln.startsWith("#") || ln.equals("")) {
 					continue;
 				}
 
+				/* Handle being able to replace -'s with spaces. */
 				if (ln.contains("-")) {
 					handleLine(ln);
 					handleLine(ln.replace('-', ' '));
@@ -119,6 +123,7 @@ public class Nouns {
 		}
 	}
 
+	/* Handle a line from a noun database. */
 	private void handleLine(final String ln) {
 		final String[] parts = ln.split(Pattern.quote("=>"));
 
@@ -129,9 +134,9 @@ public class Nouns {
 		}
 
 		final String singular = parts[0].trim();
-		final String plural = parts[1].trim();
+		final String plural   = parts[1].trim();
 
-		String modernPlural = "";
+		String modernPlural    = "";
 		String classicalPlural = "";
 
 		if (plural.contains("|")) {
@@ -140,7 +145,7 @@ public class Nouns {
 			if (plurals.length == 1) {
 				modernPlural = plurals[0].trim();
 			} else {
-				modernPlural = plurals[0].trim();
+				modernPlural    = plurals[0].trim();
 				classicalPlural = plurals[1].trim();
 			}
 
@@ -152,7 +157,7 @@ public class Nouns {
 				classicalPlural = null;
 			}
 		} else {
-			modernPlural = plural;
+			modernPlural    = plural;
 			classicalPlural = null;
 		}
 
@@ -167,31 +172,41 @@ public class Nouns {
 		}
 	}
 
+	/*
+	 * Handle a compound inflection.
+	 */
 	private void handleCompoundPlural(final String singular, final String modernPlural,
 	                                  final String classicalPlural) {
-		String actSingular = singular;
-		String actModern = modernPlural == null ? "" : modernPlural;
+		String actSingular  = singular;
+		String actModern    = modernPlural == null ? "" : modernPlural;
 		String actClassical = classicalPlural == null ? "" : classicalPlural;
 
-		final String singularPatt = actSingular.replaceAll(Pattern.quote("(SING)"),
-		                            "(?<noun>\\\\w+)");
-		final String modernPatt = actModern.replaceAll(Pattern.quote("(PL)"), "(?<noun>\\\\w+)");
-		final String classicalPatt = actClassical.replaceAll(Pattern.quote("(PL)"),
-		                             "(?<noun>\\\\w+)");
+		final String singularPatt =
+			actSingular.replaceAll(Pattern.quote("(SING)"),
+					"(?<noun>\\\\w+)");
+
+		final String modernPatt =
+			actModern.replaceAll(Pattern.quote("(PL)"),
+					"(?<noun>\\\\w+)");
+
+		final 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");
+		actSingular  = actSingular.replaceAll(Pattern.quote("(SING)"), "%1\\$s");
+		actModern    = actModern.replaceAll(Pattern.quote("(PL)"), "%1\\$s");
 		actClassical = actClassical.replaceAll(Pattern.quote("(PL)"), "%1\\$s");
 
 		final List<CompoundNounInflection> inflections = new ArrayList<>(3);
 
 		if (singular.contains("(PREP)")) {
-			handleCompoundPreposition(actSingular, actModern, actClassical, singularPatt, modernPatt,
-			                          classicalPatt, inflections);
+			handleCompoundPreposition(actSingular, actModern,
+					actClassical, singularPatt, modernPatt,
+					classicalPatt, inflections);
 		} else {
-			handleCompound(actSingular, actModern, actClassical, singularPatt, modernPatt,
-			               classicalPatt,
-			               inflections);
+			handleCompound(actSingular, actModern, actClassical,
+					singularPatt, modernPatt, classicalPatt,
+					inflections);
 		}
 
 		for (final NounInflection inf : inflections) {
@@ -199,129 +214,173 @@ public class Nouns {
 		}
 	}
 
-	private void handleCompound(final String actSinglar, final String actModrn,
-	                            final String actClasscal,
-	                            final String singularPtt, final String modernPtt, final String classicalPtt,
-	                            final List<CompoundNounInflection> inflections) {
+	/*
+	 * Handle a compound inflection.
+	 */
+	private void handleCompound(final String actSinglar, final String
+			actModrn, final String actClasscal, final String
+			singularPtt, final String modernPtt, final String
+			classicalPtt, final List<CompoundNounInflection>
+			inflections) {
 		if (singularPtt.contains("*")) {
-			final String singularPatt = singularPtt.replaceAll(Pattern.quote("*"),
-			                            "(?<scratch>\\\\w+)");
-			final String modernPatt = modernPtt.replaceAll(Pattern.quote("*"), "(?<scratch>\\\\w+)");
-			final String classicalPatt = classicalPtt.replaceAll(Pattern.quote("*"),
-			                             "(?<scratch>\\\\w+)");
-
-			final String actSingular = actSinglar.replaceAll(Pattern.quote("*"), "%2\\$s");
-			final String actModern = actModrn.replaceAll(Pattern.quote("*"), "%2\\$s");
+			final String singularPatt =
+				singularPtt.replaceAll(Pattern.quote("*"),
+						"(?<scratch>\\\\w+)");
+
+			final String modernPatt =
+				modernPtt.replaceAll(Pattern.quote("*"),
+						"(?<scratch>\\\\w+)");
+
+			final String classicalPatt =
+				classicalPtt.replaceAll(Pattern.quote("*"),
+						"(?<scratch>\\\\w+)");
+
+			final String actSingular  = actSinglar.replaceAll(Pattern.quote("*"), "%2\\$s");
+			final String actModern    = actModrn.replaceAll(Pattern.quote("*"), "%2\\$s");
 			final String actClassical = actClasscal.replaceAll(Pattern.quote("*"), "%2\\$s");
 
-			handleNonpluralCompound(actSingular, actModern, actClassical, singularPatt, modernPatt,
-			                        classicalPatt, inflections, true);
+			handleNonpluralCompound(actSingular, actModern,
+					actClassical, singularPatt, modernPatt,
+					classicalPatt, inflections, true);
 		} else {
-			handleNonpluralCompound(actSinglar, actModrn, actClasscal, singularPtt, modernPtt,
-			                        classicalPtt,
-			                        inflections, false);
+			handleNonpluralCompound(actSinglar, actModrn,
+					actClasscal, singularPtt, modernPtt,
+					classicalPtt, inflections, false);
 		}
 	}
 
-	private void handleNonpluralCompound(final String actSinglar, final String actModrn,
-	                                     final String actClasscal,
-	                                     final String singularPatt, final String modernPatt, final String classicalPatt,
-	                                     final List<CompoundNounInflection> inflections, final boolean hasScratch) {
-		final String actModern = actModrn.equals("") ? null : actModrn;
+	/* Handle a non-plural compound inflection. */
+	private void handleNonpluralCompound(final String actSinglar, final
+			String actModrn, final String actClasscal, final String
+			singularPatt, final String modernPatt, final String
+			classicalPatt, final List<CompoundNounInflection>
+			inflections, final boolean hasScratch) {
+		final String actModern    = actModrn.equals("") ? null : actModrn;
 		final String actClassical = actClasscal.equals("") ? null : actClasscal;
 
-		final CompoundNounInflection singularInflection = new CompoundNounInflection(this,
-		                prepositionDB,
-		                Pattern.compile(singularPatt), actSinglar, actModern, actClassical, false, hasScratch);
+		final Pattern singPt = Pattern.compile(singularPatt);
+
+		final CompoundNounInflection singularInflection = new
+			CompoundNounInflection(this, prepositionDB, singPt,
+					actSinglar, actModern, actClassical,
+					false, hasScratch);
 
 		inflections.add(singularInflection);
 
 		if (!modernPatt.equals("")) {
-			final CompoundNounInflection modernInflection = new CompoundNounInflection(this,
-			                prepositionDB,
-			                Pattern.compile(modernPatt), actSinglar, actModern, actClassical, false,
-			                hasScratch);
+			final Pattern modPt = Pattern.compile(modernPatt);
+
+			final CompoundNounInflection modernInflection = new
+				CompoundNounInflection(this, prepositionDB,
+						modPt, actSinglar, actModern,
+						actClassical, false,
+						hasScratch);
 
 			inflections.add(modernInflection);
 		}
 
 		if (!classicalPatt.equals("")) {
-			final CompoundNounInflection classicalInflection = new CompoundNounInflection(this,
-			                prepositionDB, Pattern.compile(classicalPatt), actSinglar, actModern,
-			                actClassical, false, hasScratch);
+			final Pattern clasPt = Pattern.compile(classicalPatt);
+
+			final CompoundNounInflection classicalInflection = new
+				CompoundNounInflection(this, prepositionDB,
+						clasPt, actSinglar, actModern,
+						actClassical, false,
+						hasScratch);
 
 			inflections.add(classicalInflection);
 		}
 	}
 
-	private void handleCompoundPreposition(final String actSinglar, final String actModrn,
-	                                       final String actClasscal,
-	                                       final String singularPtt, final String modernPtt, final String classicalPtt,
-	                                       final List<CompoundNounInflection> inflections) {
-		String singularPatt = singularPtt.replaceAll(Pattern.quote("(PREP)"),
-		                      "(?<preposition>\\\\w+)");
-		String modernPatt = modernPtt.replaceAll(Pattern.quote("(PREP)"),
-		                    "(?<preposition>\\\\w+)");
-		String classicalPatt = classicalPtt.replaceAll(Pattern.quote("(PREP)"),
-		                       "(?<preposition>\\\\w+)");
-
-		String actSingular = actSinglar.replaceAll(Pattern.quote("(PREP)"), "%2\\$s");
-		String actModern = actModrn.replaceAll(Pattern.quote("(PREP)"), "%2\\$s");
+	/*
+	 * Handle a compound plural with a preposition. */
+	private void handleCompoundPreposition(final String actSinglar, final
+			String actModrn, final String actClasscal, final String
+			singularPtt, final String modernPtt, final String
+			classicalPtt, final List<CompoundNounInflection>
+			inflections) {
+		String singularPatt =
+			singularPtt.replaceAll(Pattern.quote("(PREP)"),
+					"(?<preposition>\\\\w+)");
+
+		String modernPatt =
+			modernPtt.replaceAll(Pattern.quote("(PREP)"),
+					"(?<preposition>\\\\w+)");
+
+		String classicalPatt =
+			classicalPtt.replaceAll(Pattern.quote("(PREP)"),
+					"(?<preposition>\\\\w+)");
+
+		String actSingular  = actSinglar.replaceAll(Pattern.quote("(PREP)"), "%2\\$s");
+		String actModern    = actModrn.replaceAll(Pattern.quote("(PREP)"), "%2\\$s");
 		String actClassical = actClasscal.replaceAll(Pattern.quote("(PREP)"), "%2\\$s");
 
 		if (singularPatt.contains("*")) {
-			singularPatt = singularPatt.replaceAll(Pattern.quote("*"), "(?<scratch>\\\\w+)");
-			modernPatt = modernPatt.replaceAll(Pattern.quote("*"), "(?<scratch>\\\\w+)");
+			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");
+			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;
+			actModern    = actModern.equals("") ? null : actModern;
 			actClassical = actClassical.equals("") ? null : actClassical;
 
-			addCompoundInflections(actSingular, actModern, actClassical, singularPatt, modernPatt,
-			                       classicalPatt, inflections, true);
+			addCompoundInflections(actSingular, actModern,
+					actClassical, singularPatt, modernPatt,
+					classicalPatt, inflections, true);
 		} else {
-			addCompoundInflections(actSingular, actModern, actClassical, singularPatt, modernPatt,
-			                       classicalPatt, inflections, false);
+			addCompoundInflections(actSingular, actModern,
+					actClassical, singularPatt, modernPatt,
+					classicalPatt, inflections, false);
 		}
 	}
 
-	private void addCompoundInflections(final String actSingular, final String actModern,
-	                                    final String actClassical,
-	                                    final String singularPatt, final String modernPatt, final String classicalPatt,
-	                                    final List<CompoundNounInflection> inflections, final boolean hasScratch) {
-		final CompoundNounInflection singularInflection = new CompoundNounInflection(this,
-		                prepositionDB,
-		                Pattern.compile(singularPatt), actSingular, actModern, actClassical, true, hasScratch);
+	/* Do adding a compound inflection. */
+	private void addCompoundInflections(final String actSingular, final
+			String actModern, final String actClassical, final
+			String singularPatt, final String modernPatt, final
+			String classicalPatt, final List<CompoundNounInflection>
+			inflections, final boolean hasScratch) {
+		Pattern singPt = Pattern.compile(singularPatt);
+
+		final CompoundNounInflection singularInflection = new
+			CompoundNounInflection(this, prepositionDB, singPt,
+					actSingular, actModern, actClassical,
+					true, hasScratch);
 
 		inflections.add(singularInflection);
 
 		if (!modernPatt.equals("")) {
-			final CompoundNounInflection modernInflection = new CompoundNounInflection(this,
-			                prepositionDB,
-			                Pattern.compile(modernPatt), actSingular, actModern, actClassical, true,
-			                hasScratch);
+			Pattern modPt = Pattern.compile(modernPatt);
+
+			final CompoundNounInflection modernInflection = new
+				CompoundNounInflection(this, prepositionDB,
+						modPt, actSingular, actModern,
+						actClassical, true, hasScratch);
 
 			inflections.add(modernInflection);
 		}
 
 		if (!classicalPatt.equals("")) {
-			final CompoundNounInflection classicalInflection = new CompoundNounInflection(this,
-			                prepositionDB, Pattern.compile(classicalPatt), actSingular, actModern,
-			                actClassical, true, hasScratch);
+			Pattern clasPt = Pattern.compile(classicalPatt);
+
+			final CompoundNounInflection classicalInflection = new
+				CompoundNounInflection(this, prepositionDB,
+						clasPt, actSingular, actModern,
+						actClassical, true, hasScratch);
 
 			inflections.add(classicalInflection);
 		}
 	}
 
-	private void handleIncompletePlural(final String singular, final String modernPlural,
-	                                    final String classicalPlural) {
+	/* Handle an incomplete plural. */
+	private void handleIncompletePlural(final String singular, final String
+			modernPlural, final String classicalPlural) {
 		final InflectionAffix singularAffix = incomplete(singular.substring(1));
 
-		InflectionAffix modernAffix = null;
+		InflectionAffix modernAffix    = null;
 		InflectionAffix classicalAffix = null;
 
 		if (modernPlural != null) {
@@ -332,18 +391,19 @@ public class Nouns {
 			classicalAffix = incomplete(classicalPlural.substring(1));
 		}
 
-		final CategoricalNounInflection inflection = new CategoricalNounInflection(singularAffix,
-		                modernAffix,
-		                classicalAffix);
+		final CategoricalNounInflection inflection = new
+			CategoricalNounInflection(singularAffix, modernAffix,
+					classicalAffix);
 
 		predefinedInflections.add(inflection);
 	}
 
-	private void handleCompletePlural(final String singular, final String modernPlural,
-	                                  final String classicalPlural) {
+	/* Handle a complete plural. */
+	private void handleCompletePlural(final String singular, final String
+			modernPlural, final String classicalPlural) {
 		final InflectionAffix singularAffix = complete(singular.substring(1));
 
-		InflectionAffix modernAffix = null;
+		InflectionAffix modernAffix    = null;
 		InflectionAffix classicalAffix = null;
 
 		if (modernPlural != null) {
@@ -354,18 +414,19 @@ public class Nouns {
 			classicalAffix = complete(classicalPlural.substring(1));
 		}
 
-		final CategoricalNounInflection inflection = new CategoricalNounInflection(singularAffix,
-		                modernAffix,
-		                classicalAffix);
+		final CategoricalNounInflection inflection = new
+			CategoricalNounInflection(singularAffix, modernAffix,
+					classicalAffix);
 
 		predefinedInflections.add(inflection);
 	}
 
-	private void handleIrregularPlural(final String singular, final String modernPlural,
-	                                   final String classicalPlural) {
-		final IrregularNounInflection inflection = new IrregularNounInflection(singular,
-		                modernPlural,
-		                classicalPlural, false);
+	/* Handle an irregular plural. */
+	private void handleIrregularPlural(final String singular, final String
+			modernPlural, final String classicalPlural) {
+		final IrregularNounInflection inflection = new
+			IrregularNounInflection(singular, modernPlural,
+					classicalPlural, false);
 
 		if (!predefinedIrregulars.containsKey(singular)) {
 			predefinedIrregulars.put(singular, inflection);