Format

9 files changed, 248 insertions, 143 deletions

diff --git a/pom.xml b/pom.xml
index 0afc5a0..c1b7ca5 100644
--- a/pom.xml
+++ b/pom.xml
@@ -1,14 +1,19 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+
 	<modelVersion>4.0.0</modelVersion>
+
 	<groupId>bjc</groupId>
 	<artifactId>inflexion</artifactId>
 	<version>0.0.1-SNAPSHOT</version>
+
 	<name>Inflexion</name>
 	<description>Java based implementation of Damian Conway's Lingua::EN::Inflexion module for perl</description>
+
 	<properties>
 		<main.class>bjc.inflexion.examples.InflexionTester</main.class>
 	</properties>
+
 	<licenses>
 		<license>
 			<name>Apache License, Version 2.0</name>
@@ -26,36 +31,44 @@
 		<plugins>
 			<plugin>
 				<artifactId>maven-compiler-plugin</artifactId>
+
 				<configuration>
 					<source>1.8</source>
 					<target>1.8</target>
 				</configuration>
 			</plugin>
+
 			<plugin>
 				<groupId>org.codehaus.mojo</groupId>
 				<artifactId>exec-maven-plugin</artifactId>
 				<version>1.5.0</version>
+
 				<configuration>
 					<executable>java</executable>
+
 					<arguments>
 						<argument>-agentlib:jdwp=transport=dt_socket,server=y,suspend=n</argument>
 						<argument>-classpath</argument>
 						<classpath />
 						<argument>${main.class}</argument>
 					</arguments>
+
 					<mainClass>${main.class}</mainClass>
 				</configuration>
 			</plugin>
 		</plugins>
+
 		<resources>
 			<resource>
 				<directory>data/</directory>
+
 				<includes>
 					<include>**/*.txt</include>
 				</includes>
 			</resource>
 		</resources>
 	</build>
+
 	<dependencies>
 		<dependency>
 			<groupId>org.apache.commons</groupId>
@@ -63,4 +76,4 @@
 			<version>1.13</version>
 		</dependency>
 	</dependencies>
-</project>
\ No newline at end of file
+</project>
diff --git a/src/examples/java/bjc/inflexion/examples/InflexionTester.java b/src/examples/java/bjc/inflexion/examples/InflexionTester.java
index d174c00..ff5dcd7 100644
--- a/src/examples/java/bjc/inflexion/examples/InflexionTester.java
+++ b/src/examples/java/bjc/inflexion/examples/InflexionTester.java
@@ -48,7 +48,8 @@ public class InflexionTester {
 	 */
 	public static void main(final String[] args) {
 		final Prepositions prepositionDB = new Prepositions();
-		prepositionDB.loadFromStream(InflexionTester.class.getResourceAsStream("/prepositions.txt"));
+		prepositionDB.loadFromStream(
+		        InflexionTester.class.getResourceAsStream("/prepositions.txt"));
 
 		final Nouns nounDB = new Nouns(prepositionDB);
 		nounDB.loadFromStream(InflexionTester.class.getResourceAsStream("/nouns.txt"));
@@ -98,7 +99,7 @@ public class InflexionTester {
 			 * Pattern to find noun definition
 			 */
 			final Pattern enNounPattern = Pattern
-					.compile("\\{\\{en-noun([a-z0-9\\|\\-\\[\\]\\?\\!=]*)\\}\\}");
+			                              .compile("\\{\\{en-noun([a-z0-9\\|\\-\\[\\]\\?\\!=]*)\\}\\}");
 
 			final Pattern wordPattern = Pattern.compile("([a-zA-Z\\-]+)");
 
@@ -112,31 +113,42 @@ public class InflexionTester {
 			int wrongNoPlural = 0;
 			int wrongUncountable = 0;
 			boolean basicWord = false;
+
 			while ((line = reader.readLine()) != null) {
 				final Matcher titleMatcher = titlePattern.matcher(line);
+
 				if (titleMatcher.find()) {
 					word = titleMatcher.group(1);
+
 					if (word.startsWith("Wiktionary:")) {
 						continue;
 					}
+
 					basicWord = false;
 					text = 0;
 					continue;
 				}
+
 				final Matcher textMatcher = textPattern.matcher(line);
+
 				if (textMatcher.find()) {
 					text++;
 					continue;
 				}
+
 				final Matcher rankMatcher = rankPattern.matcher(line);
+
 				if (rankMatcher.find()) {
 					basicWord = true;
 					basicCount++;
 				}
+
 				if (text != 1) {
 					continue;
 				}
+
 				final Matcher enNounMatcher = enNounPattern.matcher(line);
+
 				if (enNounMatcher.find()) {
 					// only first
 					/*
@@ -144,18 +156,22 @@ public class InflexionTester {
 					 */
 					text++;
 					count++;
+
 					if (count % 5000 == 0) {
 						System.out.println(count);
 					}
+
 					final String[] rules = enNounMatcher.group(1).split("\\|");
 					final List<String> plurals = new ArrayList<>();
 
 					boolean uncountable = false;
 					boolean noPlural = false;
+
 					for (final String rule : rules) {
 						if (rule.isEmpty()) {
 							continue;
 						}
+
 						if ("-".equals(rule)) {
 							plurals.add(word);
 							uncountable = true;
@@ -171,17 +187,20 @@ public class InflexionTester {
 							noPlural = true;
 						} else {
 							final Matcher matcher = wordPattern.matcher(rule);
+
 							if (matcher.matches()) {
 								plurals.add(rule);
 							}
 						}
 					}
+
 					if (plurals.isEmpty()) {
 						plurals.add(word + "s");
 					}
 
 					final String calculatedPlural = nounDB.getNoun(word).plural();
 					boolean ok = false;
+
 					for (final String plural : plurals) {
 						if (plural.equals(calculatedPlural)) {
 							ok = true;
@@ -193,23 +212,26 @@ public class InflexionTester {
 						if (!uncountable) {
 							wrong++;
 						}
+
 						if (uncountable) {
 							wrongUncountable++;
 						} else if (noPlural) {
 							wrongNoPlural++;
 						}
+
 						if (basicWord) {
 							System.out.println("basic word: " + word + " got: "
-									+ calculatedPlural + ", but expected "
-									+ enNounMatcher.group(1));
+							                   + calculatedPlural + ", but expected "
+							                   + enNounMatcher.group(1));
 							basicWrong++;
 						} else if (!uncountable) {
 							System.out.println(word + " got: " + calculatedPlural
-									+ ", but expected " + enNounMatcher.group(1));
+							                   + ", but expected " + enNounMatcher.group(1));
 						}
 					}
 				}
 			}
+
 			reader.close();
 			compressedStream.close();
 
@@ -222,9 +244,10 @@ public class InflexionTester {
 			System.out.println("Correct: " + correct + "% (" + basicCorrect + "% basic words)");
 			System.out.println("Errors: ");
 			System.out.println("    No plural form specified: " + wrongNoPlural + " ("
-					+ wrongNoPluralPercent + "%)");
-			System.out.println("    Incorrect answer: " + justPlainWrong + " (" + justPlainWrongPercent
-					+ "%)");
+			                   + wrongNoPluralPercent + "%)");
+			System.out.println("    Incorrect answer: " + justPlainWrong + " (" +
+			                   justPlainWrongPercent
+			                   + "%)");
 		} catch (final FileNotFoundException fnfex) {
 			fnfex.printStackTrace();
 		} catch (final IOException ioex) {
diff --git a/src/main/java/bjc/inflexion/EnglishUtils.java b/src/main/java/bjc/inflexion/EnglishUtils.java
index e3c0823..3feb55b 100644
--- a/src/main/java/bjc/inflexion/EnglishUtils.java
+++ b/src/main/java/bjc/inflexion/EnglishUtils.java
@@ -21,32 +21,34 @@ package bjc.inflexion;
  */
 public class EnglishUtils {
 	private static String[] smallNums = new String[] { "zero", "one", "two", "three", "four", "five", "six",
-			"seven", "eight", "nine", "ten" };
+	                "seven", "eight", "nine", "ten"
+	                                                 };
 
-	private static String[]	summaryNums	= new String[] { "no", "one", "a couple of", "a few", "several" };
-	private static String[]	endSummaryNums	= new String[] { "no", "one", "a couple of", "a few", "several" };
+	private static String[]     summaryNums     = new String[] { "no", "one", "a couple of", "a few", "several" };
+	private static String[]     endSummaryNums  = new String[] { "no", "one", "a couple of", "a few", "several" };
 
 	private static int[] summaryMap = new int[] {
-			/*
-			 * no
-			 */
-			0,
-			/*
-			 * one
-			 */
-			1,
-			/*
-			 * a couple of
-			 */
-			2,
-			/*
-			 * a few
-			 */
-			3, 3, 3,
-			/*
-			 * several
-			 */
-			4, 4, 4, 4 };
+	        /*
+	         * no
+	         */
+	        0,
+	        /*
+	         * one
+	         */
+	        1,
+	        /*
+	         * a couple of
+	         */
+	        2,
+	        /*
+	         * a few
+	         */
+	        3, 3, 3,
+	        /*
+	         * several
+	         */
+	        4, 4, 4, 4
+	};
 
 	/**
 	 * Convert small integers to words.
diff --git a/src/main/java/bjc/inflexion/InflectionML.java b/src/main/java/bjc/inflexion/InflectionML.java
index 7d0cb6a..e12263b 100644
--- a/src/main/java/bjc/inflexion/InflectionML.java
+++ b/src/main/java/bjc/inflexion/InflectionML.java
@@ -22,7 +22,6 @@ import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import bjc.inflexion.examples.InflexionTester;
 import bjc.inflexion.nouns.InflectionException;
 import bjc.inflexion.nouns.Noun;
 import bjc.inflexion.nouns.Nouns;
@@ -33,18 +32,18 @@ import bjc.inflexion.nouns.Prepositions;
  *
  */
 public class InflectionML {
-	private static final List<String>	ESUB_OPT	= Arrays.asList("a", "s", "w");
-	private static Pattern			FORM_MARKER	= Pattern
-			.compile("<(?<command>[#N])(?<options>[^:]*):(?<text>[^>]*)>");
+	private static final List<String>   ESUB_OPT        = Arrays.asList("a", "s", "w");
+	private static Pattern                      FORM_MARKER     = Pattern
+	                .compile("<(?<command>[#N])(?<options>[^:]*):(?<text>[^>]*)>");
 
 	private static Nouns nounDB;
 
 	static {
 		final Prepositions prepositionDB = new Prepositions();
-		prepositionDB.loadFromStream(InflexionTester.class.getResourceAsStream("/prepositions.txt"));
+		prepositionDB.loadFromStream(InflectionML.class.getResourceAsStream("/prepositions.txt"));
 
 		nounDB = new Nouns(prepositionDB);
-		nounDB.loadFromStream(InflexionTester.class.getResourceAsStream("/nouns.txt"));
+		nounDB.loadFromStream(InflectionML.class.getResourceAsStream("/nouns.txt"));
 	}
 
 	/**
@@ -69,6 +68,7 @@ public class InflectionML {
 			final String text = formMatcher.group("text");
 
 			final Set<String> optionSet = new HashSet<>();
+
 			for (int i = 1; i <= options.length(); i++) {
 				optionSet.add(options.substring(i - 1, i));
 			}
@@ -80,6 +80,7 @@ public class InflectionML {
 						optionSet.remove("e");
 						optionSet.addAll(ESUB_OPT);
 					}
+
 					curCount = Integer.parseInt(text);
 
 					if (optionSet.contains("i")) {
@@ -126,7 +127,7 @@ public class InflectionML {
 					}
 					
 					final boolean shouldOverride = !(rep.equals("no") || rep.equals("a")
-							|| rep.equals("an"));
+					                                 || rep.equals("an"));
 
 					if (optionSet.contains("w") && shouldOverride) {
 						rep = EnglishUtils.smallIntToWord(curCount);
@@ -139,11 +140,14 @@ public class InflectionML {
 					formMatcher.appendReplacement(formBuffer, rep);
 				} catch (final NumberFormatException nfex) {
 					throw new InflectionException("Count setter must take a number as a parameter",
-							nfex);
+					                              nfex);
 				}
+
 				break;
+
 			case "N":
 				final Noun noun = nounDB.getNoun(text);
+
 				if (optionSet.contains("p") || !inflectSingular) {
 					if (optionSet.contains("c")) {
 						formMatcher.appendReplacement(formBuffer, noun.classicalPlural());
@@ -153,7 +157,9 @@ public class InflectionML {
 				} else {
 					formMatcher.appendReplacement(formBuffer, noun.singular());
 				}
+
 				break;
+
 			default:
 				final String msg = String.format("Unknown command '%s'", command);
 
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;