Throw ANTLR errors (#421)

This guarantees (more) exceptions to be thrown. Note that it isn't sufficient to
just add a default (or: minimal) catch handler to all expressions, e.g. adding
that to the 'atom' expression would result in an not detailed enough message.

The overriding of 'recoverFromMismatchedToken' guarantees the throwing of an
exception when attempting a recover (before that would be reported but not thrown (see
metafacture/metafacture-playground#84 )).

- use 'FluxParseException' instead of 'RuntimeException'
- add some more tests

Author: dr0i

metafacture-flux/build.gradle

@@ -23,6 +23,7 @@ dependencies {
   api project(':metafacture-framework')
   implementation project(':metafacture-commons')
   implementation project(':metafacture-io')
+  implementation project(':metafacture-plumbing')
   antlr 'org.antlr:antlr:3.5.2'
   testImplementation 'junit:junit:4.12'
 }

metafacture-flux/src/main/antlr/org/metafacture/flux/parser/Flux.g

@@ -41,6 +41,34 @@ import org.metafacture.flux.FluxParseException;
 package org.metafacture.flux.parser;
 }
 
+@parser::members {
+    // ensure throwing an exception
+    @Override
+    protected Object recoverFromMismatchedToken(IntStream input, int ttype, BitSet follow) throws RecognitionException {
+      {
+        RecognitionException e = new MismatchedTokenException(ttype, input);
+        // if next token is what we are looking for then "delete" this token
+        if ( mismatchIsUnwantedToken(input, ttype) ) {
+          e = new UnwantedTokenException(ttype, input);
+          beginResync();
+          input.consume(); // simply delete extra token
+          endResync();
+          reportError(e);  // report after consuming so AW sees the token in the exception
+          // we want to return the token we're actually matching
+          Object matchedSymbol = getCurrentInputSymbol(input);
+          input.consume(); // move past ttype token as if all were ok
+        }
+        // can't recover with single token deletion, try insertion
+        if ( mismatchIsMissingToken(input, follow) ) {
+          Object inserted = getMissingSymbol(input, e, ttype, follow);
+          e = new MissingTokenException(ttype, input, inserted);
+          reportError(e);  // report after inserting so AW sees the token in the exception
+        }
+        throw e;
+      }
+    }
+}
+
 flux
   :
   varDef* flow*
@@ -88,6 +116,9 @@ tee
         ^(SUBFLOW flowtail)+
        )
   ;
+catch [RecognitionException re] {
+    throw re;
+}
 
 flowtail
   :
@@ -103,6 +134,9 @@ flowtail
     )
   )*
   ;
+catch [RecognitionException re] {
+    throw re;
+}
 
 StdIn
   :
@@ -120,6 +154,9 @@ exp
   :
   atom ('+'^ atom)*
   ;
+catch [RecognitionException re] {
+    throw re;
+}
 
 atom
   :
@@ -137,6 +174,9 @@ pipeArgs
   )
   (','! namedArg)*
   ;
+catch [RecognitionException re] {
+    throw re;
+}
 
 namedArg
   :

metafacture-flux/src/test/java/org/metafacture/flux/FluxGrammarTest.java

@@ -28,8 +28,8 @@
 import org.antlr.runtime.RecognitionException;
 import org.junit.Before;
 import org.junit.Test;
+import org.metafacture.commons.reflection.ReflectionException;
 import org.metafacture.flux.parser.FluxProgramm;
-import org.metafacture.framework.MetafactureException;
 
 /**
  * Tests for the Flux grammar.
@@ -91,7 +91,7 @@ public void shouldReplaceJavaEscapeSequences()
     }
 
     @Test(expected = FluxParseException.class)
-    public void issue421_shouldThrowRuntimeExceptionWhenSemicolonInFlowIsMissing()
+    public void issue421_shouldThrowFluxParseExceptionWhenSemicolonInFlowIsMissing()
         throws RecognitionException, IOException {
         final String script = "\"test\"|print";
         try {
@@ -102,18 +102,91 @@ public void issue421_shouldThrowRuntimeExceptionWhenSemicolonInFlowIsMissing()
         }
     }
 
-    @Test(expected = RuntimeException.class)
-    public void issue421_shouldThrowRuntimeExceptionWhenSemicolonInVarDefIsMissing()
+    @Test(expected = FluxParseException.class)
+    public void issue421_shouldThrowFluxParseExceptionWhenSemicolonInVarDefIsMissing()
         throws RecognitionException, IOException {
         final String script = "foo=42";
         try {
             FluxCompiler.compile(createInputStream(script), emptyMap());
-        } catch (RuntimeException re) {
+        } catch (FluxParseException re) {
             assertEquals("mismatched input '<EOF>' expecting ';' in Flux", re.getMessage());
             throw re;
         }
     }
 
+    @Test(expected = ReflectionException.class)
+    public void issue421_shouldThrowReflectionExceptionWhenCommandIsNotFound()
+        throws RecognitionException, IOException {
+        final String script = "\"test\"|prin;";
+        try {
+            FluxCompiler.compile(createInputStream(script), emptyMap());
+        } catch (ReflectionException re) {
+             assertEquals("Class not found: prin", re.getMessage());
+            throw re;
+        }
+    }
+
+    @Test(expected = FluxParseException.class)
+    public void issue421_shouldThrowFluxParseExceptionWhenInputIsMissingAfterPipe1()
+        throws RecognitionException, IOException {
+        final String script =  "\"test\"|";
+        try {
+            FluxCompiler.compile(createInputStream(script), emptyMap());
+        } catch (FluxParseException re) {
+            assertEquals("no viable alternative at input '<EOF>' in Flux", re.getMessage());
+            throw re;
+        }
+    }
+
+    @Test(expected = FluxParseException.class)
+    public void issue421_shouldThrowFluxParseExceptionWhenInputIsMissingAfterPipe2()
+        throws RecognitionException, IOException {
+        final String script =  "\"test\"|;";
+        try {
+            FluxCompiler.compile(createInputStream(script), emptyMap());
+        } catch (FluxParseException re) {
+            assertEquals("no viable alternative at input ';' in Flux", re.getMessage());
+            throw re;
+        }
+    }
+
+    @Test(expected = FluxParseException.class)
+    public void issue421_shouldThrowFluxParseExceptionWhenTeeStructureOccursWithouATeeCommand()
+        throws RecognitionException, IOException {
+        final String script = "\"test\"|{print}{print} ;";
+        try {
+            FluxCompiler.compile(createInputStream(script), emptyMap());
+        } catch (FluxParseException re) {
+            assertEquals("Flow cannot be split without a tee-element.", re.getMessage());
+            throw re;
+        }
+    }
+
+    @Test(expected = FluxParseException.class)
+    public void issue421_shouldThrowFluxParseExceptionWhenTeeIsNotASender()
+        throws RecognitionException, IOException {
+        final String script =  "\"test\"|print|object-tee|{print}{print} ;";
+        try {
+            FluxCompiler.compile(createInputStream(script), emptyMap());
+        } catch (FluxParseException re) {
+            assertEquals("org.metafacture.io.ObjectStdoutWriter is not a sender", re.getMessage());
+            throw re;
+        }
+    }
+
+    @Test(expected = FluxParseException.class)
+    public void issue421_shouldInsertMissingSymbolsWhenTeeIsStructurallyInvalid()
+        throws RecognitionException, IOException {
+        final String script =  "\"test\"|object-tee|{object-tee{print{print} ;";
+        try {
+            FluxCompiler.compile(createInputStream(script), emptyMap());
+            String tmp=stdoutBuffer.toString();
+        } catch (FluxParseException re) {
+            assertEquals("missing '}' at '{' in Flux", re.getMessage());
+            throw re;
+        }
+    }
+
     private ByteArrayInputStream createInputStream(String script) {
         return new ByteArrayInputStream(script.getBytes(StandardCharsets.UTF_8));
     }