Refactored ParserIntronExon out of Parser. This should allow things like Java-style comments for code-generation frameworks.

Author: nedtwigg

src/main/java/com/diffplug/freshmark/CommentScript.java

@@ -15,8 +15,6 @@
  */
 package com.diffplug.freshmark;
 
-import java.util.regex.Pattern;
-
 import javax.script.ScriptEngine;
 import javax.script.ScriptException;
 
@@ -52,33 +50,18 @@
  */
 public abstract class CommentScript {
 	/**
-	 * Creates a CommentScript with the given comment intron/exon pair.
-	 * <p>
-	 * Comment blocks will be parsed using the following regex:
-	 * <pre>
-	 * Pattern.quote(intron) + "(.*?)" + Pattern.quote(exon)
-	 * </pre>
-	 * */
-	protected CommentScript(String intron, String exon) {
-		this(intron, exon, Pattern.quote(intron) + "(.*?)" + Pattern.quote(exon));
-	}
-
-	/**
-	 * Creates a CommentScript with the given comment intron/exon pair, as well
-	 * as a custom regex.
-	 * <p>
-	 * Usually, you should use the {@link #CommentScript(String, String)} constructor,
-	 * unless there are some special rules for how comment blocks are parsed. 
+	 * Creates a CommentScript using the given parser to
+	 * delineate and combine comment blocks.
 	 */
-	protected CommentScript(String intron, String exon, String regex) {
-		parser = new Parser(intron, exon, regex);
+	protected CommentScript(Parser parser) {
+		this.parser = parser;
 	}
 
 	/** Parser which splits up the raw document into structured tags which get passed to the compiler. */
 	final Parser parser;
 
 	/** Compiles a single section/script/input combo into the appropriate output. */
-	final Parser.SectionCompiler compiler = new Parser.SectionCompiler() {
+	final ParserIntronExon.SectionCompiler compiler = new ParserIntronExon.SectionCompiler() {
 		@Override
 		public String compileSection(String section, String script, String input) {
 			return Errors.rethrow().get(() -> {

src/main/java/com/diffplug/freshmark/CommentScriptMustache.java

@@ -48,13 +48,8 @@
  */
 public abstract class CommentScriptMustache extends CommentScript {
 	/** @see CommentScript#CommentScript(String, String) */
-	protected CommentScriptMustache(String intron, String exon) {
-		super(intron, exon);
-	}
-
-	/** @see CommentScript#CommentScript(String, String, String) */
-	protected CommentScriptMustache(String intron, String exon, String regex) {
-		super(intron, exon, regex);
+	protected CommentScriptMustache(Parser parser) {
+		super(parser);
 	}
 
 	/** Replaces whatever is inside of {@code {{key}}} tags using the {@code keyToValue} function. */

src/main/java/com/diffplug/freshmark/FreshMark.java

@@ -30,7 +30,7 @@
 import com.diffplug.jscriptbox.JScriptBox;
 import com.diffplug.jscriptbox.Language;
 
-/** The defaault implementation. */
+/** The default implementation. */
 public class FreshMark extends CommentScriptMustache {
 	private static final String INTRON = "<!---freshmark";
 	private static final String EXON = "-->";
@@ -39,7 +39,7 @@ public class FreshMark extends CommentScriptMustache {
 	private final Consumer<String> warningStream;
 
 	public FreshMark(Map<String, ?> properties, Consumer<String> warningStream) {
-		super(INTRON, EXON, Pattern.quote(INTRON) + "(.*?)" + Pattern.quote(EXON));
+		super(new ParserIntronExon(INTRON, EXON));
 		this.properties = properties;
 		this.warningStream = warningStream;
 	}

src/main/java/com/diffplug/freshmark/Parser.java

@@ -16,19 +16,9 @@
 package com.diffplug.freshmark;
 
 import java.util.function.Consumer;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 /** A format defined by "tag start" and "tag end" chunks of text. */
-class Parser {
-	final String intron, exon;
-	final Pattern pattern;
-
-	Parser(String intron, String exon, String regex) {
-		this.intron = intron;
-		this.exon = exon;
-		pattern = Pattern.compile(regex, Pattern.DOTALL);
-	}
+public abstract class Parser {
 
 	/**
 	 * Given an input string, parses out the body sections from the tag sections.
@@ -37,20 +27,7 @@ class Parser {
 	 * @param body		called for every chunk of text outside a tag
 	 * @param tag		called for every chunk of text inside a tag
 	 */
-	protected void bodyAndTags(String rawInput, Consumer<String> body, Consumer<String> tag) {
-		Matcher matcher = pattern.matcher(rawInput);
-		int last = 0;
-		while (matcher.find()) {
-			if (matcher.start() > last) {
-				body.accept(rawInput.substring(last, matcher.start()));
-			}
-			tag.accept(matcher.group(1));
-			last = matcher.end();
-		}
-		if (last < rawInput.length()) {
-			body.accept(rawInput.substring(last));
-		}
-	}
+	protected abstract void bodyAndTags(String rawInput, Consumer<String> body, Consumer<String> tag);
 
 	/**
 	 * Reassembles a section/script/output chunk back into
@@ -61,21 +38,7 @@ protected void bodyAndTags(String rawInput, Consumer<String> body, Consumer<Stri
 	 * @param output
 	 * @return
 	 */
-	protected String reassemble(String section, String script, String output) {
-		// make sure that the compiled output starts and ends with a newline,
-		// so that the tags stay separated separated nicely
-		if (!output.startsWith("\n")) {
-			output = "\n" + output;
-		}
-		if (!output.endsWith("\n")) {
-			output = output + "\n";
-		}
-		return intron + " " + section + "\n" +
-				script +
-				exon +
-				output +
-				intron + " /" + section + " " + exon;
-	}
+	protected abstract String reassemble(String section, String script, String output);
 
 	/** Interface which can compile a single section of a FreshMark document. */
 	@FunctionalInterface
@@ -106,9 +69,11 @@ Consumer<String> wrap(Consumer<String> action) {
 							numReadSoFar += input.length();
 						} else {
 							// tag
-							String tag = intron + input + exon;
-							assert(toRead.startsWith(tag));
-							numReadSoFar += tag.length();
+							// TODO: we don't have enough information to do line-based
+							// error checking, so it's just turned off entirely
+							//String tag = intron + input + exon;
+							//assert(toRead.startsWith(tag));
+							//numReadSoFar += tag.length();
 						}
 					} catch (Throwable e) {
 						long problemStart = 1 + countNewlines(fullInput.substring(0, numReadSoFar));

src/main/java/com/diffplug/freshmark/ParserIntronExon.java

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2015 DiffPlug
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.diffplug.freshmark;
+
+import java.util.function.Consumer;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/** A format defined by "tag start" and "tag end" chunks of text. */
+public class ParserIntronExon extends Parser {
+	final String intron, exon;
+	final Pattern pattern;
+
+	/**
+	 * A Parser which uses simple intron / exon string to delimit comments.
+	 * <p> 
+	 * Comment blocks will be parsed using the following regex:
+	 * <pre>
+	 * Pattern.quote(intron) + "(.*?)" + Pattern.quote(exon)
+	 * </pre>
+	 */
+	public ParserIntronExon(String intron, String exon) {
+		this(intron, exon, Pattern.quote(intron) + "(.*?)" + Pattern.quote(exon));
+	}
+
+	/**
+	 * A Parser with the given comment intron/exon pair, with a custom regex.
+	 * <p>
+	 * Usually, you should use the {@link #Parser(String, String)} constructor,
+	 * unless there are some special rules for how comment blocks are parsed. 
+	 */
+	public ParserIntronExon(String intron, String exon, String regex) {
+		this.intron = intron;
+		this.exon = exon;
+		pattern = Pattern.compile(regex, Pattern.DOTALL);
+	}
+
+	/**
+	 * Given an input string, parses out the body sections from the tag sections.
+	 * 
+	 * @param rawInput 	the raw input string
+	 * @param body		called for every chunk of text outside a tag
+	 * @param tag		called for every chunk of text inside a tag
+	 */
+	@Override
+	protected void bodyAndTags(String rawInput, Consumer<String> body, Consumer<String> tag) {
+		Matcher matcher = pattern.matcher(rawInput);
+		int last = 0;
+		while (matcher.find()) {
+			if (matcher.start() > last) {
+				body.accept(rawInput.substring(last, matcher.start()));
+			}
+			tag.accept(matcher.group(1));
+			last = matcher.end();
+		}
+		if (last < rawInput.length()) {
+			body.accept(rawInput.substring(last));
+		}
+	}
+
+	/**
+	 * Reassembles a section/script/output chunk back into
+	 * the full file.
+	 * 
+	 * @param section
+	 * @param script
+	 * @param output
+	 * @return
+	 */
+	@Override
+	protected String reassemble(String section, String script, String output) {
+		// make sure that the compiled output starts and ends with a newline,
+		// so that the tags stay separated separated nicely
+		if (!output.startsWith("\n")) {
+			output = "\n" + output;
+		}
+		if (!output.endsWith("\n")) {
+			output = output + "\n";
+		}
+		return intron + " " + section + "\n" +
+				script +
+				exon +
+				output +
+				intron + " /" + section + " " + exon;
+	}
+}