Format

5 files changed, 164 insertions, 103 deletions

diff --git a/src/main/java/bjc/inflexion/nouns/CategoricalNounInflection.java b/src/main/java/bjc/inflexion/nouns/CategoricalNounInflection.java
index 1989596..2651cc5 100644
--- a/src/main/java/bjc/inflexion/nouns/CategoricalNounInflection.java
+++ b/src/main/java/bjc/inflexion/nouns/CategoricalNounInflection.java
@@ -23,13 +23,14 @@ package bjc.inflexion.nouns;
  *
  */
 public class CategoricalNounInflection implements NounInflection {
-	private static final String TOSTRING_FMT = "CategoricalNounInflection [singular=%s, modernPlural=%s,"
-			+ " classicalPlural=%s]";
+	private static final String TOSTRING_FMT =
+	        "CategoricalNounInflection [singular=%s, modernPlural=%s,"
+	        + " classicalPlural=%s]";
 
 	private final InflectionAffix singular;
 
-	private final InflectionAffix	modernPlural;
-	private final InflectionAffix	classicalPlural;
+	private final InflectionAffix       modernPlural;
+	private final InflectionAffix       classicalPlural;
 
 	/**
 	 * Create a new categorical inflection.
@@ -43,8 +44,9 @@ public class CategoricalNounInflection implements NounInflection {
 	 * @param classiclPlural
 	 *                The affix for the classical plural.
 	 */
-	public CategoricalNounInflection(final InflectionAffix singlar, final InflectionAffix modrnPlural,
-			final InflectionAffix classiclPlural) {
+	public CategoricalNounInflection(final InflectionAffix singlar,
+	                                 final InflectionAffix modrnPlural,
+	                                 final InflectionAffix classiclPlural) {
 		if (singlar == null)
 			throw new NullPointerException("Singular form must not be null");
 		else if (modrnPlural == null && classiclPlural == null)
@@ -73,7 +75,8 @@ public class CategoricalNounInflection implements NounInflection {
 		else if (matchesPlural(noun))
 			return false;
 		else {
-			final String msg = String.format("Noun '%s' doesn't belong to this inflection", noun, this);
+			final String msg = String.format("Noun '%s' doesn't belong to this inflection", noun,
+			                                 this);
 
 			throw new InflectionException(msg);
 		}
@@ -86,7 +89,8 @@ public class CategoricalNounInflection implements NounInflection {
 		else if (matchesPlural(noun))
 			return true;
 		else {
-			final String msg = String.format("Noun '%s' doesn't belong to this inflection", noun, this);
+			final String msg = String.format("Noun '%s' doesn't belong to this inflection", noun,
+			                                 this);
 
 			throw new InflectionException(msg);
 		}
@@ -101,7 +105,8 @@ public class CategoricalNounInflection implements NounInflection {
 		else if (classicalPlural != null && classicalPlural.hasAffix(plural))
 			return singular.affix(classicalPlural.deaffix(plural));
 		else {
-			final String msg = String.format("Noun '%s' doesn't belong to this inflection", plural, this);
+			final String msg = String.format("Noun '%s' doesn't belong to this inflection", plural,
+			                                 this);
 
 			throw new InflectionException(msg);
 		}
@@ -116,7 +121,8 @@ public class CategoricalNounInflection implements NounInflection {
 		} else if (matchesPlural(singlar))
 			return singlar;
 		else {
-			final String msg = String.format("Noun '%s' doesn't belong to this inflection", singlar, this);
+			final String msg = String.format("Noun '%s' doesn't belong to this inflection", singlar,
+			                                 this);
 
 			throw new InflectionException(msg);
 		}
@@ -147,7 +153,9 @@ public class CategoricalNounInflection implements NounInflection {
 	@Override
 	public boolean equals(final Object obj) {
 		if (this == obj) return true;
+
 		if (obj == null) return false;
+
 		if (!(obj instanceof CategoricalNounInflection)) return false;
 
 		final CategoricalNounInflection other = (CategoricalNounInflection) obj;
@@ -168,6 +176,7 @@ public class CategoricalNounInflection implements NounInflection {
 		if (modernPlural == null) return pluralizeClassical(singlar);
 
 		String actSinglar = singlar;
+
 		if (isPlural(singlar)) {
 			actSinglar = singularize(singlar);
 		}
@@ -180,6 +189,7 @@ public class CategoricalNounInflection implements NounInflection {
 		if (classicalPlural == null) return pluralizeModern(singlar);
 
 		String actSinglar = singlar;
+
 		if (isPlural(singlar)) {
 			actSinglar = singularize(singlar);
 		}
diff --git a/src/main/java/bjc/inflexion/nouns/CompoundNounInflection.java b/src/main/java/bjc/inflexion/nouns/CompoundNounInflection.java
index da551a3..e3fc574 100644
--- a/src/main/java/bjc/inflexion/nouns/CompoundNounInflection.java
+++ b/src/main/java/bjc/inflexion/nouns/CompoundNounInflection.java
@@ -26,20 +26,21 @@ 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]";
+	private static final String TOSTRING_FMT =
+	        "CompoundNounInflection [compoundMatcher=%s, singularPattern=%s,"
+	        + " modernPluralPattern=%s, classicalPluralPattern=%s, hasPreposition=%s]";
 	/*
 	 * Data stores for use.
 	 */
-	private final Nouns		nunDB;
-	private final Prepositions	pepositionDB;
+	private final Nouns         nunDB;
+	private final Prepositions  pepositionDB;
 
 	private final Pattern cmpoundMatcher;
 
 	private final String sigularPattern;
 
-	private final String	mdernPluralPattern;
-	private final String	clasicalPluralPattern;
+	private final String        mdernPluralPattern;
+	private final String        clasicalPluralPattern;
 
 	/*
 	 * Whether or not this inflection takes a preposition.
@@ -64,8 +65,10 @@ public class CompoundNounInflection implements NounInflection {
 	 * @param hasScrtch
 	 */
 	public CompoundNounInflection(final Nouns nounDB, final Prepositions prepositionDB,
-			final Pattern compoundMatcher, final String singularPattern, final String modernPluralPattern,
-			final String classicalPluralPattern, final boolean hasPreposition, final boolean hasScrtch) {
+	                              final Pattern compoundMatcher, final String singularPattern,
+	                              final String modernPluralPattern,
+	                              final String classicalPluralPattern, final boolean hasPreposition,
+	                              final boolean hasScrtch) {
 		nunDB = nounDB;
 		pepositionDB = prepositionDB;
 		cmpoundMatcher = compoundMatcher;
@@ -116,7 +119,7 @@ public class CompoundNounInflection implements NounInflection {
 
 		if (haPreposition && hasScratch)
 			return String.format(sigularPattern, actNoun.singular(), matcher.group("preposition"),
-					matcher.group("scratch"));
+			                     matcher.group("scratch"));
 		else if (hasScratch)
 			return String.format(sigularPattern, actNoun.singular(), matcher.group("scratch"));
 		else if (haPreposition)
@@ -129,11 +132,12 @@ public class CompoundNounInflection implements NounInflection {
 		final Matcher matcher = cmpoundMatcher.matcher(singular);
 		final Noun actNoun = getNoun(matcher);
 
-		final String patt = mdernPluralPattern == null ? clasicalPluralPattern : mdernPluralPattern;
+		final String patt = mdernPluralPattern == null ? clasicalPluralPattern :
+		                    mdernPluralPattern;
 
 		if (haPreposition && hasScratch)
 			return String.format(patt, actNoun.plural(), matcher.group("preposition"),
-					matcher.group("scratch"));
+			                     matcher.group("scratch"));
 		else if (hasScratch)
 			return String.format(patt, actNoun.plural(), matcher.group("scratch"));
 		else if (haPreposition)
@@ -149,12 +153,15 @@ public class CompoundNounInflection implements NounInflection {
 		final Noun actNoun = getNoun(matcher);
 
 		if (haPreposition && hasScratch)
-			return String.format(mdernPluralPattern, actNoun.modernPlural(), matcher.group("preposition"),
-					matcher.group("scratch"));
+			return String.format(mdernPluralPattern, actNoun.modernPlural(),
+			                     matcher.group("preposition"),
+			                     matcher.group("scratch"));
 		else if (hasScratch)
-			return String.format(mdernPluralPattern, actNoun.modernPlural(), matcher.group("scratch"));
+			return String.format(mdernPluralPattern, actNoun.modernPlural(),
+			                     matcher.group("scratch"));
 		else if (haPreposition)
-			return String.format(mdernPluralPattern, actNoun.modernPlural(), matcher.group("preposition"));
+			return String.format(mdernPluralPattern, actNoun.modernPlural(),
+			                     matcher.group("preposition"));
 		else return String.format(mdernPluralPattern, actNoun.modernPlural());
 	}
 
@@ -167,13 +174,13 @@ public class CompoundNounInflection implements NounInflection {
 
 		if (haPreposition && hasScratch)
 			return String.format(clasicalPluralPattern, actNoun.classicalPlural(),
-					matcher.group("preposition"), matcher.group("scratch"));
+			                     matcher.group("preposition"), matcher.group("scratch"));
 		else if (hasScratch)
 			return String.format(clasicalPluralPattern, actNoun.classicalPlural(),
-					matcher.group("scratch"));
+			                     matcher.group("scratch"));
 		else if (haPreposition)
 			return String.format(clasicalPluralPattern, actNoun.classicalPlural(),
-					matcher.group("preposition"));
+			                     matcher.group("preposition"));
 		else return String.format(clasicalPluralPattern, actNoun.classicalPlural());
 	}
 
@@ -189,10 +196,12 @@ public class CompoundNounInflection implements NounInflection {
 		final int prime = 31;
 		int result = 1;
 
-		result = prime * result + (clasicalPluralPattern == null ? 0 : clasicalPluralPattern.hashCode());
+		result = prime * result + (clasicalPluralPattern == null ? 0 :
+		                           clasicalPluralPattern.hashCode());
 		result = prime * result + (cmpoundMatcher == null ? 0 : cmpoundMatcher.hashCode());
 		result = prime * result + (haPreposition ? 1231 : 1237);
-		result = prime * result + (mdernPluralPattern == null ? 0 : mdernPluralPattern.hashCode());
+		result = prime * result + (mdernPluralPattern == null ? 0 :
+		                           mdernPluralPattern.hashCode());
 		result = prime * result + (sigularPattern == null ? 0 : sigularPattern.hashCode());
 
 		return result;
@@ -201,7 +210,9 @@ public class CompoundNounInflection implements NounInflection {
 	@Override
 	public boolean equals(final Object obj) {
 		if (this == obj) return true;
+
 		if (obj == null) return false;
+
 		if (!(obj instanceof CompoundNounInflection)) return false;
 
 		final CompoundNounInflection other = (CompoundNounInflection) obj;
@@ -230,6 +241,6 @@ public class CompoundNounInflection implements NounInflection {
 	@Override
 	public String toString() {
 		return String.format(TOSTRING_FMT, cmpoundMatcher, sigularPattern, mdernPluralPattern,
-				clasicalPluralPattern, haPreposition);
+		                     clasicalPluralPattern, haPreposition);
 	}
 }
\ No newline at end of file
diff --git a/src/main/java/bjc/inflexion/nouns/IrregularNounInflection.java b/src/main/java/bjc/inflexion/nouns/IrregularNounInflection.java
index b64b341..f38a138 100644
--- a/src/main/java/bjc/inflexion/nouns/IrregularNounInflection.java
+++ b/src/main/java/bjc/inflexion/nouns/IrregularNounInflection.java
@@ -22,13 +22,14 @@ package bjc.inflexion.nouns;
  *
  */
 public class IrregularNounInflection implements NounInflection {
-	private static final String TOSTRING_FMT = "IrregularNounInflection [singular=%s, modernPlural=%s,"
-			+ " classicalPlural=%s, preferClassical=%s]";
+	private static final String TOSTRING_FMT =
+	        "IrregularNounInflection [singular=%s, modernPlural=%s,"
+	        + " classicalPlural=%s, preferClassical=%s]";
 
 	private final String singular;
 
-	private final String	modernPlural;
-	private final String	classicalPlural;
+	private final String        modernPlural;
+	private final String        classicalPlural;
 
 	private final boolean preferClassical;
 
@@ -48,9 +49,11 @@ public class IrregularNounInflection implements NounInflection {
 	 *                Whether the classical form should be preferred if it
 	 *                is available.
 	 */
-	public IrregularNounInflection(final String singlar, final String modrnPlural, final String classiclPlural,
-			final boolean prefrClassical) {
+	public IrregularNounInflection(final String singlar, final String modrnPlural,
+	                               final String classiclPlural,
+	                               final boolean prefrClassical) {
 		if (singlar == null) throw new NullPointerException("Singular form must not be null");
+
 		if (modrnPlural == null && classiclPlural == null)
 			throw new NullPointerException("One of modern/classical plural forms must not be null");
 
@@ -79,7 +82,7 @@ public class IrregularNounInflection implements NounInflection {
 			return false;
 		else {
 			final String msg = String.format("Noun '%s' doesn't belong to this inflection '%s'", noun,
-					this);
+			                                 this);
 
 			throw new InflectionException(msg);
 		}
@@ -93,7 +96,7 @@ public class IrregularNounInflection implements NounInflection {
 			return true;
 		else {
 			final String msg = String.format("Noun '%s' doesn't belong to this inflection '%s'", noun,
-					this);
+			                                 this);
 
 			throw new InflectionException(msg);
 		}
@@ -106,8 +109,9 @@ public class IrregularNounInflection implements NounInflection {
 		else if (matchesPlural(plural))
 			return singular;
 		else {
-			final String msg = String.format("Noun '%s' doesn't belong to this inflection '%s'", plural,
-					this);
+			final String msg = String.format("Noun '%s' doesn't belong to this inflection '%s'",
+			                                 plural,
+			                                 this);
 
 			throw new InflectionException(msg);
 		}
@@ -120,8 +124,9 @@ public class IrregularNounInflection implements NounInflection {
 		else if (matchesPlural(singlar))
 			return getPlural();
 		else {
-			final String msg = String.format("Noun '%s' doesn't belong to this inflection '%s'", singlar,
-					this);
+			final String msg = String.format("Noun '%s' doesn't belong to this inflection '%s'",
+			                                 singlar,
+			                                 this);
 
 			throw new InflectionException(msg);
 		}
@@ -143,7 +148,8 @@ public class IrregularNounInflection implements NounInflection {
 
 	@Override
 	public String toString() {
-		return String.format(TOSTRING_FMT, singular, modernPlural, classicalPlural, preferClassical);
+		return String.format(TOSTRING_FMT, singular, modernPlural, classicalPlural,
+		                     preferClassical);
 	}
 
 	@Override
@@ -161,7 +167,9 @@ public class IrregularNounInflection implements NounInflection {
 	@Override
 	public boolean equals(final Object obj) {
 		if (this == obj) return true;
+
 		if (obj == null) return false;
+
 		if (!(obj instanceof IrregularNounInflection)) return false;
 
 		final IrregularNounInflection other = (IrregularNounInflection) obj;
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
+}
diff --git a/src/main/java/bjc/inflexion/nouns/SimpleInflectionAffix.java b/src/main/java/bjc/inflexion/nouns/SimpleInflectionAffix.java
index 00b9689..e50fe5c 100644
--- a/src/main/java/bjc/inflexion/nouns/SimpleInflectionAffix.java
+++ b/src/main/java/bjc/inflexion/nouns/SimpleInflectionAffix.java
@@ -25,7 +25,8 @@ import java.util.regex.Pattern;
  *
  */
 public class SimpleInflectionAffix implements InflectionAffix {
-	private static final String TOSTRING_FMT = "SimpleInflectionAffix [affixTemplate=%s, affixMatcher=%s]";
+	private static final String TOSTRING_FMT =
+	        "SimpleInflectionAffix [affixTemplate=%s, affixMatcher=%s]";
 
 	private final String affixTmplate;
 
@@ -85,7 +86,9 @@ public class SimpleInflectionAffix implements InflectionAffix {
 	@Override
 	public boolean equals(final Object obj) {
 		if (this == obj) return true;
+
 		if (obj == null) return false;
+
 		if (!(obj instanceof SimpleInflectionAffix)) return false;
 
 		final SimpleInflectionAffix other = (SimpleInflectionAffix) obj;