Add macro() Fix bind and function.

Author: blackwinter

README.md

@@ -192,15 +192,15 @@ put_map("<mapName>",
 
 ##### `put_var`
 
-Defines a single internal variable that can be referenced with `$[<variableName>]`.
+Defines a single global variable that can be referenced with `$[<variableName>]`.
 
 ```perl
 put_var("<variableName>", "<variableValue>")
 ```
 
 ##### `put_vars`
 
-Defines multiple internal variables that can be referenced with `$[<variableName>]`.
+Defines multiple global variables that can be referenced with `$[<variableName>]`.
 
 ```perl
 put_vars(
@@ -266,6 +266,25 @@ hash("foo")
 # ["name", "value"] => {"name":"value"}
 ```
 
+##### `macro`
+
+Calls a named macro, i.e. a list of statements that have been previously defined with the [`do macro`](#do-macro) bind.
+
+Parameters:
+
+- `name` (required): Unique name of the macro.
+
+Options:
+
+- All options are made available as "dynamic" local variables.
+
+```perl
+do macro("<macroName>"[, <staticLocalVariables>...])
+  ...
+end
+macro("<macroName>"[, <dynamicLocalVariables>...])
+```
+
 ##### `move_field`
 
 Moves (or appends to) a field from an existing field. Can be used to rename a field.
@@ -613,6 +632,25 @@ do list(path: "<sourceField>", "var": "<variableName>")
 end
 ```
 
+#### `do macro`
+
+Defines a named macro, i.e. a list of statements that can be executed later with the [`macro`](#macro) function.
+
+Parameters:
+
+- `name` (required): Unique name of the macro.
+
+Options:
+
+- All options are made available as "static" local variables.
+
+```perl
+do macro("<macroName>"[, <staticLocalVariables>...])
+  ...
+end
+macro("<macroName>"[, <dynamicLocalVariables>...])
+```
+
 #### `do once`
 
 Executes the statements only once (when the bind is first encountered), not repeatedly for each record.

metafix/src/main/java/org/metafacture/metafix/FixBind.java

@@ -60,8 +60,16 @@ public void execute(final Metafix metafix, final Record record, final List<Strin
         }
     },
 
+    macro {
+        @Override
+        public void execute(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options, final RecordTransformer recordTransformer) {
+            recordTransformer.addVars(options);
+            metafix.putMacro(params.get(0), recordTransformer);
+        }
+    },
+
     once {
-        private Map<Metafix, Set<String>> executed = new HashMap<>();
+        private final Map<Metafix, Set<String>> executed = new HashMap<>();
 
         @Override
         public void execute(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options, final RecordTransformer recordTransformer) {

metafix/src/main/java/org/metafacture/metafix/FixMethod.java

@@ -153,6 +153,18 @@ public void apply(final Metafix metafix, final Record record, final List<String>
             })));
         }
     },
+    macro {
+        @Override
+        public void apply(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
+            final RecordTransformer recordTransformer = metafix.getMacro(params.get(0));
+            if (recordTransformer != null) {
+                recordTransformer.transform(record, options);
+            }
+            else {
+                // TODO?: Metamorph throws MorphBuildException("Macro '" + macroName + "' undefined!")
+            }
+        }
+    },
     move_field {
         @Override
         public void apply(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {

metafix/src/main/java/org/metafacture/metafix/Metafix.java

@@ -72,8 +72,9 @@ public class Metafix implements StreamPipe<StreamReceiver>, Maps {
     private final Deque<Integer> entityCountStack = new LinkedList<>();
     private final List<Closeable> resources = new ArrayList<>();
     private final List<Expression> expressions = new ArrayList<>();
-    private final Map<String, RecordTransformer> fixCache = new HashMap<>();
     private final Map<String, Map<String, String>> maps = new HashMap<>();
+    private final Map<String, RecordTransformer> fixCache = new HashMap<>();
+    private final Map<String, RecordTransformer> macros = new HashMap<>();
     private final Map<String, String> vars = new HashMap<>();
     private final RecordTransformer recordTransformer;
     private final StreamFlattener flattener = new StreamFlattener();
@@ -163,6 +164,14 @@ private RecordTransformer getRecordTransformer(final Reader fixDef) {
         return new RecordTransformer(this, FixStandaloneSetup.parseFix(fixDef));
     }
 
+    public void putMacro(final String name, final RecordTransformer macro) {
+        macros.put(name, macro);
+    }
+
+    public RecordTransformer getMacro(final String name) {
+        return macros.get(name);
+    }
+
     public List<Expression> getExpressions() {
         return expressions;
     }

metafix/src/main/java/org/metafacture/metafix/RecordTransformer.java

@@ -38,6 +38,7 @@
 import org.slf4j.LoggerFactory;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.LinkedList;
 import java.util.List;
@@ -47,6 +48,8 @@
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
+// TODO: Utilize org.metafacture.commons.types.ScopedHashMap for vars instead?
+
 /**
  * Transform a record using a {@link Fix}.
  *
@@ -58,7 +61,7 @@ public class RecordTransformer { // checkstyle-disable-line ClassFanOutComplexit
     private static final Logger LOG = LoggerFactory.getLogger(RecordTransformer.class);
 
     private final List<Consumer<Record>> consumers = new LinkedList<>();
-    private final Map<String, String> vars;
+    private final List<Map<String, String>> vars = new ArrayList<>();
     private final Metafix metafix;
 
     private Supplier<String> currentMessageSupplier;
@@ -69,7 +72,7 @@ public class RecordTransformer { // checkstyle-disable-line ClassFanOutComplexit
 
     private RecordTransformer(final Metafix metafix, final List<Expression> expressions) {
         this.metafix = metafix;
-        vars = metafix.getVars();
+        addVars(metafix.getVars());
 
         expressions.forEach(e -> {
             final Params params = new Params(e.getParams(), vars);
@@ -93,6 +96,22 @@ else if (e instanceof MethodCall) {
         });
     }
 
+    public void addVars(final Map<String, String> additionalVars) {
+        vars.add(additionalVars);
+    }
+
+    public void transform(final Record record, final Map<String, String> additionalVars) {
+        final int index = vars.size();
+        addVars(additionalVars);
+
+        try {
+            transform(record);
+        }
+        finally {
+            vars.remove(index);
+        }
+    }
+
     public void transform(final Record record) {
         consumers.forEach(consumer -> {
             final FixExecutionException exception = tryRun(() -> consumer.accept(record));
@@ -246,17 +265,23 @@ protected String resolveVars(final String value, final Map<String, String> vars)
             return value == null ? null : StringUtil.format(value, Metafix.VAR_START, Metafix.VAR_END, false, vars);
         }
 
+        protected Map<String, String> mergeVars(final List<Map<String, String>> vars) {
+            final Map<String, String> mergedVars = new HashMap<>();
+            vars.forEach(mergedVars::putAll);
+            return mergedVars;
+        }
+
         protected abstract T resolve();
 
     }
 
     private static class Params extends AbstractResolvable<List<String>> {
 
         private final List<String> list;
-        private final Map<String, String> vars;
+        private final List<Map<String, String>> vars;
         private final boolean resolve;
 
-        private Params(final List<String> list, final Map<String, String> vars) {
+        private Params(final List<String> list, final List<Map<String, String>> vars) {
             this.list = list;
             this.vars = vars;
 
@@ -267,9 +292,10 @@ private Params(final List<String> list, final Map<String, String> vars) {
         protected List<String> resolve() {
             if (resolve) {
                 final List<String> resolvedList = new ArrayList<>(list.size());
+                final Map<String, String> mergedVars = mergeVars(vars);
 
                 for (final String entry : list) {
-                    resolvedList.add(resolveVars(entry, vars));
+                    resolvedList.add(resolveVars(entry, mergedVars));
                 }
 
                 return resolvedList;
@@ -284,10 +310,10 @@ protected List<String> resolve() {
     private static class Options extends AbstractResolvable<Map<String, String>> {
 
         private final Map<String, String> map = new LinkedHashMap<>();
-        private final Map<String, String> vars;
+        private final List<Map<String, String>> vars;
         private final boolean resolve;
 
-        private Options(final org.metafacture.metafix.fix.Options options, final Map<String, String> vars) {
+        private Options(final org.metafacture.metafix.fix.Options options, final List<Map<String, String>> vars) {
             this.vars = vars;
 
             boolean resolveTemp = false;
@@ -315,9 +341,10 @@ private Options(final org.metafacture.metafix.fix.Options options, final Map<Str
         protected Map<String, String> resolve() {
             if (resolve) {
                 final Map<String, String> resolvedMap = new LinkedHashMap<>(map.size());
+                final Map<String, String> mergedVars = mergeVars(vars);
 
                 for (final Map.Entry<String, String> entry : map.entrySet()) {
-                    resolvedMap.put(resolveVars(entry.getKey(), vars), resolveVars(entry.getValue(), vars));
+                    resolvedMap.put(resolveVars(entry.getKey(), mergedVars), resolveVars(entry.getValue(), mergedVars));
                 }
 
                 return resolvedMap;

metafix/src/test/java/org/metafacture/metafix/MetafixRecordTest.java

@@ -1989,6 +1989,118 @@ public void arrayFromHash() {
             });
     }
 
+    @Test
+    public void shouldCallMacro() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "do macro('test')",
+                "  add_field('test', '42')",
+                "end",
+                "macro('test')",
+                "macro('test')"
+            ),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+            },
+            (o, f) -> {
+                o.get().startRecord("1");
+                f.apply(2).literal("test", "42");
+                o.get().endRecord();
+            }
+        );
+    }
+
+    @Test
+    public void shouldNotCallUnknownMacro() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "macro('test')",
+                "macro('test')"
+            ),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+            },
+            o -> {
+                o.get().startRecord("1");
+                o.get().endRecord();
+            }
+        );
+    }
+
+    @Test
+    public void shouldCallMacroWithVariables() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "put_vars(a: '1', b: '2')", // global variables
+                "do macro('test', b: '22', c: '33')", // "static" local variables
+                "  add_field('test', '$[a]-$[b]-$[c]-$[d]')",
+                "end",
+                "macro('test', c: '333', d: '444')", // "dynamic" local variables
+                "macro('test', b: '555', d: '666')",
+                "add_field('vars', '$[a]-$[b]')"
+            ),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+            },
+            o -> {
+                o.get().startRecord("1");
+                o.get().literal("test", "1-22-333-444");
+                o.get().literal("test", "1-555-33-666");
+                o.get().literal("vars", "1-2");
+                o.get().endRecord();
+            }
+        );
+    }
+
+    @Test
+    public void shouldNotLeakVariablesFromMacro() {
+        MetafixTestHelpers.assertProcessException(IllegalArgumentException.class, "Variable 'c' was not assigned!\nAssigned variables:\n{a=1, b=2}", () ->
+            MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                    "put_vars(a: '1', b: '2')", // global variables
+                    "do macro('test', b: '22', c: '33')", // "static" local variables
+                    "end",
+                    "macro('test', c: '333', d: '444')", // "dynamic" local variables
+                    "macro('test', b: '555', d: '666')",
+                    "add_field('test', '$[a]-$[b]-$[c]-$[d]')"
+                ),
+                i -> {
+                    i.startRecord("1");
+                    i.endRecord();
+                },
+                o -> {
+                }
+            )
+        );
+    }
+
+    @Test
+    public void shouldCallNestedMacro() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "do macro('test1', c: '23')",
+                "  add_field('test$[a]', '42')",
+                "  macro('test2', b: '$[b]', c: '$[c]')",
+                "end",
+                "do macro('test2')",
+                "  add_field('test$[b]', '$[c]')",
+                "end",
+                "macro('test1', a: '1', b: '2')",
+                "macro('test1', a: '3', b: '4')"
+            ),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+            },
+            o -> {
+                o.get().startRecord("1");
+                o.get().literal("test1", "42");
+                o.get().literal("test2", "23");
+                o.get().literal("test3", "42");
+                o.get().literal("test4", "23");
+                o.get().endRecord();
+            }
+        );
+    }
+
     @Test
     public void reject() {
         MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(