Minor changes

3 files changed, 102 insertions, 86 deletions

diff --git a/src/main/java/bjc/inflexion/EnglishUtils.java b/src/main/java/bjc/inflexion/EnglishUtils.java
index 96982ed..c782162 100644
--- a/src/main/java/bjc/inflexion/EnglishUtils.java
+++ b/src/main/java/bjc/inflexion/EnglishUtils.java
@@ -48,20 +48,40 @@ public class EnglishUtils {
 			 */
 			4, 4, 4, 4 };
 
+	/**
+	 * 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) {
+		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;
 
-		if(num >= 0 && num < 10) {
+		if (num >= 0 && num < 10) {
 			return nums[summaryMap[num]];
-		} else
-			return "many";
+		}
+
+		return "many";
 	}
-}
+}
\ No newline at end of file
diff --git a/src/main/java/bjc/inflexion/InflectionML.java b/src/main/java/bjc/inflexion/InflectionML.java
index 38119c0..4ceda7a 100644
--- a/src/main/java/bjc/inflexion/InflectionML.java
+++ b/src/main/java/bjc/inflexion/InflectionML.java
@@ -53,9 +53,6 @@ public class InflectionML {
 	 * @param form
 	 *                The string to inflect.
 	 * 
-	 * @param nounDB
-	 *                The source to load nouns from.
-	 * 
 	 * @return The inflected string.
 	 */
 	public static String inflect(String form) {
@@ -66,34 +63,33 @@ public class InflectionML {
 		int curCount = 1;
 		boolean inflectSingular = true;
 
-		while(formMatcher.find()) {
+		while (formMatcher.find()) {
 			String command = formMatcher.group("command");
 			String options = formMatcher.group("options");
 			String text = formMatcher.group("text");
 
 			Set<String> optionSet = new HashSet<>();
-			for(int i = 1; i <= options.length(); i++) {
+			for (int i = 1; i <= options.length(); i++) {
 				optionSet.add(options.substring(i - 1, i));
 			}
 
-			switch(command) {
+			switch (command) {
 			case "#":
 				try {
-					if(optionSet.contains("e")) {
+					if (optionSet.contains("e")) {
 						optionSet.remove("e");
 						optionSet.addAll(ESUB_OPT);
 					}
 					curCount = Integer.parseInt(text);
 
-					if(optionSet.contains("i")) {
+					if (optionSet.contains("i")) {
 						curCount += 1;
 					}
 
-					if(curCount != 1) {
-						if(curCount == 0 && optionSet.contains("s"))
+					if (curCount != 1) {
+						if (curCount == 0 && optionSet.contains("s"))
 							inflectSingular = true;
-						else
-							inflectSingular = false;
+						else inflectSingular = false;
 					} else {
 						inflectSingular = true;
 					}
@@ -101,24 +97,24 @@ public class InflectionML {
 					/*
 					 * Break out of switch.
 					 */
-					if(optionSet.contains("d")) {
+					if (optionSet.contains("d")) {
 						formMatcher.appendReplacement(formBuffer, "");
 						break;
 					}
 
 					String rep = text;
 
-					if(optionSet.contains("n")) {
-						if(curCount == 0) rep = "no";
+					if (optionSet.contains("n")) {
+						if (curCount == 0) rep = "no";
 					}
 
-					if(optionSet.contains("s")) {
-						if(curCount == 0) {
+					if (optionSet.contains("s")) {
+						if (curCount == 0) {
 							rep = "no";
 						}
 					}
 
-					if(optionSet.contains("a")) {
+					if (optionSet.contains("a")) {
 						/*
 						 * TODO implement a/an for nouns
 						 */
@@ -127,24 +123,24 @@ public class InflectionML {
 					boolean shouldOverride = !(rep.equals("no") || rep.equals("a")
 							|| rep.equals("an"));
 
-					if(optionSet.contains("w") && shouldOverride) {
+					if (optionSet.contains("w") && shouldOverride) {
 						rep = EnglishUtils.smallIntToWord(curCount);
 					}
 
-					if(optionSet.contains("f") && shouldOverride) {
+					if (optionSet.contains("f") && shouldOverride) {
 						rep = EnglishUtils.intSummarize(curCount, false);
 					}
 
 					formMatcher.appendReplacement(formBuffer, rep);
-				} catch(NumberFormatException nfex) {
+				} catch (NumberFormatException nfex) {
 					throw new InflectionException("Count setter must take a number as a parameter",
 							nfex);
 				}
 				break;
 			case "N":
 				Noun noun = nounDB.getNoun(text);
-				if(optionSet.contains("p") || !inflectSingular) {
-					if(optionSet.contains("c")) {
+				if (optionSet.contains("p") || !inflectSingular) {
+					if (optionSet.contains("c")) {
 						formMatcher.appendReplacement(formBuffer, noun.classicalPlural());
 					} else {
 						formMatcher.appendReplacement(formBuffer, noun.modernPlural());
diff --git a/src/main/java/bjc/inflexion/nouns/Nouns.java b/src/main/java/bjc/inflexion/nouns/Nouns.java
index 3b280eb..8bfbea2 100644
--- a/src/main/java/bjc/inflexion/nouns/Nouns.java
+++ b/src/main/java/bjc/inflexion/nouns/Nouns.java
@@ -69,14 +69,14 @@ public class Nouns {
 	 *                 If the noun matched no inflection.
 	 */
 	public Noun getNoun(String noun) {
-		if(userIrregulars.containsKey(noun)) return new Noun(noun, userIrregulars.get(noun));
-		for(NounInflection inflect : userInflections) {
-			if(inflect.matches(noun)) return new Noun(noun, inflect);
+		if (userIrregulars.containsKey(noun)) return new Noun(noun, userIrregulars.get(noun));
+		for (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) {
-			if(inflect.matches(noun)) return new Noun(noun, inflect);
+		if (predefinedIrregulars.containsKey(noun)) return new Noun(noun, predefinedIrregulars.get(noun));
+		for (NounInflection inflect : predefinedInflections) {
+			if (inflect.matches(noun)) return new Noun(noun, inflect);
 		}
 
 		return new Noun(noun, DEFAULT_INFLECTION);
@@ -89,17 +89,17 @@ public class Nouns {
 	 *                The stream to load from.
 	 */
 	public void loadFromStream(InputStream stream) {
-		try(Scanner scn = new Scanner(stream)) {
-			while(scn.hasNextLine()) {
+		try (Scanner scn = new Scanner(stream)) {
+			while (scn.hasNextLine()) {
 				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("-")) {
+				if (ln.contains("-")) {
 					handleLine(ln);
 					handleLine(ln.replace('-', ' '));
 				} else {
@@ -112,7 +112,7 @@ public class Nouns {
 	private void handleLine(String ln) {
 		String[] parts = ln.split(Pattern.quote("=>"));
 
-		if(parts.length != 2) {
+		if (parts.length != 2) {
 			String msg = String.format("Improperly formatted noun defn '%s'", ln);
 
 			throw new InflectionException(msg);
@@ -124,28 +124,28 @@ public class Nouns {
 		String modernPlural = "";
 		String classicalPlural = "";
 
-		if(plural.contains("|")) {
+		if (plural.contains("|")) {
 			String[] plurals = plural.split(Pattern.quote("|"));
 
-			if(plurals.length == 1) {
+			if (plurals.length == 1) {
 				modernPlural = plurals[0].trim();
 			} else {
 				modernPlural = plurals[0].trim();
 				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;
 		}
 
-		if(singular.contains("(SING)")) {
+		if (singular.contains("(SING)")) {
 			handleCompoundPlural(singular, modernPlural, classicalPlural);
-		} else if(singular.startsWith("*")) {
+		} else if (singular.startsWith("*")) {
 			handleCompletePlural(singular, modernPlural, classicalPlural);
-		} else if(singular.startsWith("-")) {
+		} else if (singular.startsWith("-")) {
 			handleIncompletePlural(singular, modernPlural, classicalPlural);
 		} else {
 			handleIrregularPlural(singular, modernPlural, classicalPlural);
@@ -167,7 +167,7 @@ public class Nouns {
 
 		List<CompoundNounInflection> inflections = new ArrayList<>(3);
 
-		if(singular.contains("(PREP)")) {
+		if (singular.contains("(PREP)")) {
 			handleCompoundPreposition(actSingular, actModern, actClassical, singularPatt, modernPatt,
 					classicalPatt, inflections);
 		} else {
@@ -175,70 +175,70 @@ public class Nouns {
 					inflections);
 		}
 
-		for(NounInflection inf : inflections) {
+		for (NounInflection inf : inflections) {
 			predefinedInflections.add(inf);
 		}
 	}
 
-	private void handleCompound(String actSingular, String actModern, String actClassical, String singularPatt,
-			String modernPatt, String classicalPatt, List<CompoundNounInflection> inflections) {
-		if(singularPatt.contains("*")) {
-			singularPatt = singularPatt.replaceAll(Pattern.quote("*"), "(?<scratch>\\\\w+)");
-			modernPatt = modernPatt.replaceAll(Pattern.quote("*"), "(?<scratch>\\\\w+)");
-			classicalPatt = classicalPatt.replaceAll(Pattern.quote("*"), "(?<scratch>\\\\w+)");
+	private void handleCompound(String actSinglar, String actModrn, String actClasscal, String singularPtt,
+			String modernPtt, String classicalPtt, 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+)");
 
-			actSingular = actSingular.replaceAll(Pattern.quote("*"), "%2\\$s");
-			actModern = actModern.replaceAll(Pattern.quote("*"), "%2\\$s");
-			actClassical = actClassical.replaceAll(Pattern.quote("*"), "%2\\$s");
+			String actSingular = actSinglar.replaceAll(Pattern.quote("*"), "%2\\$s");
+			String actModern = actModrn.replaceAll(Pattern.quote("*"), "%2\\$s");
+			String actClassical = actClasscal.replaceAll(Pattern.quote("*"), "%2\\$s");
 
 			handleNonpluralCompound(actSingular, actModern, actClassical, singularPatt, modernPatt,
 					classicalPatt, inflections, true);
 		} else {
-			handleNonpluralCompound(actSingular, actModern, actClassical, singularPatt, modernPatt,
-					classicalPatt, inflections, false);
+			handleNonpluralCompound(actSinglar, actModrn, actClasscal, singularPtt, modernPtt, classicalPtt,
+					inflections, false);
 		}
 	}
 
-	private void handleNonpluralCompound(String actSingular, String actModern, String actClassical,
+	private void handleNonpluralCompound(String actSinglar, String actModrn, String actClasscal,
 			String singularPatt, String modernPatt, String classicalPatt,
 			List<CompoundNounInflection> inflections, boolean hasScratch) {
-		actModern = actModern.equals("") ? null : actModern;
-		actClassical = actClassical.equals("") ? null : actClassical;
+		String actModern = actModrn.equals("") ? null : actModrn;
+		String actClassical = actClasscal.equals("") ? null : actClasscal;
 
 		CompoundNounInflection singularInflection = new CompoundNounInflection(this, prepositionDB,
-				Pattern.compile(singularPatt), actSingular, actModern, actClassical, false, hasScratch);
+				Pattern.compile(singularPatt), actSinglar, actModern, actClassical, false, hasScratch);
 
 		inflections.add(singularInflection);
 
-		if(!modernPatt.equals("")) {
+		if (!modernPatt.equals("")) {
 			CompoundNounInflection modernInflection = new CompoundNounInflection(this, prepositionDB,
-					Pattern.compile(modernPatt), actSingular, actModern, actClassical, false,
+					Pattern.compile(modernPatt), actSinglar, actModern, actClassical, false,
 					hasScratch);
 
 			inflections.add(modernInflection);
 		}
 
-		if(!classicalPatt.equals("")) {
+		if (!classicalPatt.equals("")) {
 			CompoundNounInflection classicalInflection = new CompoundNounInflection(this, prepositionDB,
-					Pattern.compile(classicalPatt), actSingular, actModern, actClassical, false,
+					Pattern.compile(classicalPatt), actSinglar, actModern, actClassical, false,
 					hasScratch);
 
 			inflections.add(classicalInflection);
 		}
 	}
 
-	private void handleCompoundPreposition(String actSingular, String actModern, String actClassical,
-			String singularPatt, String modernPatt, String classicalPatt,
+	private void handleCompoundPreposition(String actSinglar, String actModrn, String actClasscal,
+			String singularPtt, String modernPtt, String classicalPtt,
 			List<CompoundNounInflection> inflections) {
-		singularPatt = singularPatt.replaceAll(Pattern.quote("(PREP)"), "(?<preposition>\\\\w+)");
-		modernPatt = modernPatt.replaceAll(Pattern.quote("(PREP)"), "(?<preposition>\\\\w+)");
-		classicalPatt = classicalPatt.replaceAll(Pattern.quote("(PREP)"), "(?<preposition>\\\\w+)");
+		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+)");
 
-		actSingular = actSingular.replaceAll(Pattern.quote("(PREP)"), "%2\\$s");
-		actModern = actModern.replaceAll(Pattern.quote("(PREP)"), "%2\\$s");
-		actClassical = actClassical.replaceAll(Pattern.quote("(PREP)"), "%2\\$s");
+		String actSingular = actSinglar.replaceAll(Pattern.quote("(PREP)"), "%2\\$s");
+		String actModern = actModrn.replaceAll(Pattern.quote("(PREP)"), "%2\\$s");
+		String actClassical = actClasscal.replaceAll(Pattern.quote("(PREP)"), "%2\\$s");
 
-		if(singularPatt.contains("*")) {
+		if (singularPatt.contains("*")) {
 			singularPatt = singularPatt.replaceAll(Pattern.quote("*"), "(?<scratch>\\\\w+)");
 			modernPatt = modernPatt.replaceAll(Pattern.quote("*"), "(?<scratch>\\\\w+)");
 			classicalPatt = classicalPatt.replaceAll(Pattern.quote("*"), "(?<scratch>\\\\w+)");
@@ -266,7 +266,7 @@ public class Nouns {
 
 		inflections.add(singularInflection);
 
-		if(!modernPatt.equals("")) {
+		if (!modernPatt.equals("")) {
 			CompoundNounInflection modernInflection = new CompoundNounInflection(this, prepositionDB,
 					Pattern.compile(modernPatt), actSingular, actModern, actClassical, true,
 					hasScratch);
@@ -274,7 +274,7 @@ public class Nouns {
 			inflections.add(modernInflection);
 		}
 
-		if(!classicalPatt.equals("")) {
+		if (!classicalPatt.equals("")) {
 			CompoundNounInflection classicalInflection = new CompoundNounInflection(this, prepositionDB,
 					Pattern.compile(classicalPatt), actSingular, actModern, actClassical, true,
 					hasScratch);
@@ -289,8 +289,8 @@ public class Nouns {
 		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,
 				classicalAffix);
@@ -304,8 +304,8 @@ public class Nouns {
 		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,
 				classicalAffix);
@@ -317,13 +317,13 @@ public class Nouns {
 		IrregularNounInflection inflection = new IrregularNounInflection(singular, modernPlural,
 				classicalPlural, false);
 
-		if(!predefinedIrregulars.containsKey(singular)) {
+		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