Cleanup

14 files changed, 476 insertions, 465 deletions

diff --git a/src/main/java/bjc/inflexion/EnglishUtils.java b/src/main/java/bjc/inflexion/EnglishUtils.java
index c782162..e3c0823 100644
--- a/src/main/java/bjc/inflexion/EnglishUtils.java
+++ b/src/main/java/bjc/inflexion/EnglishUtils.java
@@ -50,37 +50,33 @@ public class EnglishUtils {
 
 	/**
 	 * Convert small integers to words.
-	 * 
+	 *
 	 * @param num
 	 *                The number to convert.
-	 * 
+	 *
 	 * @return The word for the number, if it's less than ten.
 	 */
-	public static String smallIntToWord(int num) {
-		if (num >= 0 && num <= 10) {
-			return smallNums[num];
-		}
+	public static String smallIntToWord(final int num) {
+		if (num >= 0 && num <= 10) return smallNums[num];
 
 		return Integer.toString(num);
 	}
 
 	/**
 	 * Summarize an integer.
-	 * 
+	 *
 	 * @param num
 	 *                The number to summarize.
-	 * 
+	 *
 	 * @param atEnd
 	 *                Whether or not the integer is at the end of a string.
-	 * 
+	 *
 	 * @return A string summarizing the integer.
 	 */
-	public static String intSummarize(int num, boolean atEnd) {
-		String[] nums = atEnd ? endSummaryNums : summaryNums;
+	public static String intSummarize(final int num, final boolean atEnd) {
+		final String[] nums = atEnd ? endSummaryNums : summaryNums;
 
-		if (num >= 0 && num < 10) {
-			return nums[summaryMap[num]];
-		}
+		if (num >= 0 && num < 10) return nums[summaryMap[num]];
 
 		return "many";
 	}
diff --git a/src/main/java/bjc/inflexion/InflectionML.java b/src/main/java/bjc/inflexion/InflectionML.java
index 4ceda7a..5705cab 100644
--- a/src/main/java/bjc/inflexion/InflectionML.java
+++ b/src/main/java/bjc/inflexion/InflectionML.java
@@ -40,7 +40,7 @@ public class InflectionML {
 	private static Nouns nounDB;
 
 	static {
-		Prepositions prepositionDB = new Prepositions();
+		final Prepositions prepositionDB = new Prepositions();
 		prepositionDB.loadFromStream(InflexionTester.class.getResourceAsStream("/prepositions.txt"));
 
 		nounDB = new Nouns(prepositionDB);
@@ -49,26 +49,26 @@ public class InflectionML {
 
 	/**
 	 * Apply inflection to marked forms in the string.
-	 * 
+	 *
 	 * @param form
 	 *                The string to inflect.
-	 * 
+	 *
 	 * @return The inflected string.
 	 */
-	public static String inflect(String form) {
-		Matcher formMatcher = FORM_MARKER.matcher(form);
+	public static String inflect(final String form) {
+		final Matcher formMatcher = FORM_MARKER.matcher(form);
 
-		StringBuffer formBuffer = new StringBuffer();
+		final StringBuffer formBuffer = new StringBuffer();
 
 		int curCount = 1;
 		boolean inflectSingular = true;
 
 		while (formMatcher.find()) {
-			String command = formMatcher.group("command");
-			String options = formMatcher.group("options");
-			String text = formMatcher.group("text");
+			final String command = formMatcher.group("command");
+			final String options = formMatcher.group("options");
+			final String text = formMatcher.group("text");
 
-			Set<String> optionSet = new HashSet<>();
+			final Set<String> optionSet = new HashSet<>();
 			for (int i = 1; i <= options.length(); i++) {
 				optionSet.add(options.substring(i - 1, i));
 			}
@@ -87,9 +87,11 @@ public class InflectionML {
 					}
 
 					if (curCount != 1) {
-						if (curCount == 0 && optionSet.contains("s"))
+						if (curCount == 0 && optionSet.contains("s")) {
 							inflectSingular = true;
-						else inflectSingular = false;
+						} else {
+							inflectSingular = false;
+						}
 					} else {
 						inflectSingular = true;
 					}
@@ -105,7 +107,9 @@ public class InflectionML {
 					String rep = text;
 
 					if (optionSet.contains("n")) {
-						if (curCount == 0) rep = "no";
+						if (curCount == 0) {
+							rep = "no";
+						}
 					}
 
 					if (optionSet.contains("s")) {
@@ -120,7 +124,7 @@ public class InflectionML {
 						 */
 					}
 
-					boolean shouldOverride = !(rep.equals("no") || rep.equals("a")
+					final boolean shouldOverride = !(rep.equals("no") || rep.equals("a")
 							|| rep.equals("an"));
 
 					if (optionSet.contains("w") && shouldOverride) {
@@ -132,13 +136,13 @@ public class InflectionML {
 					}
 
 					formMatcher.appendReplacement(formBuffer, rep);
-				} catch (NumberFormatException nfex) {
+				} catch (final NumberFormatException nfex) {
 					throw new InflectionException("Count setter must take a number as a parameter",
 							nfex);
 				}
 				break;
 			case "N":
-				Noun noun = nounDB.getNoun(text);
+				final Noun noun = nounDB.getNoun(text);
 				if (optionSet.contains("p") || !inflectSingular) {
 					if (optionSet.contains("c")) {
 						formMatcher.appendReplacement(formBuffer, noun.classicalPlural());
@@ -150,7 +154,7 @@ public class InflectionML {
 				}
 				break;
 			default:
-				String msg = String.format("Unknown command '%s'", command);
+				final String msg = String.format("Unknown command '%s'", command);
 
 				throw new InflectionException(msg);
 			}
@@ -163,16 +167,16 @@ public class InflectionML {
 
 	/**
 	 * Alias method to format a string, then inflect it.
-	 * 
+	 *
 	 * @param format
 	 *                The combined format/inflection string.
-	 * 
+	 *
 	 * @param objects
 	 *                The parameters for the format string.
-	 * 
+	 *
 	 * @return The string, formatted & inflected.
 	 */
-	public static String iprintf(String format, Object... objects) {
+	public static String iprintf(final String format, final Object... objects) {
 		return inflect(String.format(format, objects));
 	}
 }
diff --git a/src/main/java/bjc/inflexion/nouns/CategoricalNounInflection.java b/src/main/java/bjc/inflexion/nouns/CategoricalNounInflection.java
index 136d393..1989596 100644
--- a/src/main/java/bjc/inflexion/nouns/CategoricalNounInflection.java
+++ b/src/main/java/bjc/inflexion/nouns/CategoricalNounInflection.java
@@ -18,7 +18,7 @@ package bjc.inflexion.nouns;
 /**
  * Implementation of {@link NounInflection} for nouns matched by a regular
  * expression.
- * 
+ *
  * @author EVE
  *
  */
@@ -26,28 +26,28 @@ public class CategoricalNounInflection implements NounInflection {
 	private static final String TOSTRING_FMT = "CategoricalNounInflection [singular=%s, modernPlural=%s,"
 			+ " classicalPlural=%s]";
 
-	private InflectionAffix singular;
+	private final InflectionAffix singular;
 
-	private InflectionAffix	modernPlural;
-	private InflectionAffix	classicalPlural;
+	private final InflectionAffix	modernPlural;
+	private final InflectionAffix	classicalPlural;
 
 	/**
 	 * 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.
 	 */
-	public CategoricalNounInflection(InflectionAffix singlar, InflectionAffix modrnPlural,
-			InflectionAffix classiclPlural) {
-		if(singlar == null)
+	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)
+		else if (modrnPlural == null && classiclPlural == null)
 			throw new NullPointerException("One of modern/classical plural forms must not be null");
 
 		singular = singlar;
@@ -56,79 +56,76 @@ public class CategoricalNounInflection implements NounInflection {
 	}
 
 	@Override
-	public boolean matches(String noun) {
-		if(singular.hasAffix(noun))
+	public boolean matches(final String noun) {
+		if (singular.hasAffix(noun))
 			return true;
-		else if(modernPlural != null && modernPlural.hasAffix(noun))
+		else if (modernPlural != null && modernPlural.hasAffix(noun))
 			return true;
-		else if(classicalPlural != null && classicalPlural.hasAffix(noun))
+		else if (classicalPlural != null && classicalPlural.hasAffix(noun))
 			return true;
-		else
-			return false;
+		else return false;
 	}
 
 	@Override
-	public boolean isSingular(String noun) {
-		if(singular.hasAffix(noun))
+	public boolean isSingular(final String noun) {
+		if (singular.hasAffix(noun))
 			return true;
-		else if(matchesPlural(noun))
+		else if (matchesPlural(noun))
 			return false;
 		else {
-			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);
 		}
 	}
 
 	@Override
-	public boolean isPlural(String noun) {
-		if(singular.hasAffix(noun))
+	public boolean isPlural(final String noun) {
+		if (singular.hasAffix(noun))
 			return false;
-		else if(matchesPlural(noun))
+		else if (matchesPlural(noun))
 			return true;
 		else {
-			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);
 		}
 	}
 
 	@Override
-	public String singularize(String plural) {
-		if(singular.hasAffix(plural))
+	public String singularize(final String plural) {
+		if (singular.hasAffix(plural))
 			return plural;
-		else if(modernPlural != null && modernPlural.hasAffix(plural))
+		else if (modernPlural != null && modernPlural.hasAffix(plural))
 			return singular.affix(modernPlural.deaffix(plural));
-		else if(classicalPlural != null && classicalPlural.hasAffix(plural))
+		else if (classicalPlural != null && classicalPlural.hasAffix(plural))
 			return singular.affix(classicalPlural.deaffix(plural));
 		else {
-			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);
 		}
 	}
 
 	@Override
-	public String pluralize(String singlar) {
-		if(singular.hasAffix(singlar)) {
-			if(modernPlural == null) {
-				return classicalPlural.affix(singular.deaffix(singlar));
-			} else {
-				return modernPlural.affix(singular.deaffix(singlar));
-			}
-		} else if(matchesPlural(singlar)) {
+	public String pluralize(final String singlar) {
+		if (singular.hasAffix(singlar)) {
+			if (modernPlural == null) return classicalPlural.affix(singular.deaffix(singlar));
+
+			return modernPlural.affix(singular.deaffix(singlar));
+		} else if (matchesPlural(singlar))
 			return singlar;
-		} else {
-			String msg = String.format("Noun '%s' doesn't belong to this inflection", singlar, this);
+		else {
+			final String msg = String.format("Noun '%s' doesn't belong to this inflection", singlar, this);
 
 			throw new InflectionException(msg);
 		}
 	}
 
-	private boolean matchesPlural(String noun) {
-		boolean hasModernPlural = modernPlural != null && modernPlural.hasAffix(noun);
+	private boolean matchesPlural(final String noun) {
+		final boolean hasModernPlural = modernPlural != null && modernPlural.hasAffix(noun);
 
-		return hasModernPlural || (classicalPlural != null && classicalPlural.hasAffix(noun));
+		return hasModernPlural || classicalPlural != null && classicalPlural.hasAffix(noun);
 	}
 
 	@Override
@@ -141,37 +138,37 @@ public class CategoricalNounInflection implements NounInflection {
 		final int prime = 31;
 		int result = 1;
 
-		result = prime * result + ((classicalPlural == null) ? 0 : classicalPlural.hashCode());
-		result = prime * result + ((modernPlural == null) ? 0 : modernPlural.hashCode());
+		result = prime * result + (classicalPlural == null ? 0 : classicalPlural.hashCode());
+		result = prime * result + (modernPlural == null ? 0 : modernPlural.hashCode());
 
 		return result;
 	}
 
 	@Override
-	public boolean equals(Object obj) {
-		if(this == obj) return true;
-		if(obj == null) return false;
-		if(!(obj instanceof CategoricalNounInflection)) return false;
+	public boolean equals(final Object obj) {
+		if (this == obj) return true;
+		if (obj == null) return false;
+		if (!(obj instanceof CategoricalNounInflection)) return false;
 
-		CategoricalNounInflection other = (CategoricalNounInflection) obj;
+		final CategoricalNounInflection other = (CategoricalNounInflection) obj;
 
-		if(classicalPlural == null) {
-			if(other.classicalPlural != null) return false;
-		} else if(!classicalPlural.equals(other.classicalPlural)) return false;
+		if (classicalPlural == null) {
+			if (other.classicalPlural != null) return false;
+		} else if (!classicalPlural.equals(other.classicalPlural)) return false;
 
-		if(modernPlural == null) {
-			if(other.modernPlural != null) return false;
-		} else if(!modernPlural.equals(other.modernPlural)) return false;
+		if (modernPlural == null) {
+			if (other.modernPlural != null) return false;
+		} else if (!modernPlural.equals(other.modernPlural)) return false;
 
 		return true;
 	}
 
 	@Override
-	public String pluralizeModern(String singlar) {
-		if(modernPlural == null) return pluralizeClassical(singlar);
+	public String pluralizeModern(final String singlar) {
+		if (modernPlural == null) return pluralizeClassical(singlar);
 
 		String actSinglar = singlar;
-		if(isPlural(singlar)) {
+		if (isPlural(singlar)) {
 			actSinglar = singularize(singlar);
 		}
 
@@ -179,11 +176,11 @@ public class CategoricalNounInflection implements NounInflection {
 	}
 
 	@Override
-	public String pluralizeClassical(String singlar) {
-		if(classicalPlural == null) return pluralizeModern(singlar);
+	public String pluralizeClassical(final String singlar) {
+		if (classicalPlural == null) return pluralizeModern(singlar);
 
 		String actSinglar = singlar;
-		if(isPlural(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 2eb0813..da551a3 100644
--- a/src/main/java/bjc/inflexion/nouns/CompoundNounInflection.java
+++ b/src/main/java/bjc/inflexion/nouns/CompoundNounInflection.java
@@ -21,7 +21,7 @@ import java.util.regex.Pattern;
 /**
  * Implementation of {@link NounInflection} for words that don't inflect at the
  * end.
- * 
+ *
  * @author EVE
  *
  */
@@ -31,29 +31,29 @@ public class CompoundNounInflection implements NounInflection {
 	/*
 	 * Data stores for use.
 	 */
-	private Nouns		nounDB;
-	private Prepositions	prepositionDB;
+	private final Nouns		nunDB;
+	private final Prepositions	pepositionDB;
 
-	private Pattern compoundMatcher;
+	private final Pattern cmpoundMatcher;
 
-	private String singularPattern;
+	private final String sigularPattern;
 
-	private String	modernPluralPattern;
-	private String	classicalPluralPattern;
+	private final String	mdernPluralPattern;
+	private final String	clasicalPluralPattern;
 
 	/*
 	 * Whether or not this inflection takes a preposition.
 	 */
-	private boolean hasPreposition;
+	private final boolean haPreposition;
 
 	/*
 	 * Whether or not there is a scratch word in place.
 	 */
-	private boolean hasScratch;
+	private final boolean hasScratch;
 
 	/**
 	 * TODO fill in documentation.
-	 * 
+	 *
 	 * @param nounDB
 	 * @param prepositionDB
 	 * @param compoundMatcher
@@ -63,133 +63,124 @@ public class CompoundNounInflection implements NounInflection {
 	 * @param hasPreposition
 	 * @param hasScrtch
 	 */
-	public CompoundNounInflection(Nouns nounDB, Prepositions prepositionDB, Pattern compoundMatcher,
-			String singularPattern, String modernPluralPattern, String classicalPluralPattern,
-			boolean hasPreposition, boolean hasScrtch) {
-		this.nounDB = nounDB;
-		this.prepositionDB = prepositionDB;
-		this.compoundMatcher = compoundMatcher;
-		this.singularPattern = singularPattern;
-		this.modernPluralPattern = modernPluralPattern;
-		this.classicalPluralPattern = classicalPluralPattern;
-		this.hasPreposition = hasPreposition;
+	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) {
+		nunDB = nounDB;
+		pepositionDB = prepositionDB;
+		cmpoundMatcher = compoundMatcher;
+		sigularPattern = singularPattern;
+		mdernPluralPattern = modernPluralPattern;
+		clasicalPluralPattern = classicalPluralPattern;
+		haPreposition = hasPreposition;
 		hasScratch = hasScrtch;
 	}
 
 	@Override
-	public boolean matches(String noun) {
-		Matcher matcher = compoundMatcher.matcher(noun);
+	public boolean matches(final String noun) {
+		final Matcher matcher = cmpoundMatcher.matcher(noun);
+
+		if (matcher.matches()) {
+			final Noun actNoun = nunDB.getNoun(matcher.group("noun"));
 
-		if(matcher.matches()) {
-			Noun actNoun = nounDB.getNoun(matcher.group("noun"));
+			if (actNoun == null) return false;
 
-			if(actNoun == null) return false;
+			if (haPreposition) return pepositionDB.isPreposition(matcher.group("preposition"));
 
-			if(hasPreposition) {
-				return prepositionDB.isPreposition(matcher.group("preposition"));
-			} else
-				return true;
-		} else {
-			return false;
+			return true;
 		}
+
+		return false;
 	}
 
 	@Override
-	public boolean isSingular(String noun) {
-		Matcher matcher = compoundMatcher.matcher(noun);
-		Noun actNoun = nounDB.getNoun(matcher.group("noun"));
+	public boolean isSingular(final String noun) {
+		final Matcher matcher = cmpoundMatcher.matcher(noun);
+		final Noun actNoun = nunDB.getNoun(matcher.group("noun"));
 
 		return actNoun.isSingular();
 	}
 
 	@Override
-	public boolean isPlural(String noun) {
-		Matcher matcher = compoundMatcher.matcher(noun);
-		Noun actNoun = nounDB.getNoun(matcher.group("noun"));
+	public boolean isPlural(final String noun) {
+		final Matcher matcher = cmpoundMatcher.matcher(noun);
+		final Noun actNoun = nunDB.getNoun(matcher.group("noun"));
 
 		return actNoun.isPlural();
 	}
 
 	@Override
-	public String singularize(String plural) {
-		Matcher matcher = compoundMatcher.matcher(plural);
-		Noun actNoun = getNoun(matcher);
+	public String singularize(final String plural) {
+		final Matcher matcher = cmpoundMatcher.matcher(plural);
+		final Noun actNoun = getNoun(matcher);
 
-		if(hasPreposition && hasScratch) {
-			return String.format(singularPattern, actNoun.singular(), matcher.group("preposition"),
+		if (haPreposition && hasScratch)
+			return String.format(sigularPattern, 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());
-		}
+		else if (hasScratch)
+			return String.format(sigularPattern, actNoun.singular(), matcher.group("scratch"));
+		else if (haPreposition)
+			return String.format(sigularPattern, actNoun.singular(), matcher.group("preposition"));
+		else return String.format(sigularPattern, actNoun.singular());
 	}
 
 	@Override
-	public String pluralize(String singular) {
-		Matcher matcher = compoundMatcher.matcher(singular);
-		Noun actNoun = getNoun(matcher);
+	public String pluralize(final String singular) {
+		final Matcher matcher = cmpoundMatcher.matcher(singular);
+		final Noun actNoun = getNoun(matcher);
 
-		String patt = modernPluralPattern == null ? classicalPluralPattern : modernPluralPattern;
+		final String patt = mdernPluralPattern == null ? clasicalPluralPattern : mdernPluralPattern;
 
-		if(hasPreposition && hasScratch) {
+		if (haPreposition && hasScratch)
 			return String.format(patt, actNoun.plural(), matcher.group("preposition"),
 					matcher.group("scratch"));
-		} else if(hasScratch) {
+		else if (hasScratch)
 			return String.format(patt, actNoun.plural(), matcher.group("scratch"));
-		} else if(hasPreposition) {
+		else if (haPreposition)
 			return String.format(patt, actNoun.plural(), matcher.group("preposition"));
-		} else {
-			return String.format(patt, actNoun.plural());
-		}
+		else return String.format(patt, actNoun.plural());
 	}
 
 	@Override
-	public String pluralizeModern(String singular) {
-		if(modernPluralPattern == null) return pluralizeClassical(singular);
+	public String pluralizeModern(final String singular) {
+		if (mdernPluralPattern == null) return pluralizeClassical(singular);
 
-		Matcher matcher = compoundMatcher.matcher(singular);
-		Noun actNoun = getNoun(matcher);
+		final Matcher matcher = cmpoundMatcher.matcher(singular);
+		final Noun actNoun = getNoun(matcher);
 
-		if(hasPreposition && hasScratch) {
-			return String.format(modernPluralPattern, actNoun.modernPlural(), matcher.group("preposition"),
+		if (haPreposition && hasScratch)
+			return String.format(mdernPluralPattern, 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());
-		}
+		else if (hasScratch)
+			return String.format(mdernPluralPattern, actNoun.modernPlural(), matcher.group("scratch"));
+		else if (haPreposition)
+			return String.format(mdernPluralPattern, actNoun.modernPlural(), matcher.group("preposition"));
+		else return String.format(mdernPluralPattern, actNoun.modernPlural());
 	}
 
 	@Override
-	public String pluralizeClassical(String singular) {
-		if(classicalPluralPattern == null) return pluralizeModern(singular);
+	public String pluralizeClassical(final String singular) {
+		if (clasicalPluralPattern == null) return pluralizeModern(singular);
 
-		Matcher matcher = compoundMatcher.matcher(singular);
-		Noun actNoun = getNoun(matcher);
+		final Matcher matcher = cmpoundMatcher.matcher(singular);
+		final Noun actNoun = getNoun(matcher);
 
-		if(hasPreposition && hasScratch) {
-			return String.format(classicalPluralPattern, actNoun.classicalPlural(),
+		if (haPreposition && hasScratch)
+			return String.format(clasicalPluralPattern, actNoun.classicalPlural(),
 					matcher.group("preposition"), matcher.group("scratch"));
-		} else if(hasScratch) {
-			return String.format(classicalPluralPattern, actNoun.classicalPlural(),
+		else if (hasScratch)
+			return String.format(clasicalPluralPattern, actNoun.classicalPlural(),
 					matcher.group("scratch"));
-		} else if(hasPreposition) {
-			return String.format(classicalPluralPattern, actNoun.classicalPlural(),
+		else if (haPreposition)
+			return String.format(clasicalPluralPattern, actNoun.classicalPlural(),
 					matcher.group("preposition"));
-		} else {
-			return String.format(classicalPluralPattern, actNoun.classicalPlural());
-		}
+		else return String.format(clasicalPluralPattern, actNoun.classicalPlural());
 	}
 
-	private Noun getNoun(Matcher matcher) {
+	private Noun getNoun(final Matcher matcher) {
 		matcher.matches();
 
-		Noun actNoun = nounDB.getNoun(matcher.group("noun"));
+		final Noun actNoun = nunDB.getNoun(matcher.group("noun"));
 		return actNoun;
 	}
 
@@ -198,47 +189,47 @@ public class CompoundNounInflection implements NounInflection {
 		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());
+		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 + (sigularPattern == null ? 0 : sigularPattern.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;
+	public boolean equals(final Object obj) {
+		if (this == obj) return true;
+		if (obj == null) return false;
+		if (!(obj instanceof CompoundNounInflection)) return false;
 
-		CompoundNounInflection other = (CompoundNounInflection) obj;
+		final CompoundNounInflection other = (CompoundNounInflection) obj;
 
-		if(singularPattern == null) {
-			if(other.singularPattern != null) return false;
-		} else if(!singularPattern.equals(other.singularPattern)) return false;
+		if (sigularPattern == null) {
+			if (other.sigularPattern != null) return false;
+		} else if (!sigularPattern.equals(other.sigularPattern)) return false;
 
-		if(classicalPluralPattern == null) {
-			if(other.classicalPluralPattern != null) return false;
-		} else if(!classicalPluralPattern.equals(other.classicalPluralPattern)) return false;
+		if (clasicalPluralPattern == null) {
+			if (other.clasicalPluralPattern != null) return false;
+		} else if (!clasicalPluralPattern.equals(other.clasicalPluralPattern)) return false;
 
-		if(hasPreposition != other.hasPreposition) return false;
+		if (haPreposition != other.haPreposition) return false;
 
-		if(modernPluralPattern == null) {
-			if(other.modernPluralPattern != null) return false;
-		} else if(!modernPluralPattern.equals(other.modernPluralPattern)) return false;
+		if (mdernPluralPattern == null) {
+			if (other.mdernPluralPattern != null) return false;
+		} else if (!mdernPluralPattern.equals(other.mdernPluralPattern)) return false;
 
-		if(compoundMatcher == null) {
-			if(other.compoundMatcher != null) return false;
-		} else if(!compoundMatcher.equals(other.compoundMatcher)) return false;
+		if (cmpoundMatcher == null) {
+			if (other.cmpoundMatcher != null) return false;
+		} else if (!cmpoundMatcher.equals(other.cmpoundMatcher)) return false;
 
 		return true;
 	}
 
 	@Override
 	public String toString() {
-		return String.format(TOSTRING_FMT, compoundMatcher, singularPattern, modernPluralPattern,
-				classicalPluralPattern, hasPreposition);
+		return String.format(TOSTRING_FMT, cmpoundMatcher, sigularPattern, mdernPluralPattern,
+				clasicalPluralPattern, haPreposition);
 	}
 }
\ No newline at end of file
diff --git a/src/main/java/bjc/inflexion/nouns/DefaultNounInflection.java b/src/main/java/bjc/inflexion/nouns/DefaultNounInflection.java
index 458c3f2..71adba3 100644
--- a/src/main/java/bjc/inflexion/nouns/DefaultNounInflection.java
+++ b/src/main/java/bjc/inflexion/nouns/DefaultNounInflection.java
@@ -17,52 +17,49 @@ package bjc.inflexion.nouns;
 
 /**
  * Default noun inflection for english nouns.
- * 
+ *
  * @author EVE
  *
  */
 public class DefaultNounInflection implements NounInflection {
 	@Override
-	public boolean matches(String noun) {
+	public boolean matches(final String noun) {
 		return true;
 	}
 
 	@Override
-	public boolean isSingular(String noun) {
+	public boolean isSingular(final String noun) {
 		return !noun.endsWith("s");
 	}
 
 	@Override
-	public boolean isPlural(String noun) {
+	public boolean isPlural(final String noun) {
 		return noun.endsWith("s");
 	}
 
 	@Override
-	public String singularize(String plural) {
-		if(plural.endsWith("ses")) {
+	public String singularize(final String plural) {
+		if (plural.endsWith("ses"))
 			return plural.substring(0, plural.length() - 3);
-		} else if(plural.endsWith("s")) {
+		else if (plural.endsWith("s"))
 			return plural.substring(0, plural.length() - 1);
-		} else
-			return plural;
+		else return plural;
 	}
 
 	@Override
-	public String pluralize(String singular) {
-		if(singular.endsWith("s")) {
-			return singular + "es";
-		}
+	public String pluralize(final String singular) {
+		if (singular.endsWith("s")) return singular + "es";
 
 		return singular + "s";
 	}
 
 	@Override
-	public String pluralizeModern(String singular) {
+	public String pluralizeModern(final String singular) {
 		return pluralize(singular);
 	}
 
 	@Override
-	public String pluralizeClassical(String singular) {
+	public String pluralizeClassical(final String singular) {
 		return pluralize(singular);
 	}
 }
\ No newline at end of file
diff --git a/src/main/java/bjc/inflexion/nouns/InflectionAffix.java b/src/main/java/bjc/inflexion/nouns/InflectionAffix.java
index d8c8cb4..54588a2 100644
--- a/src/main/java/bjc/inflexion/nouns/InflectionAffix.java
+++ b/src/main/java/bjc/inflexion/nouns/InflectionAffix.java
@@ -17,7 +17,7 @@ package bjc.inflexion.nouns;
 
 /**
  * An affix attached to a word and used for inflection.
- * 
+ *
  * @author EVE
  *
  */
@@ -25,30 +25,30 @@ public interface InflectionAffix {
 
 	/**
 	 * Check if a word has this affix.
-	 * 
+	 *
 	 * @param word
 	 *                The word to check.
-	 * 
+	 *
 	 * @return Whether or not the word has the affix.
 	 */
 	boolean hasAffix(String word);
 
 	/**
 	 * Remove the affix from a word.
-	 * 
+	 *
 	 * @param word
 	 *                The word to remove the affix from.
-	 * 
+	 *
 	 * @return The word with the affix removed.
 	 */
 	String deaffix(String word);
 
 	/**
 	 * Apply this affix to a word.
-	 * 
+	 *
 	 * @param word
 	 *                The word to apply the affix to.
-	 * 
+	 *
 	 * @return The word with the affix applied.
 	 */
 	String affix(String word);
diff --git a/src/main/java/bjc/inflexion/nouns/InflectionAffixes.java b/src/main/java/bjc/inflexion/nouns/InflectionAffixes.java
index 4061776..4b1d2cf 100644
--- a/src/main/java/bjc/inflexion/nouns/InflectionAffixes.java
+++ b/src/main/java/bjc/inflexion/nouns/InflectionAffixes.java
@@ -19,55 +19,55 @@ import java.util.regex.Pattern;
 
 /**
  * Utility methods for constructing inflection affixes.
- * 
+ *
  * @author EVE
  *
  */
 public class InflectionAffixes {
 	/*
 	 * Template for 'complete' affix patterns.
-	 * 
+	 *
 	 * Match the start of the word, followed by zero or more word
 	 * characters, followed by the suffix, then the end of the string.
-	 * 
+	 *
 	 * The word is in a capturing group named 'stem'.
 	 */
 	private static final String COMPLETE_PATT_FMT = "(?<stem>\\w*)%s$";
 
 	/*
 	 * Template for 'incomplete' affix patterns.
-	 * 
+	 *
 	 * Match the start of the word, followed by one or more word characters,
 	 * followed by the suffix, then the end of the string.
-	 * 
+	 *
 	 * The word is in a capturing group named 'stem'.
 	 */
 	private static final String INCOMPLETE_PATT_FMT = "(?<stem>\\w+)%s$";
 
 	/**
 	 * Create an affix that's a word by itself.
-	 * 
+	 *
 	 * @param suffix
 	 *                The suffix to use.
-	 * 
+	 *
 	 * @return A affix that represents the suffix.
 	 */
-	public static InflectionAffix complete(String suffix) {
-		Pattern patt = Pattern.compile(String.format(COMPLETE_PATT_FMT, suffix));
+	public static InflectionAffix complete(final String suffix) {
+		final Pattern patt = Pattern.compile(String.format(COMPLETE_PATT_FMT, suffix));
 
 		return new SimpleInflectionAffix("%s" + suffix, patt);
 	}
 
 	/**
 	 * Create an affix that's not a word by itself.
-	 * 
+	 *
 	 * @param suffix
 	 *                The suffix to use.
-	 * 
+	 *
 	 * @return An affix that represents the suffix.
 	 */
-	public static InflectionAffix incomplete(String suffix) {
-		Pattern patt = Pattern.compile(String.format(INCOMPLETE_PATT_FMT, suffix));
+	public static InflectionAffix incomplete(final String suffix) {
+		final Pattern patt = Pattern.compile(String.format(INCOMPLETE_PATT_FMT, suffix));
 
 		return new SimpleInflectionAffix("%s" + suffix, patt);
 	}
diff --git a/src/main/java/bjc/inflexion/nouns/InflectionException.java b/src/main/java/bjc/inflexion/nouns/InflectionException.java
index a2d92bc..59ec61b 100644
--- a/src/main/java/bjc/inflexion/nouns/InflectionException.java
+++ b/src/main/java/bjc/inflexion/nouns/InflectionException.java
@@ -17,7 +17,7 @@ package bjc.inflexion.nouns;
 
 /**
  * Exception thrown when something goes wrong with inflection.
- * 
+ *
  * @author EVE
  *
  */
@@ -26,24 +26,24 @@ public class InflectionException extends RuntimeException {
 
 	/**
 	 * Create a new inflection exception with the given message and cause.
-	 * 
+	 *
 	 * @param message
 	 *                The message of the exception.
-	 * 
+	 *
 	 * @param cause
 	 *                The cause of the exception.
 	 */
-	public InflectionException(String message, Throwable cause) {
+	public InflectionException(final String message, final Throwable cause) {
 		super(message, cause);
 	}
 
 	/**
 	 * Create a new inflection exception with the given message.
-	 * 
+	 *
 	 * @param message
 	 *                The message of the exception.
 	 */
-	public InflectionException(String message) {
+	public InflectionException(final String message) {
 		super(message);
 	}
 }
diff --git a/src/main/java/bjc/inflexion/nouns/IrregularNounInflection.java b/src/main/java/bjc/inflexion/nouns/IrregularNounInflection.java
index 772c5a9..b64b341 100644
--- a/src/main/java/bjc/inflexion/nouns/IrregularNounInflection.java
+++ b/src/main/java/bjc/inflexion/nouns/IrregularNounInflection.java
@@ -17,7 +17,7 @@ package bjc.inflexion.nouns;
 
 /**
  * Implementation of {@link NounInflection} for irregular nouns.
- * 
+ *
  * @author EVE
  *
  */
@@ -25,33 +25,33 @@ public class IrregularNounInflection implements NounInflection {
 	private static final String TOSTRING_FMT = "IrregularNounInflection [singular=%s, modernPlural=%s,"
 			+ " classicalPlural=%s, preferClassical=%s]";
 
-	private String singular;
+	private final String singular;
 
-	private String	modernPlural;
-	private String	classicalPlural;
+	private final String	modernPlural;
+	private final String	classicalPlural;
 
-	private boolean preferClassical;
+	private final boolean preferClassical;
 
 	/**
 	 * Create a new irregular noun inflection.
-	 * 
+	 *
 	 * @param singlar
 	 *                The singular form of the noun.
-	 * 
+	 *
 	 * @param modrnPlural
 	 *                The modern plural of the noun.
-	 * 
+	 *
 	 * @param classiclPlural
 	 *                The classical plural of the noun.
-	 * 
+	 *
 	 * @param prefrClassical
 	 *                Whether the classical form should be preferred if it
 	 *                is available.
 	 */
-	public IrregularNounInflection(String singlar, String modrnPlural, String classiclPlural,
-			boolean prefrClassical) {
-		if(singlar == null) throw new NullPointerException("Singular form must not be null");
-		if(modrnPlural == null && classiclPlural == null)
+	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");
 
 		singular = singlar;
@@ -61,83 +61,83 @@ public class IrregularNounInflection implements NounInflection {
 	}
 
 	@Override
-	public boolean matches(String noun) {
-		if(noun.equalsIgnoreCase(singular))
+	public boolean matches(final String noun) {
+		if (noun.equalsIgnoreCase(singular))
 			return true;
-		else if(noun.equalsIgnoreCase(modernPlural))
+		else if (noun.equalsIgnoreCase(modernPlural))
 			return true;
-		else if(noun.equalsIgnoreCase(classicalPlural))
+		else if (noun.equalsIgnoreCase(classicalPlural))
 			return true;
-		else
-			return false;
+		else return false;
 	}
 
 	@Override
-	public boolean isSingular(String noun) {
-		if(noun.equalsIgnoreCase(singular))
+	public boolean isSingular(final String noun) {
+		if (noun.equalsIgnoreCase(singular))
 			return true;
-		else if(matchesPlural(noun))
+		else if (matchesPlural(noun))
 			return false;
 		else {
-			String msg = String.format("Noun '%s' doesn't belong to this inflection '%s'", noun, this);
+			final String msg = String.format("Noun '%s' doesn't belong to this inflection '%s'", noun,
+					this);
 
 			throw new InflectionException(msg);
 		}
 	}
 
 	@Override
-	public boolean isPlural(String noun) {
-		if(noun.equalsIgnoreCase(singular))
+	public boolean isPlural(final String noun) {
+		if (noun.equalsIgnoreCase(singular))
 			return false;
-		else if(matchesPlural(noun))
+		else if (matchesPlural(noun))
 			return true;
 		else {
-			String msg = String.format("Noun '%s' doesn't belong to this inflection '%s'", noun, this);
+			final String msg = String.format("Noun '%s' doesn't belong to this inflection '%s'", noun,
+					this);
 
 			throw new InflectionException(msg);
 		}
 	}
 
 	@Override
-	public String singularize(String plural) {
-		if(plural.equalsIgnoreCase(singular))
+	public String singularize(final String plural) {
+		if (plural.equalsIgnoreCase(singular))
 			return singular;
-		else if(matchesPlural(plural))
+		else if (matchesPlural(plural))
 			return singular;
 		else {
-			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);
 		}
 	}
 
 	@Override
-	public String pluralize(String singular) {
-		if(singular.equalsIgnoreCase(singular))
+	public String pluralize(final String singlar) {
+		if (singlar.equalsIgnoreCase(singlar))
 			return getPlural();
-		else if(matchesPlural(singular))
+		else if (matchesPlural(singlar))
 			return getPlural();
 		else {
-			String msg = String.format("Noun '%s' doesn't belong to this inflection '%s'", singular, this);
+			final String msg = String.format("Noun '%s' doesn't belong to this inflection '%s'", singlar,
+					this);
 
 			throw new InflectionException(msg);
 		}
 	}
 
 	private String getPlural() {
-		if(preferClassical) {
-			if(classicalPlural == null)
-				return modernPlural;
-			else
-				return classicalPlural;
-		} else if(modernPlural == null) {
+		if (preferClassical) {
+			if (classicalPlural == null) return modernPlural;
+
 			return classicalPlural;
-		} else {
-			return modernPlural;
-		}
+		} else if (modernPlural == null)
+			return classicalPlural;
+		else return modernPlural;
 	}
 
-	private boolean matchesPlural(String noun) {
+	private boolean matchesPlural(final String noun) {
 		return noun.equalsIgnoreCase(modernPlural) || noun.equalsIgnoreCase(classicalPlural);
 	}
 
@@ -151,46 +151,46 @@ public class IrregularNounInflection implements NounInflection {
 		final int prime = 31;
 		int result = 1;
 
-		result = prime * result + ((classicalPlural == null) ? 0 : classicalPlural.hashCode());
-		result = prime * result + ((modernPlural == null) ? 0 : modernPlural.hashCode());
-		result = prime * result + ((singular == null) ? 0 : singular.hashCode());
+		result = prime * result + (classicalPlural == null ? 0 : classicalPlural.hashCode());
+		result = prime * result + (modernPlural == null ? 0 : modernPlural.hashCode());
+		result = prime * result + (singular == null ? 0 : singular.hashCode());
 
 		return result;
 	}
 
 	@Override
-	public boolean equals(Object obj) {
-		if(this == obj) return true;
-		if(obj == null) return false;
-		if(!(obj instanceof IrregularNounInflection)) return false;
+	public boolean equals(final Object obj) {
+		if (this == obj) return true;
+		if (obj == null) return false;
+		if (!(obj instanceof IrregularNounInflection)) return false;
 
-		IrregularNounInflection other = (IrregularNounInflection) obj;
+		final IrregularNounInflection other = (IrregularNounInflection) obj;
 
-		if(singular == null) {
-			if(other.singular != null) return false;
-		} else if(!singular.equals(other.singular)) return false;
+		if (singular == null) {
+			if (other.singular != null) return false;
+		} else if (!singular.equals(other.singular)) return false;
 
-		if(classicalPlural == null) {
-			if(other.classicalPlural != null) return false;
-		} else if(!classicalPlural.equals(other.classicalPlural)) return false;
+		if (classicalPlural == null) {
+			if (other.classicalPlural != null) return false;
+		} else if (!classicalPlural.equals(other.classicalPlural)) return false;
 
-		if(modernPlural == null) {
-			if(other.modernPlural != null) return false;
-		} else if(!modernPlural.equals(other.modernPlural)) return false;
+		if (modernPlural == null) {
+			if (other.modernPlural != null) return false;
+		} else if (!modernPlural.equals(other.modernPlural)) return false;
 
 		return true;
 	}
 
 	@Override
-	public String pluralizeModern(String singular) {
-		if(modernPlural == null) return pluralizeClassical(singular);
+	public String pluralizeModern(final String singlar) {
+		if (modernPlural == null) return pluralizeClassical(singlar);
 
 		return modernPlural;
 	}
 
 	@Override
-	public String pluralizeClassical(String singular) {
-		if(classicalPlural == null) return pluralizeModern(singular);
+	public String pluralizeClassical(final String singlar) {
+		if (classicalPlural == null) return pluralizeModern(singlar);
 
 		return classicalPlural;
 	}
diff --git a/src/main/java/bjc/inflexion/nouns/Noun.java b/src/main/java/bjc/inflexion/nouns/Noun.java
index 4f785ad..5ab5009 100644
--- a/src/main/java/bjc/inflexion/nouns/Noun.java
+++ b/src/main/java/bjc/inflexion/nouns/Noun.java
@@ -17,7 +17,7 @@ package bjc.inflexion.nouns;
 
 /**
  * A noun attached to an inflection.
- * 
+ *
  * @author EVE
  *
  */
@@ -30,21 +30,21 @@ public class Noun {
 
 	/**
 	 * Create a new noun from a word and inflection.
-	 * 
+	 *
 	 * @param wrd
 	 *                The word for the noun.
-	 * 
+	 *
 	 * @param inflction
 	 *                The inflection for the word.
 	 */
-	public Noun(String wrd, NounInflection inflction) {
+	public Noun(final String wrd, final NounInflection inflction) {
 		word = wrd;
 		inflection = inflction;
 	}
 
 	/**
 	 * Get the input noun.
-	 * 
+	 *
 	 * @return The noun, as input.
 	 */
 	public String getWord() {
@@ -53,7 +53,7 @@ public class Noun {
 
 	/**
 	 * Get the inflection for this noun.
-	 * 
+	 *
 	 * @return The inflection for this noun.
 	 */
 	public NounInflection getInflection() {
@@ -62,7 +62,7 @@ public class Noun {
 
 	/**
 	 * Check if this noun is singular.
-	 * 
+	 *
 	 * @return Whether or not the noun is singular.
 	 */
 	public boolean isSingular() {
@@ -71,7 +71,7 @@ public class Noun {
 
 	/**
 	 * Check if this noun is plural.
-	 * 
+	 *
 	 * @return Whether or not this noun is plural.
 	 */
 	public boolean isPlural() {
@@ -80,7 +80,7 @@ public class Noun {
 
 	/**
 	 * Get the singular form of this noun.
-	 * 
+	 *
 	 * @return The singular form of this noun.
 	 */
 	public String singular() {
@@ -89,7 +89,7 @@ public class Noun {
 
 	/**
 	 * Get the plural form of this noun.
-	 * 
+	 *
 	 * @return The plural form of this noun.
 	 */
 	public String plural() {
@@ -103,7 +103,7 @@ public class Noun {
 
 	/**
 	 * Get the modern plural form of this noun.
-	 * 
+	 *
 	 * @return The modern plural form of this noun.
 	 */
 	public String modernPlural() {
@@ -112,7 +112,7 @@ public class Noun {
 
 	/**
 	 * Get the classical plural form of this noun.
-	 * 
+	 *
 	 * @return The classical plural form of this noun.
 	 */
 	public String classicalPlural() {
diff --git a/src/main/java/bjc/inflexion/nouns/NounInflection.java b/src/main/java/bjc/inflexion/nouns/NounInflection.java
index 9e6f4d4..142968f 100644
--- a/src/main/java/bjc/inflexion/nouns/NounInflection.java
+++ b/src/main/java/bjc/inflexion/nouns/NounInflection.java
@@ -17,29 +17,29 @@ package bjc.inflexion.nouns;
 
 /**
  * Interface for inflecting nouns.
- * 
+ *
  * @author EVE
  *
  */
 public interface NounInflection {
 	/**
 	 * Check if a noun matches this inflection.
-	 * 
+	 *
 	 * @param noun
 	 *                The noun to check on this inflection.
-	 * 
+	 *
 	 * @return Whether or not the noun belongs to the inflection.
 	 */
 	public boolean matches(String noun);
 
 	/**
 	 * Check if a noun for this inflection is singular or not.
-	 * 
+	 *
 	 * @param noun
 	 *                The noun to check for singularity.
-	 * 
+	 *
 	 * @return Whether or not the noun is singular.
-	 * 
+	 *
 	 * @throws InflectionException
 	 *                 If the noun isn't part of this inflection.
 	 */
@@ -47,12 +47,12 @@ public interface NounInflection {
 
 	/**
 	 * Check if a noun for this inflection is plural or not.
-	 * 
+	 *
 	 * @param noun
 	 *                The noun to check for plurality.
-	 * 
+	 *
 	 * @return Whether or not the noun is plural.
-	 * 
+	 *
 	 * @throws InflectionException
 	 *                 If the noun isn't part of this inflection.
 	 */
@@ -60,12 +60,12 @@ public interface NounInflection {
 
 	/**
 	 * Convert a singular noun to a plural noun.
-	 * 
+	 *
 	 * @param plural
 	 *                The plural noun to inflect to a singular form.
-	 * 
+	 *
 	 * @return The singular form of the noun.
-	 * 
+	 *
 	 * @throws InflectionException
 	 *                 If the noun isn't part of the inflection.
 	 */
@@ -73,12 +73,12 @@ public interface NounInflection {
 
 	/**
 	 * Convert a singular noun to a plural noun.
-	 * 
+	 *
 	 * @param singular
 	 *                The singular noun to inflect to a plural form.
-	 * 
+	 *
 	 * @return The plural form of the noun.
-	 * 
+	 *
 	 * @throws InflectionException
 	 *                 If the noun isn't part of the inflection.
 	 */
@@ -86,12 +86,12 @@ public interface NounInflection {
 
 	/**
 	 * Convert a singular noun to a modern plural noun.
-	 * 
+	 *
 	 * @param singular
 	 *                The singular noun to inflect to a modern plural form.
-	 * 
+	 *
 	 * @return The modern plural form of the noun.
-	 * 
+	 *
 	 * @throws InflectionException
 	 *                 If the noun isn't part of the inflection.
 	 */
@@ -99,13 +99,13 @@ public interface NounInflection {
 
 	/**
 	 * Convert a singular noun to a classical plural noun.
-	 * 
+	 *
 	 * @param singular
 	 *                The singular noun to inflect to a classical plural
 	 *                form.
-	 * 
+	 *
 	 * @return The classical plural form of the noun.
-	 * 
+	 *
 	 * @throws InflectionException
 	 *                 If the noun isn't part of the inflection.
 	 */
diff --git a/src/main/java/bjc/inflexion/nouns/Nouns.java b/src/main/java/bjc/inflexion/nouns/Nouns.java
index 8bfbea2..0fbfddd 100644
--- a/src/main/java/bjc/inflexion/nouns/Nouns.java
+++ b/src/main/java/bjc/inflexion/nouns/Nouns.java
@@ -15,7 +15,8 @@
  */
 package bjc.inflexion.nouns;
 
-import static bjc.inflexion.nouns.InflectionAffixes.*;
+import static bjc.inflexion.nouns.InflectionAffixes.complete;
+import static bjc.inflexion.nouns.InflectionAffixes.incomplete;
 
 import java.io.InputStream;
 import java.util.ArrayList;
@@ -33,21 +34,21 @@ import java.util.regex.Pattern;
 public class Nouns {
 	private static final DefaultNounInflection DEFAULT_INFLECTION = new DefaultNounInflection();
 
-	private Prepositions prepositionDB;
+	private final Prepositions prepositionDB;
 
-	private Map<String, NounInflection>	userIrregulars;
-	private List<NounInflection>		userInflections;
+	private final Map<String, NounInflection>	userIrregulars;
+	private final List<NounInflection>		userInflections;
 
-	private Map<String, NounInflection>	predefinedIrregulars;
-	private List<NounInflection>		predefinedInflections;
+	private final Map<String, NounInflection>	predefinedIrregulars;
+	private final List<NounInflection>		predefinedInflections;
 
 	/**
 	 * Create a new empty noun DB.
-	 * 
+	 *
 	 * @param prepDB
 	 *                The source for prepositions.
 	 */
-	public Nouns(Prepositions prepDB) {
+	public Nouns(final Prepositions prepDB) {
 		prepositionDB = prepDB;
 
 		userIrregulars = new HashMap<>();
@@ -59,23 +60,23 @@ public class Nouns {
 
 	/**
 	 * Retrieve a noun with its inflection from the database of inflections.
-	 * 
+	 *
 	 * @param noun
 	 *                The noun to retrieve.
-	 * 
+	 *
 	 * @return The noun with its inflection.
-	 * 
+	 *
 	 * @throws InflectionException
 	 *                 If the noun matched no inflection.
 	 */
-	public Noun getNoun(String noun) {
+	public Noun getNoun(final String noun) {
 		if (userIrregulars.containsKey(noun)) return new Noun(noun, userIrregulars.get(noun));
-		for (NounInflection inflect : userInflections) {
+		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));
-		for (NounInflection inflect : predefinedInflections) {
+		for (final NounInflection inflect : predefinedInflections) {
 			if (inflect.matches(noun)) return new Noun(noun, inflect);
 		}
 
@@ -84,20 +85,24 @@ public class Nouns {
 
 	/**
 	 * Load the contents of the stream into this DB.
-	 * 
+	 *
 	 * @param stream
 	 *                The stream to load from.
 	 */
-	public void loadFromStream(InputStream stream) {
+	public void loadFromStream(final InputStream stream) {
 		try (Scanner scn = new Scanner(stream)) {
 			while (scn.hasNextLine()) {
-				String ln = scn.nextLine().trim();
+				final String ln = scn.nextLine().trim();
 
 				/*
 				 * Ignore comments and blank lines.
 				 */
-				if (ln.startsWith("#")) continue;
-				if (ln.equals("")) continue;
+				if (ln.startsWith("#")) {
+					continue;
+				}
+				if (ln.equals("")) {
+					continue;
+				}
 
 				if (ln.contains("-")) {
 					handleLine(ln);
@@ -109,23 +114,23 @@ public class Nouns {
 		}
 	}
 
-	private void handleLine(String ln) {
-		String[] parts = ln.split(Pattern.quote("=>"));
+	private void handleLine(final String ln) {
+		final String[] parts = ln.split(Pattern.quote("=>"));
 
 		if (parts.length != 2) {
-			String msg = String.format("Improperly formatted noun defn '%s'", ln);
+			final String msg = String.format("Improperly formatted noun defn '%s'", ln);
 
 			throw new InflectionException(msg);
 		}
 
-		String singular = parts[0].trim();
-		String plural = parts[1].trim();
+		final String singular = parts[0].trim();
+		final String plural = parts[1].trim();
 
 		String modernPlural = "";
 		String classicalPlural = "";
 
 		if (plural.contains("|")) {
-			String[] plurals = plural.split(Pattern.quote("|"));
+			final String[] plurals = plural.split(Pattern.quote("|"));
 
 			if (plurals.length == 1) {
 				modernPlural = plurals[0].trim();
@@ -134,8 +139,12 @@ public class Nouns {
 				classicalPlural = plurals[1].trim();
 			}
 
-			if (modernPlural.equals("")) modernPlural = null;
-			if (classicalPlural.equals("")) classicalPlural = null;
+			if (modernPlural.equals("")) {
+				modernPlural = null;
+			}
+			if (classicalPlural.equals("")) {
+				classicalPlural = null;
+			}
 		} else {
 			modernPlural = plural;
 			classicalPlural = null;
@@ -152,20 +161,21 @@ public class Nouns {
 		}
 	}
 
-	private void handleCompoundPlural(String singular, String modernPlural, String classicalPlural) {
+	private void handleCompoundPlural(final String singular, final String modernPlural,
+			final 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+)");
+		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");
 		actClassical = actClassical.replaceAll(Pattern.quote("(PL)"), "%1\\$s");
 
-		List<CompoundNounInflection> inflections = new ArrayList<>(3);
+		final List<CompoundNounInflection> inflections = new ArrayList<>(3);
 
 		if (singular.contains("(PREP)")) {
 			handleCompoundPreposition(actSingular, actModern, actClassical, singularPatt, modernPatt,
@@ -175,21 +185,22 @@ public class Nouns {
 					inflections);
 		}
 
-		for (NounInflection inf : inflections) {
+		for (final NounInflection inf : inflections) {
 			predefinedInflections.add(inf);
 		}
 	}
 
-	private void handleCompound(String actSinglar, String actModrn, String actClasscal, String singularPtt,
-			String modernPtt, String classicalPtt, 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("*")) {
-			String singularPatt = singularPtt.replaceAll(Pattern.quote("*"), "(?<scratch>\\\\w+)");
-			String modernPatt = modernPtt.replaceAll(Pattern.quote("*"), "(?<scratch>\\\\w+)");
-			String classicalPatt = classicalPtt.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+)");
 
-			String actSingular = actSinglar.replaceAll(Pattern.quote("*"), "%2\\$s");
-			String actModern = actModrn.replaceAll(Pattern.quote("*"), "%2\\$s");
-			String actClassical = actClasscal.replaceAll(Pattern.quote("*"), "%2\\$s");
+			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);
@@ -199,19 +210,19 @@ public class Nouns {
 		}
 	}
 
-	private void handleNonpluralCompound(String actSinglar, String actModrn, String actClasscal,
-			String singularPatt, String modernPatt, String classicalPatt,
-			List<CompoundNounInflection> inflections, boolean hasScratch) {
-		String actModern = actModrn.equals("") ? null : actModrn;
-		String actClassical = actClasscal.equals("") ? null : actClasscal;
+	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;
 
-		CompoundNounInflection singularInflection = new CompoundNounInflection(this, prepositionDB,
+		final CompoundNounInflection singularInflection = new CompoundNounInflection(this, prepositionDB,
 				Pattern.compile(singularPatt), actSinglar, actModern, actClassical, false, hasScratch);
 
 		inflections.add(singularInflection);
 
 		if (!modernPatt.equals("")) {
-			CompoundNounInflection modernInflection = new CompoundNounInflection(this, prepositionDB,
+			final CompoundNounInflection modernInflection = new CompoundNounInflection(this, prepositionDB,
 					Pattern.compile(modernPatt), actSinglar, actModern, actClassical, false,
 					hasScratch);
 
@@ -219,17 +230,17 @@ public class Nouns {
 		}
 
 		if (!classicalPatt.equals("")) {
-			CompoundNounInflection classicalInflection = new CompoundNounInflection(this, prepositionDB,
-					Pattern.compile(classicalPatt), actSinglar, actModern, actClassical, false,
-					hasScratch);
+			final CompoundNounInflection classicalInflection = new CompoundNounInflection(this,
+					prepositionDB, Pattern.compile(classicalPatt), actSinglar, actModern,
+					actClassical, false, hasScratch);
 
 			inflections.add(classicalInflection);
 		}
 	}
 
-	private void handleCompoundPreposition(String actSinglar, String actModrn, String actClasscal,
-			String singularPtt, String modernPtt, String classicalPtt,
-			List<CompoundNounInflection> inflections) {
+	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+)");
@@ -258,16 +269,16 @@ public class Nouns {
 		}
 	}
 
-	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,
+	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("")) {
-			CompoundNounInflection modernInflection = new CompoundNounInflection(this, prepositionDB,
+			final CompoundNounInflection modernInflection = new CompoundNounInflection(this, prepositionDB,
 					Pattern.compile(modernPatt), actSingular, actModern, actClassical, true,
 					hasScratch);
 
@@ -275,55 +286,68 @@ public class Nouns {
 		}
 
 		if (!classicalPatt.equals("")) {
-			CompoundNounInflection classicalInflection = new CompoundNounInflection(this, prepositionDB,
-					Pattern.compile(classicalPatt), actSingular, actModern, actClassical, true,
-					hasScratch);
+			final 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));
+	private void handleIncompletePlural(final String singular, final String modernPlural,
+			final String classicalPlural) {
+		final InflectionAffix singularAffix = incomplete(singular.substring(1));
 
 		InflectionAffix modernAffix = null;
 		InflectionAffix classicalAffix = null;
 
-		if (modernPlural != null) modernAffix = incomplete(modernPlural.substring(1));
-		if (classicalPlural != null) classicalAffix = incomplete(classicalPlural.substring(1));
+		if (modernPlural != null) {
+			modernAffix = incomplete(modernPlural.substring(1));
+		}
+		if (classicalPlural != null) {
+			classicalAffix = incomplete(classicalPlural.substring(1));
+		}
 
-		CategoricalNounInflection inflection = new CategoricalNounInflection(singularAffix, modernAffix,
+		final CategoricalNounInflection inflection = new CategoricalNounInflection(singularAffix, modernAffix,
 				classicalAffix);
 
 		predefinedInflections.add(inflection);
 	}
 
-	private void handleCompletePlural(String singular, String modernPlural, String classicalPlural) {
-		InflectionAffix singularAffix = complete(singular.substring(1));
+	private void handleCompletePlural(final String singular, final String modernPlural,
+			final String classicalPlural) {
+		final InflectionAffix singularAffix = complete(singular.substring(1));
 
 		InflectionAffix modernAffix = null;
 		InflectionAffix classicalAffix = null;
 
-		if (modernPlural != null) modernAffix = complete(modernPlural.substring(1));
-		if (classicalPlural != null) classicalAffix = complete(classicalPlural.substring(1));
+		if (modernPlural != null) {
+			modernAffix = complete(modernPlural.substring(1));
+		}
+		if (classicalPlural != null) {
+			classicalAffix = complete(classicalPlural.substring(1));
+		}
 
-		CategoricalNounInflection inflection = new CategoricalNounInflection(singularAffix, modernAffix,
+		final CategoricalNounInflection inflection = new CategoricalNounInflection(singularAffix, modernAffix,
 				classicalAffix);
 
 		predefinedInflections.add(inflection);
 	}
 
-	private void handleIrregularPlural(String singular, String modernPlural, String classicalPlural) {
-		IrregularNounInflection inflection = new IrregularNounInflection(singular, modernPlural,
+	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);
 		}
 
-		if (modernPlural != null && !predefinedIrregulars.containsKey(modernPlural))
+		if (modernPlural != null && !predefinedIrregulars.containsKey(modernPlural)) {
 			predefinedIrregulars.put(modernPlural, inflection);
-		if (classicalPlural != null && !predefinedIrregulars.containsKey(classicalPlural))
+		}
+		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/Prepositions.java b/src/main/java/bjc/inflexion/nouns/Prepositions.java
index 356aa1c..9f8424e 100644
--- a/src/main/java/bjc/inflexion/nouns/Prepositions.java
+++ b/src/main/java/bjc/inflexion/nouns/Prepositions.java
@@ -22,12 +22,12 @@ import java.util.Set;
 
 /**
  * List of prepositions.
- * 
+ *
  * @author EVE
  *
  */
 public class Prepositions {
-	private Set<String> prepositions;
+	private final Set<String> prepositions;
 
 	/**
 	 * Create an empty preposition DB.
@@ -38,31 +38,33 @@ public class Prepositions {
 
 	/**
 	 * Check if a word is a preposition.
-	 * 
+	 *
 	 * @param word
 	 *                The word as a preposition.
-	 * 
+	 *
 	 * @return Whether or not the word is a preposition.
 	 */
-	public boolean isPreposition(String word) {
+	public boolean isPreposition(final String word) {
 		return prepositions.contains(word);
 	}
 
 	/**
 	 * Load the contents of the stream into this DB.
-	 * 
+	 *
 	 * @param stream
 	 *                The stream to load from.
 	 */
-	public void loadFromStream(InputStream stream) {
-		try(Scanner scn = new Scanner(stream)) {
-			while(scn.hasNextLine()) {
-				String ln = scn.nextLine().trim();
+	public void loadFromStream(final InputStream stream) {
+		try (Scanner scn = new Scanner(stream)) {
+			while (scn.hasNextLine()) {
+				final String ln = scn.nextLine().trim();
 
 				/*
 				 * Ignore comments
 				 */
-				if(ln.startsWith("#")) continue;
+				if (ln.startsWith("#")) {
+					continue;
+				}
 
 				prepositions.add(ln);
 			}
diff --git a/src/main/java/bjc/inflexion/nouns/SimpleInflectionAffix.java b/src/main/java/bjc/inflexion/nouns/SimpleInflectionAffix.java
index c9db8a1..00b9689 100644
--- a/src/main/java/bjc/inflexion/nouns/SimpleInflectionAffix.java
+++ b/src/main/java/bjc/inflexion/nouns/SimpleInflectionAffix.java
@@ -20,55 +20,55 @@ import java.util.regex.Pattern;
 
 /**
  * Simple implementation of {@link InflectionAffix}
- * 
+ *
  * @author EVE
  *
  */
 public class SimpleInflectionAffix implements InflectionAffix {
 	private static final String TOSTRING_FMT = "SimpleInflectionAffix [affixTemplate=%s, affixMatcher=%s]";
 
-	private String affixTemplate;
+	private final String affixTmplate;
 
-	private Pattern affixMatcher;
+	private final Pattern affixMtcher;
 
 	/**
 	 * Create a new inflection affix.
-	 * 
+	 *
 	 * @param affixTemplate
 	 *                The template for applying the affix, Should be a
 	 *                printf-style format string with a single string blank.
-	 * 
+	 *
 	 * @param affixMatcher
 	 *                The regular expression that matches the affix on
 	 *                strings. The 'stem' or word should be placed in a
 	 *                named capturing group named 'stem'.
 	 */
-	public SimpleInflectionAffix(String affixTemplate, Pattern affixMatcher) {
-		this.affixTemplate = affixTemplate;
-		this.affixMatcher = affixMatcher;
+	public SimpleInflectionAffix(final String affixTemplate, final Pattern affixMatcher) {
+		affixTmplate = affixTemplate;
+		affixMtcher = affixMatcher;
 	}
 
 	@Override
-	public boolean hasAffix(String word) {
-		return affixMatcher.matcher(word).matches();
+	public boolean hasAffix(final String word) {
+		return affixMtcher.matcher(word).matches();
 	}
 
 	@Override
-	public String deaffix(String word) {
-		Matcher matcher = affixMatcher.matcher(word);
+	public String deaffix(final String word) {
+		final Matcher matcher = affixMtcher.matcher(word);
 		matcher.matches();
-		
+
 		return matcher.group("stem");
 	}
 
 	@Override
-	public String affix(String word) {
-		return String.format(affixTemplate, word);
+	public String affix(final String word) {
+		return String.format(affixTmplate, word);
 	}
 
 	@Override
 	public String toString() {
-		return String.format(TOSTRING_FMT, affixTemplate, affixMatcher);
+		return String.format(TOSTRING_FMT, affixTmplate, affixMtcher);
 	}
 
 	@Override
@@ -76,27 +76,27 @@ public class SimpleInflectionAffix implements InflectionAffix {
 		final int prime = 31;
 		int result = 1;
 
-		result = prime * result + ((affixMatcher == null) ? 0 : affixMatcher.hashCode());
-		result = prime * result + ((affixTemplate == null) ? 0 : affixTemplate.hashCode());
+		result = prime * result + (affixMtcher == null ? 0 : affixMtcher.hashCode());
+		result = prime * result + (affixTmplate == null ? 0 : affixTmplate.hashCode());
 
 		return result;
 	}
 
 	@Override
-	public boolean equals(Object obj) {
-		if(this == obj) return true;
-		if(obj == null) return false;
-		if(!(obj instanceof SimpleInflectionAffix)) return false;
+	public boolean equals(final Object obj) {
+		if (this == obj) return true;
+		if (obj == null) return false;
+		if (!(obj instanceof SimpleInflectionAffix)) return false;
 
-		SimpleInflectionAffix other = (SimpleInflectionAffix) obj;
+		final SimpleInflectionAffix other = (SimpleInflectionAffix) obj;
 
-		if(affixTemplate == null) {
-			if(other.affixTemplate != null) return false;
-		} else if(!affixTemplate.equals(other.affixTemplate)) return false;
+		if (affixTmplate == null) {
+			if (other.affixTmplate != null) return false;
+		} else if (!affixTmplate.equals(other.affixTmplate)) return false;
 
-		if(affixMatcher == null) {
-			if(other.affixMatcher != null) return false;
-		} else if(!affixMatcher.equals(other.affixMatcher)) return false;
+		if (affixMtcher == null) {
+			if (other.affixMtcher != null) return false;
+		} else if (!affixMtcher.equals(other.affixMtcher)) return false;
 
 		return true;
 	}