Add export rules to grammars

6 files changed, 247 insertions, 19 deletions

diff --git a/RGens/src/main/java/bjc/rgens/newparser/RGrammar.java b/RGens/src/main/java/bjc/rgens/newparser/RGrammar.java
index 4adcbe8..35fc356 100644
--- a/RGens/src/main/java/bjc/rgens/newparser/RGrammar.java
+++ b/RGens/src/main/java/bjc/rgens/newparser/RGrammar.java
@@ -1,7 +1,8 @@
 package bjc.rgens.newparser;
 
-import java.util.List;
+import java.util.HashSet;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * Represents a randomized grammar.
@@ -20,7 +21,9 @@ public class RGrammar {
 
 	private Map<String, Rule> rules;
 
-	private Map<String, Rule> importRules;
+	private Map<String, RGrammar> importRules;
+
+	private Set<String> exportRules;
 
 	private String initialRule;
 
@@ -40,11 +43,11 @@ public class RGrammar {
 	 * Imported rules are checked for rule definitions after local
 	 * definitions are checked.
 	 * 
-	 * @param importedRules
+	 * @param exportedRules
 	 *                The set of imported rules to use.
 	 */
-	public void setImportedRules(Map<String, Rule> importedRules) {
-		importRules = importedRules;
+	public void setImportedRules(Map<String, RGrammar> exportedRules) {
+		importRules = exportedRules;
 	}
 
 	/**
@@ -116,9 +119,9 @@ public class RGrammar {
 
 					generateCase(cse, state);
 				} else if(importRules.containsKey(elm.getLiteral())) {
-					RuleCase cse = importRules.get(elm.getLiteral()).getCase();
+					RGrammar dst = importRules.get(elm.getLiteral());
 
-					generateCase(cse, state);
+					state.contents.append(dst.generate(elm.getLiteral()));
 				} else {
 					throw new GrammarException(
 							String.format("No rule by name '%s' found", elm.getLiteral()));
@@ -149,6 +152,14 @@ public class RGrammar {
 	 *                is no initial rule.
 	 */
 	public void setInitialRule(String initialRule) {
+		/*
+		 * Passing null nulls our initial rule.
+		 */
+		if(initialRule == null) {
+			this.initialRule = null;
+			return;
+		}
+
 		if(initialRule.equals("")) {
 			throw new GrammarException("The empty string is not a valid rule name");
 		} else if(!rules.containsKey(initialRule)) {
@@ -158,4 +169,40 @@ public class RGrammar {
 
 		this.initialRule = initialRule;
 	}
+
+	/**
+	 * Gets the rules exported by this grammar.
+	 * 
+	 * The initial rule is exported by default if specified.
+	 * 
+	 * @return The rules exported by this grammar.
+	 */
+	public Set<Rule> getExportedRules() {
+		Set<Rule> res = new HashSet<>();
+
+		for(String rname : exportRules) {
+			if(!rules.containsKey(rname)) {
+				throw new GrammarException(String
+						.format("No rule named '%s' local to this grammar found", initialRule));
+			}
+
+			res.add(rules.get(rname));
+		}
+
+		if(initialRule != null) {
+			res.add(rules.get(initialRule));
+		}
+
+		return res;
+	}
+
+	/**
+	 * Set the rules exported by this grammar.
+	 * 
+	 * @param exportRules
+	 *                The rules exported by this grammar.
+	 */
+	public void setExportedRules(Set<String> exportRules) {
+		this.exportRules = exportRules;
+	}
 }
diff --git a/RGens/src/main/java/bjc/rgens/newparser/RGrammarBuilder.java b/RGens/src/main/java/bjc/rgens/newparser/RGrammarBuilder.java
index 7549847..346e588 100644
--- a/RGens/src/main/java/bjc/rgens/newparser/RGrammarBuilder.java
+++ b/RGens/src/main/java/bjc/rgens/newparser/RGrammarBuilder.java
@@ -4,7 +4,9 @@ import bjc.utils.funcdata.FunctionalList;
 import bjc.utils.funcdata.IList;
 
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
+import java.util.Set;
 
 import static bjc.rgens.newparser.CaseElement.ElementType.*;
 import static bjc.rgens.newparser.RuleCase.CaseType.*;
@@ -16,11 +18,13 @@ import static bjc.rgens.newparser.RuleCase.CaseType.*;
  *
  */
 public class RGrammarBuilder {
-	private Map<String, Rule> rules;
+	private IList<CaseElement> currentCase;
 
 	private Rule currRule;
 
-	private IList<CaseElement> currentCase;
+	private Map<String, Rule> rules;
+
+	private Set<String> exportedRules;
 
 	private String initialRule;
 
@@ -30,6 +34,8 @@ public class RGrammarBuilder {
 	public RGrammarBuilder() {
 		rules = new HashMap<>();
 
+		exportedRules = new HashSet<>();
+
 		currentCase = new FunctionalList<>();
 	}
 
@@ -65,6 +71,8 @@ public class RGrammarBuilder {
 
 		grammar.setInitialRule(initialRule);
 
+		grammar.setExportedRules(exportedRules);
+
 		return grammar;
 	}
 
@@ -139,6 +147,10 @@ public class RGrammarBuilder {
 	 * 
 	 * @param init
 	 *                The initial rule of the grammar.
+	 * 
+	 * @throws IllegalArgumentException
+	 *                 If the rule is either not valid or not defined in the
+	 *                 grammar.
 	 */
 	public void setInitialRule(String init) {
 		if(init == null) {
@@ -151,4 +163,26 @@ public class RGrammarBuilder {
 
 		initialRule = init;
 	}
+
+	/**
+	 * Add an exported rule to this grammar.
+	 * 
+	 * @param export
+	 *                The name of the rule to export.
+	 * 
+	 * @throws IllegalArgumentException
+	 *                 If the rule is either not valid or not defined in the
+	 *                 grammar.
+	 */
+	public void addExport(String export) {
+		if(export == null) {
+			throw new NullPointerException("Export name must not be null");
+		} else if(export.equals("")) {
+			throw new NullPointerException("The empty string is not a valid rule name");
+		} else if(!rules.containsKey(export)) {
+			throw new IllegalArgumentException(String.format("No rule named '%s' found", export));
+		}
+
+		exportedRules.add(export);
+	}
 }
diff --git a/RGens/src/main/java/bjc/rgens/newparser/RGrammarParser.java b/RGens/src/main/java/bjc/rgens/newparser/RGrammarParser.java
index b74c5f7..64d7b54 100644
--- a/RGens/src/main/java/bjc/rgens/newparser/RGrammarParser.java
+++ b/RGens/src/main/java/bjc/rgens/newparser/RGrammarParser.java
@@ -49,6 +49,14 @@ public class RGrammarParser {
 
 			build.setInitialRule(body);
 		});
+
+		pragmas.put("export-rule", (body, build, level) -> {
+			String[] exports = body.split(" ");
+
+			for(String export : exports) {
+				build.addExport(export);
+			}
+		});
 	}
 
 	/**
@@ -99,6 +107,7 @@ public class RGrammarParser {
 		 */
 		if(block.equals("")) return;
 		if(block.equals("\n")) return;
+		if(block.equals("\r\n")) return;
 
 		int typeSep = block.indexOf(' ');
 
@@ -176,7 +185,11 @@ public class RGrammarParser {
 		String pragmaBody = pragma.substring(bodySep + 1);
 
 		if(pragmas.containsKey(pragmaName)) {
-			pragmas.get(pragmaName).accept(pragmaBody, build, level);
+			try {
+				pragmas.get(pragmaName).accept(pragmaBody, build, level);
+			} catch(GrammarException gex) {
+				throw new GrammarException(String.format("Error in '%s' pragma", pragmaName), gex);
+			}
 		} else {
 			throw new GrammarException(String.format("Unknown pragma named '%s'", pragmaName));
 		}
@@ -211,7 +224,7 @@ public class RGrammarParser {
 					 * single case.
 					 */
 					handleRuleDecl(build, ruleBlock);
-					
+
 					build.finishRule();
 				}
 			} catch(GrammarException gex) {
@@ -231,7 +244,8 @@ public class RGrammarParser {
 
 		if(declSep == -1) {
 			/*
-			 * The old syntax allowed it to work with just a space.
+			 * TODO remove support for the old syntax when all of
+			 * the files are converted.
 			 */
 			declSep = declContents.indexOf(' ');
 
@@ -240,9 +254,6 @@ public class RGrammarParser {
 						"A rule must be given at least one case in its declaration, and"
 								+ "seperated from that case by \u2192");
 			}
-
-			System.out.println(
-					"WARNING: Rule declarations must now be seperated from the initial case by \u2192.");
 		}
 
 		String ruleName = declContents.substring(0, declSep).trim();
@@ -264,7 +275,14 @@ public class RGrammarParser {
 		build.beginCase();
 
 		for(String csepart : cse.split(" ")) {
-			build.addCasePart(csepart);
+			String partToAdd = csepart.trim();
+			
+			/*
+			 * Ignore empty parts
+			 */
+			if(partToAdd.equals("")) continue;
+
+			build.addCasePart(partToAdd);
 		}
 
 		build.finishCase();
diff --git a/RGens/src/main/java/bjc/rgens/newparser/RGrammarSet.java b/RGens/src/main/java/bjc/rgens/newparser/RGrammarSet.java
new file mode 100644
index 0000000..e67e356
--- /dev/null
+++ b/RGens/src/main/java/bjc/rgens/newparser/RGrammarSet.java
@@ -0,0 +1,123 @@
+package bjc.rgens.newparser;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Represents a set of grammars that can share rules via exports.
+ * 
+ * @author EVE
+ *
+ */
+public class RGrammarSet {
+	private Map<String, RGrammar> grammars;
+
+	private Map<String, RGrammar> exportedRules;
+
+	/**
+	 * Create a new set of randomized grammars.
+	 */
+	public RGrammarSet() {
+		grammars = new HashMap<>();
+
+		exportedRules = new HashMap<>();
+	}
+
+	/**
+	 * Add a grammar to this grammar set.
+	 * 
+	 * @param grammarName
+	 *                The name of the grammar to add.
+	 * 
+	 * @param gram
+	 *                The grammar to add.
+	 * 
+	 * @throws IllegalArgumentException
+	 *                 If the grammar name is invalid.
+	 */
+	public void addGrammar(String grammarName, RGrammar gram) {
+		if(grammarName == null) {
+			throw new NullPointerException("Grammar name must not be null");
+		} else if(gram == null) {
+			throw new NullPointerException("Grammar must not be null");
+		} else if(grammarName.equals("")) {
+			throw new IllegalArgumentException("The empty string is not a valid grammar name");
+		}
+
+		grammars.put(grammarName, gram);
+
+		for(Rule export : gram.getExportedRules()) {
+			exportedRules.put(export.ruleName, gram);
+		}
+
+		gram.setImportedRules(exportedRules);
+	}
+
+	/**
+	 * Get a grammar from this grammar set.
+	 * 
+	 * @param grammarName
+	 *                The name of the grammar to get.
+	 * 
+	 * @return The grammar with that name.
+	 * 
+	 * @throws IllegalArgumentException
+	 *                 If the grammar name is invalid or not present in this
+	 *                 set.
+	 */
+	public RGrammar getGrammar(String grammarName) {
+		if(grammarName == null) {
+			throw new NullPointerException("Grammar name must not be null");
+		} else if(grammarName.equals("")) {
+			throw new IllegalArgumentException("The empty string is not a valid grammar name");
+		} else if(!grammars.containsKey("")) {
+			throw new IllegalArgumentException(
+					String.format("No grammar with name '%s' found", grammarName));
+		}
+
+		return grammars.get(grammarName);
+	}
+
+	/**
+	 * Get the grammar a rule was exported from.
+	 * 
+	 * @param exportName
+	 *                The name of the exported rule.
+	 * 
+	 * @return The grammar the exported rule came from.
+	 * 
+	 * @throws IllegalArgumentException
+	 *                 If the export name is invalid or not present in this
+	 *                 set.
+	 */
+	public RGrammar getExportSource(String exportName) {
+		if(exportName == null) {
+			throw new NullPointerException("Export name must not be null");
+		} else if(exportName.equals("")) {
+			throw new IllegalArgumentException("The empty string is not a valid rule name");
+		} else if(!exportedRules.containsKey(exportName)) {
+			throw new IllegalArgumentException(String.format("No export with name '%s' found", exportName));
+		}
+		
+		return exportedRules.get(exportName);
+	}
+
+	/**
+	 * Get the names of all the grammars in this set.
+	 * 
+	 * @return The names of all the grammars in this set.
+	 */
+	public Set<String> getGrammars() {
+		return grammars.keySet();
+	}
+
+	/**
+	 * Get the names of all the exported rules in this set.
+	 * 
+	 * @return The names of all the exported rules in this set.
+	 */
+	public Set<String> getExportedRules() {
+		return exportedRules.keySet();
+	}
+}
diff --git a/RGens/src/main/java/bjc/rgens/newparser/RGrammarTest.java b/RGens/src/main/java/bjc/rgens/newparser/RGrammarTest.java
index 483542e..48977e9 100644
--- a/RGens/src/main/java/bjc/rgens/newparser/RGrammarTest.java
+++ b/RGens/src/main/java/bjc/rgens/newparser/RGrammarTest.java
@@ -16,12 +16,18 @@ public class RGrammarTest {
 	 *                Unused CLI args.
 	 */
 	public static void main(String[] args) {
-		InputStream stream = RGrammarTest.class.getResourceAsStream("/sample-grammars/insults.gram");
+		InputStream stream = RGrammarTest.class.getResourceAsStream("/sample-grammars/24hr-rpg.gram");
+
+		RGrammarSet grammarSet = new RGrammarSet();
 
 		RGrammarParser parse = new RGrammarParser();
 
 		RGrammar grammar = parse.readGrammar(stream);
 
-		System.out.println(grammar.generate(null));
+		grammarSet.addGrammar("rpg", grammar);
+
+		for(int i = 0; i < 10; i++) {
+			System.out.println(grammar.generate(null));
+		}
 	}
 }
diff --git a/RGens/src/main/java/bjc/rgens/newparser/RuleCase.java b/RGens/src/main/java/bjc/rgens/newparser/RuleCase.java
index e919cb8..9652273 100644
--- a/RGens/src/main/java/bjc/rgens/newparser/RuleCase.java
+++ b/RGens/src/main/java/bjc/rgens/newparser/RuleCase.java
@@ -18,7 +18,7 @@ public class RuleCase {
 		/**
 		 * A normal case, composed from a list of elementList.
 		 */
-		NORMAL;
+		NORMAL,
 	}
 
 	/**