Format

1 files changed, 87 insertions, 58 deletions

diff --git a/src/main/java/bjc/inflexion/nouns/Nouns.java b/src/main/java/bjc/inflexion/nouns/Nouns.java
index 0fbfddd..d63b704 100644
--- a/src/main/java/bjc/inflexion/nouns/Nouns.java
+++ b/src/main/java/bjc/inflexion/nouns/Nouns.java
@@ -32,15 +32,16 @@ import java.util.regex.Pattern;
  *
  */
 public class Nouns {
-	private static final DefaultNounInflection DEFAULT_INFLECTION = new DefaultNounInflection();
+	private static final DefaultNounInflection DEFAULT_INFLECTION = new
+	DefaultNounInflection();
 
 	private final Prepositions prepositionDB;
 
-	private final Map<String, NounInflection>	userIrregulars;
-	private final List<NounInflection>		userInflections;
+	private final Map<String, NounInflection>   userIrregulars;
+	private final List<NounInflection>          userInflections;
 
-	private final Map<String, NounInflection>	predefinedIrregulars;
-	private final List<NounInflection>		predefinedInflections;
+	private final Map<String, NounInflection>   predefinedIrregulars;
+	private final List<NounInflection>          predefinedInflections;
 
 	/**
 	 * Create a new empty noun DB.
@@ -71,11 +72,14 @@ public class Nouns {
 	 */
 	public Noun getNoun(final String noun) {
 		if (userIrregulars.containsKey(noun)) return new Noun(noun, userIrregulars.get(noun));
+
 		for (final NounInflection inflect : userInflections) {
 			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);
 		}
@@ -100,6 +104,7 @@ public class Nouns {
 				if (ln.startsWith("#")) {
 					continue;
 				}
+
 				if (ln.equals("")) {
 					continue;
 				}
@@ -142,6 +147,7 @@ public class Nouns {
 			if (modernPlural.equals("")) {
 				modernPlural = null;
 			}
+
 			if (classicalPlural.equals("")) {
 				classicalPlural = null;
 			}
@@ -162,14 +168,16 @@ public class Nouns {
 	}
 
 	private void handleCompoundPlural(final String singular, final String modernPlural,
-			final String classicalPlural) {
+	                                  final String classicalPlural) {
 		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 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 classicalPatt = actClassical.replaceAll(Pattern.quote("(PL)"),
+		                             "(?<noun>\\\\w+)");
 
 		actSingular = actSingular.replaceAll(Pattern.quote("(SING)"), "%1\\$s");
 		actModern = actModern.replaceAll(Pattern.quote("(PL)"), "%1\\$s");
@@ -179,10 +187,11 @@ public class Nouns {
 
 		if (singular.contains("(PREP)")) {
 			handleCompoundPreposition(actSingular, actModern, actClassical, singularPatt, modernPatt,
-					classicalPatt, inflections);
+			                          classicalPatt, inflections);
 		} else {
-			handleCompound(actSingular, actModern, actClassical, singularPatt, modernPatt, classicalPatt,
-					inflections);
+			handleCompound(actSingular, actModern, actClassical, singularPatt, modernPatt,
+			               classicalPatt,
+			               inflections);
 		}
 
 		for (final NounInflection inf : inflections) {
@@ -190,60 +199,71 @@ 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) {
+	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 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 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);
+			                        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) {
+	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 CompoundNounInflection singularInflection = new CompoundNounInflection(this,
+		                prepositionDB,
+		                Pattern.compile(singularPatt), 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 CompoundNounInflection modernInflection = new CompoundNounInflection(this,
+			                prepositionDB,
+			                Pattern.compile(modernPatt), 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);
+			                prepositionDB, Pattern.compile(classicalPatt), 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+)");
+	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");
@@ -262,40 +282,43 @@ public class Nouns {
 			actClassical = actClassical.equals("") ? null : actClassical;
 
 			addCompoundInflections(actSingular, actModern, actClassical, singularPatt, modernPatt,
-					classicalPatt, inflections, true);
+			                       classicalPatt, inflections, true);
 		} else {
 			addCompoundInflections(actSingular, actModern, actClassical, singularPatt, modernPatt,
-					classicalPatt, inflections, false);
+			                       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);
+	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);
 
 		inflections.add(singularInflection);
 
 		if (!modernPatt.equals("")) {
-			final CompoundNounInflection modernInflection = new CompoundNounInflection(this, prepositionDB,
-					Pattern.compile(modernPatt), actSingular, actModern, actClassical, true,
-					hasScratch);
+			final CompoundNounInflection modernInflection = new CompoundNounInflection(this,
+			                prepositionDB,
+			                Pattern.compile(modernPatt), 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);
+			                prepositionDB, Pattern.compile(classicalPatt), actSingular, actModern,
+			                actClassical, true, hasScratch);
 
 			inflections.add(classicalInflection);
 		}
 	}
 
 	private void handleIncompletePlural(final String singular, final String modernPlural,
-			final String classicalPlural) {
+	                                    final String classicalPlural) {
 		final InflectionAffix singularAffix = incomplete(singular.substring(1));
 
 		InflectionAffix modernAffix = null;
@@ -304,18 +327,20 @@ public class Nouns {
 		if (modernPlural != null) {
 			modernAffix = incomplete(modernPlural.substring(1));
 		}
+
 		if (classicalPlural != null) {
 			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) {
+	                                  final String classicalPlural) {
 		final InflectionAffix singularAffix = complete(singular.substring(1));
 
 		InflectionAffix modernAffix = null;
@@ -324,20 +349,23 @@ public class Nouns {
 		if (modernPlural != null) {
 			modernAffix = complete(modernPlural.substring(1));
 		}
+
 		if (classicalPlural != null) {
 			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);
+	                                   final String classicalPlural) {
+		final IrregularNounInflection inflection = new IrregularNounInflection(singular,
+		                modernPlural,
+		                classicalPlural, false);
 
 		if (!predefinedIrregulars.containsKey(singular)) {
 			predefinedIrregulars.put(singular, inflection);
@@ -346,8 +374,9 @@ public class Nouns {
 		if (modernPlural != null && !predefinedIrregulars.containsKey(modernPlural)) {
 			predefinedIrregulars.put(modernPlural, inflection);
 		}
+
 		if (classicalPlural != null && !predefinedIrregulars.containsKey(classicalPlural)) {
 			predefinedIrregulars.put(classicalPlural, inflection);
 		}
 	}
-}
\ No newline at end of file
+}