Merge pull request #243 from metafacture/addMacroBindAndFunction

Add `put_macro()`/`call_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(
@@ -234,6 +234,25 @@ array("foo")
 # {"name":"value"} => ["name", "value"]
 ```
 
+##### `call_macro`
+
+Calls a named macro, i.e. a list of statements that have been previously defined with the [`do put_macro`](#do-put_macro) bind.
+
+Parameters:
+
+- `name` (required): Unique name of the macro.
+
+Options:
+
+- All options are made available as "dynamic" local variables in the macro.
+
+```perl
+do put_macro("<macroName>"[, <staticLocalVariables>...])
+  ...
+end
+call_macro("<macroName>"[, <dynamicLocalVariables>...])
+```
+
 ##### `copy_field`
 
 Copies (or appends to) a field from an existing field.
@@ -634,6 +653,31 @@ do once("vars setup")
 end
 ```
 
+#### `do put_macro`
+
+Defines a named macro, i.e. a list of statements that can be executed later with the [`call_macro`](#call_macro) function.
+
+Variables can be referenced with `$[<variableName>]`, in the following order of precedence:
+
+1. "dynamic" local variables, passed as options to the `call_macro` function;
+2. "static" local variables, passed as options to the `do put_macro` bind;
+3. global variables, defined via [`put_var`](#put_var)/[`put_vars`](#put_vars).
+
+Parameters:
+
+- `name` (required): Unique name of the macro.
+
+Options:
+
+- All options are made available as "static" local variables in the macro.
+
+```perl
+do put_macro("<macroName>"[, <staticLocalVariables>...])
+  ...
+end
+call_macro("<macroName>"[, <dynamicLocalVariables>...])
+```
+
 ### Conditionals
 
 Conditionals start with `if` in case of affirming the condition or `unless` rejecting the condition.

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

@@ -61,14 +61,22 @@ public void execute(final Metafix metafix, final Record record, final List<Strin
     },
 
     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) {
             if (executed.computeIfAbsent(metafix, k -> new HashSet<>()).add(params.isEmpty() ? null : params.get(0))) {
                 recordTransformer.transform(record);
             }
         }
+    },
+
+    put_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);
+        }
     }
 
 }

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

@@ -120,6 +120,20 @@ public void apply(final Metafix metafix, final Record record, final List<String>
             })));
         }
     },
+    call_macro {
+        @Override
+        public void apply(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
+            final String macroName = params.get(0);
+            final RecordTransformer recordTransformer = metafix.getMacro(macroName);
+
+            if (recordTransformer != null) {
+                recordTransformer.transform(record, options);
+            }
+            else {
+                throw new IllegalArgumentException("Macro '" + macroName + "' undefined!");
+            }
+        }
+    },
     copy_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,22 +61,24 @@ 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 final RecordTransformer parent;
 
     private Supplier<String> currentMessageSupplier;
 
     /*package-private*/ RecordTransformer(final Metafix metafix, final Fix fix) {
-        this(metafix, fix.getElements());
+        this(metafix, fix.getElements(), null);
+        addVars(metafix.getVars());
     }
 
-    private RecordTransformer(final Metafix metafix, final List<Expression> expressions) {
+    private RecordTransformer(final Metafix metafix, final List<Expression> expressions, final RecordTransformer parent) {
         this.metafix = metafix;
-        vars = metafix.getVars();
+        this.parent = parent;
 
         expressions.forEach(e -> {
-            final Params params = new Params(e.getParams(), vars);
-            final Options options = new Options(e.getOptions(), vars);
+            final Params params = new Params(e.getParams(), this);
+            final Options options = new Options(e.getOptions(), this);
 
             if (e instanceof Do) {
                 processDo((Do) e, params, options);
@@ -93,6 +98,26 @@ else if (e instanceof MethodCall) {
         });
     }
 
+    private RecordTransformer childTransformer(final List<Expression> expressions) {
+        return new RecordTransformer(metafix, expressions, this);
+    }
+
+    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));
@@ -106,7 +131,7 @@ public void transform(final Record record) {
     private void processDo(final Do expression, final Params params, final Options options) {
         processFix(() -> executionExceptionMessage(expression), () -> {
             final FixContext context = getInstance(expression.getName(), FixContext.class, FixBind::valueOf);
-            final RecordTransformer recordTransformer = new RecordTransformer(metafix, expression.getElements());
+            final RecordTransformer recordTransformer = childTransformer(expression.getElements());
 
             return record -> context.execute(metafix, record, params.resolve(), options.resolve(), recordTransformer);
         });
@@ -121,14 +146,14 @@ private void processIf(final If ifExpression, final Params ifParams, final Optio
 
         processFix(() -> executionExceptionMessage(ifExpression, ifExpression.eResource()), () -> {
             final FixPredicate ifPredicate = getInstance(ifExpression.getName(), FixPredicate.class, FixConditional::valueOf);
-            final RecordTransformer ifTransformer = new RecordTransformer(metafix, ifExpression.getElements());
+            final RecordTransformer ifTransformer = childTransformer(ifExpression.getElements());
 
             final List<FixPredicate> elseIfPredicates = mapList(elseIfExpressions, e -> getInstance(e.getName(), FixPredicate.class, FixConditional::valueOf));
-            final List<Params> elseIfParamsList = mapList(elseIfExpressions, e -> new Params(e.getParams(), vars));
-            final List<Options> elseIfOptionsList = mapList(elseIfExpressions, e -> new Options(e.getOptions(), vars));
-            final List<RecordTransformer> elseIfTransformers = mapList(elseIfExpressions, e -> new RecordTransformer(metafix, e.getElements()));
+            final List<Params> elseIfParamsList = mapList(elseIfExpressions, e -> new Params(e.getParams(), this));
+            final List<Options> elseIfOptionsList = mapList(elseIfExpressions, e -> new Options(e.getOptions(), this));
+            final List<RecordTransformer> elseIfTransformers = mapList(elseIfExpressions, e -> childTransformer(e.getElements()));
 
-            final RecordTransformer elseTransformer = elseExpression != null ? new RecordTransformer(metafix, elseExpression.getElements()) : null;
+            final RecordTransformer elseTransformer = elseExpression != null ? childTransformer(elseExpression.getElements()) : null;
 
             return record -> {
                 if (ifPredicate.test(metafix, record, ifParams.resolve(), ifOptions.resolve())) {
@@ -163,7 +188,7 @@ private void processIf(final If ifExpression, final Params ifParams, final Optio
     private void processUnless(final Unless expression, final Params params, final Options options) {
         processFix(() -> executionExceptionMessage(expression, expression.eResource()), () -> {
             final FixPredicate predicate = getInstance(expression.getName(), FixPredicate.class, FixConditional::valueOf);
-            final RecordTransformer recordTransformer = new RecordTransformer(metafix, expression.getElements());
+            final RecordTransformer recordTransformer = childTransformer(expression.getElements());
 
             return record -> {
                 if (!predicate.test(metafix, record, params.resolve(), options.resolve())) {
@@ -236,6 +261,12 @@ private String executionExceptionMessage(final EObject object, final Resource re
                 resource.getURI(), node.getStartLine(), NodeModelUtils.getTokenText(node));
     }
 
+    private Map<String, String> getVars() {
+        final Map<String, String> mergedVars = parent != null ? parent.getVars() : new HashMap<>();
+        vars.forEach(mergedVars::putAll);
+        return mergedVars;
+    }
+
     private abstract static class AbstractResolvable<T> {
 
         protected boolean isResolvable(final String value) {
@@ -253,12 +284,12 @@ protected String resolveVars(final String value, final Map<String, String> vars)
     private static class Params extends AbstractResolvable<List<String>> {
 
         private final List<String> list;
-        private final Map<String, String> vars;
+        private final RecordTransformer recordTransformer;
         private final boolean resolve;
 
-        private Params(final List<String> list, final Map<String, String> vars) {
+        private Params(final List<String> list, final RecordTransformer recordTransformer) {
             this.list = list;
-            this.vars = vars;
+            this.recordTransformer = recordTransformer;
 
             resolve = list.stream().anyMatch(this::isResolvable);
         }
@@ -267,6 +298,7 @@ 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> vars = recordTransformer.getVars();
 
                 for (final String entry : list) {
                     resolvedList.add(resolveVars(entry, vars));
@@ -284,11 +316,11 @@ 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 RecordTransformer recordTransformer;
         private final boolean resolve;
 
-        private Options(final org.metafacture.metafix.fix.Options options, final Map<String, String> vars) {
-            this.vars = vars;
+        private Options(final org.metafacture.metafix.fix.Options options, final RecordTransformer recordTransformer) {
+            this.recordTransformer = recordTransformer;
 
             boolean resolveTemp = false;
 
@@ -315,6 +347,7 @@ 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> vars = recordTransformer.getVars();
 
                 for (final Map.Entry<String, String> entry : map.entrySet()) {
                     resolvedMap.put(resolveVars(entry.getKey(), vars), resolveVars(entry.getValue(), vars));