Set up draft tree grammar and classes for Fix, analogous to Flux

See metafacture/metafacture-fix#298

Author: fsteeg

metafacture-fix/build.gradle

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 Christoph Böhme
+ * Copyright 2024 Fabian Steeg, hbz
  *
  * Licensed under the Apache License, Version 2.0 the "License";
  * you may not use this file except in compliance with the License.
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-ext.mavenName = 'Metafacture Flux'
-description = 'A domain specific language for building Metafacture pipelines'
+ext.mavenName = 'Metafacture Fix'
+description = 'A domain specific language for building Metafacture transformations'
 
 apply plugin: 'antlr'
 

metafacture-fix/src/main/antlr/org/metafacture/fix/parser/RecordTransformerBuilder.g

@@ -0,0 +1,58 @@
+/*
+ *  Copyright 2024 Fabian Steeg, hbz
+ *
+ *  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.
+ */
+tree grammar RecordTransformerBuilder;
+
+options {
+language = Java;
+tokenVocab = Fix;
+ASTLabelType = CommonTree;
+}
+
+@header {
+package org.metafacture.fix.parser;
+
+import java.util.Map;
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Collections;
+import org.metafacture.fix.parser.RecordTransformer;
+}
+
+@members {
+private RecordTransformer transformer = new RecordTransformer();
+}
+
+transformer returns [RecordTransformer retValue = transformer] : expression*;
+
+expression	: (doExpr | unless | ifExpr | methodCall | COMMENT) WS*;
+
+methodCall	: method=ID '(' param=(ID|option) (',' (ID|option))* ')'
+{
+  transformer.processMethod($method.text, $param.text);
+};
+
+doExpr	: 'do' methodCall expression* 'end';
+
+unless	: 'unless' methodCall expression* 'end';
+
+ifExpr	: 'if' methodCall expression* elsIf* elseExpr? 'end';
+
+elsIf	: 'elsif' methodCall expression*;
+
+elseExpr: 'else' expression*;
+
+option	: ID ':' ID;

metafacture-fix/src/main/java/org/metafacture/fix/Metafix.java

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2024 Fabian Steeg, hbz
+ *
+ * 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 org.metafacture.fix;
+
+import org.metafacture.fix.parser.FixLexer;
+import org.metafacture.fix.parser.FixParser;
+import org.metafacture.fix.parser.RecordTransformer;
+import org.metafacture.fix.parser.RecordTransformerBuilder;
+
+import org.antlr.runtime.ANTLRInputStream;
+import org.antlr.runtime.CommonTokenStream;
+import org.antlr.runtime.RecognitionException;
+import org.antlr.runtime.tree.CommonTreeNodeStream;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Map;
+
+/**
+ * Creates a flow based on a flux script.
+ *
+ * @author Fabian Steeg
+ */
+// This is based on FluxCompiler, but using the ANTLR Fix draft. To be replaced by the Metafix class from metafacture-fix.
+// See https://github.com/metafacture/metafacture-fix/blob/master/metafix/src/main/java/org/metafacture/metafix/Metafix.java
+public final class Metafix {
+    private Metafix() {
+        // no instances
+    }
+
+    /**
+     * Compiles the Fix to a RecordTransformer.
+     *
+     * @see RecordTransformer
+     * @param fix the Fix
+     * @param vars the variables of the Fix
+     * @return the RecordTransformer
+     * @throws RecognitionException if an ANTLR exception occurs
+     * @throws IOException          if an I/O error occurs
+     */
+    public static RecordTransformer compile(final InputStream fix, final Map<String, String> vars) throws RecognitionException, IOException {
+        return compileFix(compileAst(fix), vars);
+    }
+
+    private static CommonTreeNodeStream compileAst(final InputStream flowDef) throws IOException, RecognitionException {
+        final FixParser parser = new FixParser(new CommonTokenStream(new FixLexer(new ANTLRInputStream(flowDef))));
+        return new CommonTreeNodeStream(parser.fix().getTree());
+    }
+
+    private static RecordTransformer compileFix(final CommonTreeNodeStream treeNodes, final Map<String, String> vars)
+            throws RecognitionException {
+        final RecordTransformerBuilder builder = new RecordTransformerBuilder(treeNodes);
+        return builder.transformer();
+    }
+}

metafacture-fix/src/main/java/org/metafacture/fix/parser/RecordTransformer.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2024 Fabian Steeg, hbz
+ *
+ * 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 org.metafacture.fix.parser;
+
+/**
+ * @author Fabian Steeg
+ *
+ */
+// For Flux, the equivalent of this class is `FluxProgramm`. In metafacture-fix, we have RecordTransformer, to be rewritten for ANTLR here.
+// See https://github.com/metafacture/metafacture-fix/blob/master/metafix/src/main/java/org/metafacture/metafix/RecordTransformer.java
+@SuppressWarnings("checkstyle:MissingCtor")
+public final class RecordTransformer {
+    /**
+     * @param name The method name
+     * @param param The param passed to the method
+     */
+    // sample method called from the tree grammar / RecordTransformerBuilder
+    public void processMethod(final String name, final String param) {
+        System.out.printf("Called processMethod: %s with %s\n", name, param);
+    }
+
+}

metafacture-fix/src/test/java/org/metafacture/fix/FixGrammarTest.java

@@ -20,6 +20,7 @@
 
 import org.metafacture.fix.parser.FixLexer;
 import org.metafacture.fix.parser.FixParser;
+import org.metafacture.fix.parser.RecordTransformer;
 
 import org.antlr.runtime.ANTLRInputStream;
 import org.antlr.runtime.CommonTokenStream;
@@ -40,18 +41,18 @@ public final class FixGrammarTest {
 
     @Test
     public void parseSimpleFix() {
-        assertEquals("add_field ( test )", parseToString("add_field(test)"));
+        assertEquals("add_field ( test )", parse("add_field(test)"));
     }
 
     @Test
     public void parseSimpleFixWithOption() {
-        assertEquals("add_field ( test1 , option : test2 )", parseToString("add_field(test1,option:test2)"));
+        assertEquals("add_field ( test1 , option : test2 )", parse("add_field(test1,option:test2)"));
     }
 
     @Test
     public void parseFixWithIf() {
         assertEquals("if some ( test1 ) add ( something ) elsif some ( test2 ) add ( somethingElse , opt : one ) else add ( anotherThing , opt : two ) end",
-                parseToString(
+                parse(
                     "if some(test1)",
                     "  add(something)",
                     "elsif some(test2)",
@@ -65,21 +66,28 @@ public void parseFixWithIf() {
     @Test
     public void parseError() {
         assertEquals("<unexpected: [@3,14:14='<EOF>',<-1>,1:14], resync=add_field(> <mismatched token: [@3,14:14='<EOF>',<-1>,1:14], resync=test>",
-                parseToString("add_field(test"));
+                parse("add_field(test"));
     }
 
-    private String parseToString(final String... fixLines) {
+    private String parse(final String... fixLines) {
+        final String input = String.join("\n", fixLines);
         try {
-            final ByteArrayInputStream fixInput = createInputStream(String.join("\n", fixLines));
-            final FixLexer lexer = new FixLexer(new ANTLRInputStream(fixInput));
-            final FixParser parser = new FixParser(new CommonTokenStream(lexer));
-            return ((Tree) parser.fix().getTree()).toStringTree();
+            RecordTransformer transformer = Metafix.compile(createInputStream(input), null);
+            System.out.println("Created RecordTransformer for fix: " + transformer);
+            return parseToStringTree(input);
         } catch (IOException | RecognitionException e) {
             e.printStackTrace();
             return null;
         }
     }
 
+    private String parseToStringTree(final String input) throws IOException, RecognitionException {
+        final ByteArrayInputStream fixInput = createInputStream(input);
+        final FixLexer lexer = new FixLexer(new ANTLRInputStream(fixInput));
+        final FixParser parser = new FixParser(new CommonTokenStream(lexer));
+        return ((Tree) parser.fix().getTree()).toStringTree();
+    }
+
     private ByteArrayInputStream createInputStream(final String string) {
         return new ByteArrayInputStream(string.getBytes(StandardCharsets.UTF_8));
     }