diff --git a/build.gradle b/build.gradle
index 315a47ec..8600dd0a 100644
--- a/build.gradle
+++ b/build.gradle
@@ -52,12 +52,12 @@ subprojects {
   targetCompatibility = '1.8'
 
   repositories {
-    jcenter()
+    mavenCentral()
     maven githubPackage.invoke("metafacture")
   }
 
   dependencies {
-    compile platform("org.eclipse.xtext:xtext-dev-bom:${versions.xtext}")
+    implementation platform("org.eclipse.xtext:xtext-dev-bom:${versions.xtext}")
   }
 
   configurations.all {
diff --git a/config/checkstyle/checkstyle.xml b/config/checkstyle/checkstyle.xml
index 5b5bb2c9..7d7b827f 100644
--- a/config/checkstyle/checkstyle.xml
+++ b/config/checkstyle/checkstyle.xml
@@ -29,6 +29,7 @@
         <module name="CustomImportOrder">
             <property name="customImportOrderRules" value="SAME_PACKAGE(2)###THIRD_PARTY_PACKAGE###STANDARD_JAVA_PACKAGE###SPECIAL_IMPORTS###STATIC"/>
             <property name="separateLineBetweenGroups" value="true"/>
+            <property name="sortImportsInGroupAlphabetically" value="true"/>
         </module>
         <module name="CyclomaticComplexity"/>
         <module name="DeclarationOrder"/>
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 44e7c4d1..a2e01c0d 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-5.2.1-bin.zip
+distributionSha256Sum=f581709a9c35e9cb92e16f585d2c4bc99b2b1a5f85d2badbd3dc6bff59e1e6dd
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.2-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/org.metafacture.fix.ide/build.gradle b/org.metafacture.fix.ide/build.gradle
index b438ace3..c4faa28d 100644
--- a/org.metafacture.fix.ide/build.gradle
+++ b/org.metafacture.fix.ide/build.gradle
@@ -3,10 +3,10 @@ plugins {
 }
 
 dependencies {
-  compile project(':metafacture-fix')
+  implementation project(':metafix')
 
-  compile "org.eclipse.xtext:org.eclipse.xtext.ide:${versions.xtext}"
-  compile "org.eclipse.xtext:org.eclipse.xtext.xbase.ide:${versions.xtext}"
+  implementation "org.eclipse.xtext:org.eclipse.xtext.ide:${versions.xtext}"
+  implementation "org.eclipse.xtext:org.eclipse.xtext.xbase.ide:${versions.xtext}"
 }
 
 apply plugin: 'application'
@@ -17,7 +17,7 @@ applicationName = 'xtext-server'
 
 shadowJar {
   from(project.convention.getPlugin(JavaPluginConvention).sourceSets.main.output)
-  configurations = [project.configurations.runtime]
+  configurations = [project.configurations.runtimeClasspath]
 
   exclude(
     '*.html',
diff --git a/org.metafacture.fix.ide/src/main/java/org/metafacture/fix/ide/FixIdeModule.java b/org.metafacture.fix.ide/src/main/java/org/metafacture/metafix/ide/FixIdeModule.java
similarity index 80%
rename from org.metafacture.fix.ide/src/main/java/org/metafacture/fix/ide/FixIdeModule.java
rename to org.metafacture.fix.ide/src/main/java/org/metafacture/metafix/ide/FixIdeModule.java
index 226c18c4..4b9f4785 100644
--- a/org.metafacture.fix.ide/src/main/java/org/metafacture/fix/ide/FixIdeModule.java
+++ b/org.metafacture.fix.ide/src/main/java/org/metafacture/metafix/ide/FixIdeModule.java
@@ -1,11 +1,9 @@
-package org.metafacture.fix.ide;
+package org.metafacture.metafix.ide;
 
 /**
  * Use this class to register ide components.
  */
 public class FixIdeModule extends AbstractFixIdeModule {
-
     public FixIdeModule() {
     }
-
 }
diff --git a/org.metafacture.fix.ide/src/main/java/org/metafacture/fix/ide/FixIdeSetup.java b/org.metafacture.fix.ide/src/main/java/org/metafacture/metafix/ide/FixIdeSetup.java
similarity index 76%
rename from org.metafacture.fix.ide/src/main/java/org/metafacture/fix/ide/FixIdeSetup.java
rename to org.metafacture.fix.ide/src/main/java/org/metafacture/metafix/ide/FixIdeSetup.java
index 2d446884..2dd6f9fc 100644
--- a/org.metafacture.fix.ide/src/main/java/org/metafacture/fix/ide/FixIdeSetup.java
+++ b/org.metafacture.fix.ide/src/main/java/org/metafacture/metafix/ide/FixIdeSetup.java
@@ -1,7 +1,7 @@
-package org.metafacture.fix.ide;
+package org.metafacture.metafix.ide;
 
-import org.metafacture.fix.FixRuntimeModule;
-import org.metafacture.fix.FixStandaloneSetup;
+import org.metafacture.metafix.FixRuntimeModule;
+import org.metafacture.metafix.FixStandaloneSetup;
 
 import com.google.inject.Guice;
 import com.google.inject.Injector;
diff --git a/org.metafacture.fix.ide/src/main/java/org/metafacture/fix/ide/contentassist/antlr/FixTokenSource.java b/org.metafacture.fix.ide/src/main/java/org/metafacture/metafix/ide/contentassist/antlr/FixTokenSource.java
similarity index 84%
rename from org.metafacture.fix.ide/src/main/java/org/metafacture/fix/ide/contentassist/antlr/FixTokenSource.java
rename to org.metafacture.fix.ide/src/main/java/org/metafacture/metafix/ide/contentassist/antlr/FixTokenSource.java
index 579e345f..138a7f9d 100644
--- a/org.metafacture.fix.ide/src/main/java/org/metafacture/fix/ide/contentassist/antlr/FixTokenSource.java
+++ b/org.metafacture.fix.ide/src/main/java/org/metafacture/metafix/ide/contentassist/antlr/FixTokenSource.java
@@ -1,6 +1,6 @@
-package org.metafacture.fix.ide.contentassist.antlr;
+package org.metafacture.metafix.ide.contentassist.antlr;
 
-import org.metafacture.fix.ide.contentassist.antlr.internal.InternalFixParser;
+import org.metafacture.metafix.ide.contentassist.antlr.internal.InternalFixParser;
 
 import org.antlr.runtime.Token;
 import org.antlr.runtime.TokenSource;
@@ -31,5 +31,4 @@ protected int getEndTokenType() {
     protected boolean shouldEmitPendingEndTokens() {
         return false;
     }
-
 }
diff --git a/org.metafacture.fix.web/build.gradle b/org.metafacture.fix.web/build.gradle
index 72a1cbfa..61e79562 100644
--- a/org.metafacture.fix.web/build.gradle
+++ b/org.metafacture.fix.web/build.gradle
@@ -3,15 +3,15 @@ plugins {
 }
 
 dependencies {
-  compile project(':metafacture-fix')
-  compile project(':org.metafacture.fix.ide')
+  implementation project(':metafix')
+  implementation project(':org.metafacture.fix.ide')
 
-  compile "org.eclipse.xtend:org.eclipse.xtend.lib:${versions.xtext}"
-  compile "org.eclipse.xtext:org.eclipse.xtext.web.servlet:${versions.xtext}"
-  compile "org.eclipse.xtext:org.eclipse.xtext.xbase.web:${versions.xtext}"
-  compile "org.webjars:ace:${versions.ace}"
-  compile "org.webjars:jquery:${versions.jquery}"
-  compile "org.webjars:requirejs:${versions.requirejs}"
+  implementation "org.eclipse.xtend:org.eclipse.xtend.lib:${versions.xtext}"
+  implementation "org.eclipse.xtext:org.eclipse.xtext.web.servlet:${versions.xtext}"
+  implementation "org.eclipse.xtext:org.eclipse.xtext.xbase.web:${versions.xtext}"
+  implementation "org.webjars:ace:${versions.ace}"
+  implementation "org.webjars:jquery:${versions.jquery}"
+  implementation "org.webjars:requirejs:${versions.requirejs}"
 
   providedCompile "org.eclipse.jetty:jetty-annotations:${versions.jetty}"
   providedCompile "org.slf4j:slf4j-simple:${versions.slf4j}"
@@ -27,7 +27,7 @@ dependencies {
 task jettyRun(type: JavaExec) {
   dependsOn(sourceSets.main.runtimeClasspath)
   classpath = sourceSets.main.runtimeClasspath.filter { it.exists() }
-  main = 'org.metafacture.fix.web.ServerLauncher'
+  mainClass = 'org.metafacture.metafix.web.ServerLauncher'
   standardInput = System.in
   group = 'run'
   description = 'Starts an example Jetty server with your language'
diff --git a/org.metafacture.fix.web/src/main/java/org/metafacture/fix/web/FixServlet.java b/org.metafacture.fix.web/src/main/java/org/metafacture/metafix/web/FixServlet.java
similarity index 93%
rename from org.metafacture.fix.web/src/main/java/org/metafacture/fix/web/FixServlet.java
rename to org.metafacture.fix.web/src/main/java/org/metafacture/metafix/web/FixServlet.java
index 2b675426..16866e70 100644
--- a/org.metafacture.fix.web/src/main/java/org/metafacture/fix/web/FixServlet.java
+++ b/org.metafacture.fix.web/src/main/java/org/metafacture/metafix/web/FixServlet.java
@@ -1,6 +1,6 @@
-package org.metafacture.fix.web;
+package org.metafacture.metafix.web;
 
-import org.metafacture.metamorph.Metafix;
+import org.metafacture.metafix.FixStandaloneSetup;
 import org.metafacture.runner.Flux;
 
 import org.antlr.runtime.RecognitionException;
@@ -86,7 +86,7 @@ private boolean process(final HttpServletRequest request, final HttpServletRespo
 
         builder.append(request.getParameter(PARAM_FLUX).replaceAll("\\s?\\|\\s?", "|").replace(
                 "|" + COMMAND_FIX + "|",
-                "|org.metafacture.metamorph.Metafix(fixFile=\"" + fixFile + "\")|"));
+                "|org.metafacture.metafix.Metafix(\"" + fixFile + "\")|"));
         builder.append("|write(\"");
         builder.append(outFile);
         builder.append("\");");
@@ -106,7 +106,7 @@ private boolean process(final HttpServletRequest request, final HttpServletRespo
     }
 
     private String absPathToTempFile(final String content, final String suffix) throws IOException {
-        return Metafix.absPathToTempFile(new StringReader(content), suffix);
+        return FixStandaloneSetup.absPathToTempFile(new StringReader(content), suffix);
     }
 
 }
diff --git a/org.metafacture.fix.web/src/main/java/org/metafacture/fix/web/FixWebModule.java b/org.metafacture.fix.web/src/main/java/org/metafacture/metafix/web/FixWebModule.java
similarity index 71%
rename from org.metafacture.fix.web/src/main/java/org/metafacture/fix/web/FixWebModule.java
rename to org.metafacture.fix.web/src/main/java/org/metafacture/metafix/web/FixWebModule.java
index 3825a191..ad61024e 100644
--- a/org.metafacture.fix.web/src/main/java/org/metafacture/fix/web/FixWebModule.java
+++ b/org.metafacture.fix.web/src/main/java/org/metafacture/metafix/web/FixWebModule.java
@@ -1,11 +1,10 @@
-package org.metafacture.fix.web;
+package org.metafacture.metafix.web;
 
 /**
- * Use this class to register additional components to be used within the web application.
+ * Use this class to register additional components to be used within the web
+ * application.
  */
 public class FixWebModule extends AbstractFixWebModule {
-
     public FixWebModule() {
     }
-
 }
diff --git a/org.metafacture.fix.web/src/main/java/org/metafacture/fix/web/FixWebSetup.java b/org.metafacture.fix.web/src/main/java/org/metafacture/metafix/web/FixWebSetup.java
similarity index 71%
rename from org.metafacture.fix.web/src/main/java/org/metafacture/fix/web/FixWebSetup.java
rename to org.metafacture.fix.web/src/main/java/org/metafacture/metafix/web/FixWebSetup.java
index 74cee0ee..ad7c397a 100644
--- a/org.metafacture.fix.web/src/main/java/org/metafacture/fix/web/FixWebSetup.java
+++ b/org.metafacture.fix.web/src/main/java/org/metafacture/metafix/web/FixWebSetup.java
@@ -1,8 +1,8 @@
-package org.metafacture.fix.web;
+package org.metafacture.metafix.web;
 
-import org.metafacture.fix.FixRuntimeModule;
-import org.metafacture.fix.FixStandaloneSetup;
-import org.metafacture.fix.ide.FixIdeModule;
+import org.metafacture.metafix.FixRuntimeModule;
+import org.metafacture.metafix.FixStandaloneSetup;
+import org.metafacture.metafix.ide.FixIdeModule;
 
 import com.google.inject.Guice;
 import com.google.inject.Injector;
diff --git a/org.metafacture.fix.web/src/main/java/org/metafacture/fix/web/ServerLauncher.java b/org.metafacture.fix.web/src/main/java/org/metafacture/metafix/web/ServerLauncher.java
similarity index 90%
rename from org.metafacture.fix.web/src/main/java/org/metafacture/fix/web/ServerLauncher.java
rename to org.metafacture.fix.web/src/main/java/org/metafacture/metafix/web/ServerLauncher.java
index 1526dafe..93893f7c 100644
--- a/org.metafacture.fix.web/src/main/java/org/metafacture/fix/web/ServerLauncher.java
+++ b/org.metafacture.fix.web/src/main/java/org/metafacture/metafix/web/ServerLauncher.java
@@ -1,4 +1,4 @@
-package org.metafacture.fix.web;
+package org.metafacture.metafix.web;
 
 import org.eclipse.jetty.annotations.AnnotationConfiguration;
 import org.eclipse.jetty.server.Server;
@@ -16,7 +16,8 @@
  * This program starts an HTTP server for testing the web integration of your DSL.
  * Just execute it and point a web browser to http://localhost:8080/
  */
-public class ServerLauncher { // checkstyle-disable-line ClassDataAbstractionCoupling
+@SuppressWarnings({"checkstyle:ClassDataAbstractionCoupling", "checkstyle:IllegalCatch"})
+public class ServerLauncher {
 
     private ServerLauncher() {
         throw new IllegalAccessError("Utility class");
@@ -52,14 +53,14 @@ public static void main(final String[] args) {
                         log.warn("Console input is not available. In order to stop the server, you need to cancel the process manually.");
                     }
                 }
-                catch (final Exception e) { // checkstyle-disable-line IllegalCatch
+                catch (final Exception e) {
                     throw Exceptions.sneakyThrow(e);
                 }
             }).start();
 
             server.join();
         }
-        catch (final Throwable e) { // checkstyle-disable-line IllegalCatch
+        catch (final Throwable e) {
             if (e instanceof Exception) {
                 log.warn(((Exception) e).getMessage());
                 System.exit(1);
diff --git a/org.metafacture.fix.web/src/main/webapp/index.html b/org.metafacture.fix.web/src/main/webapp/index.html
index 55f347f2..88eea196 100644
--- a/org.metafacture.fix.web/src/main/webapp/index.html
+++ b/org.metafacture.fix.web/src/main/webapp/index.html
@@ -34,7 +34,7 @@
     <script>
         function loadContent() {
             var editor = ace.edit("xtext-editor");
-            editor.setValue('map(_id, id)\nmap(a,title)\nmap(b.n,author)\n/*map(_else)*/\n');
+            editor.setValue('move_field(_id, id)\nmove_field(a,title)\nmove_field(b.n,author)\nretain(id,title,author)\n');
             document.getElementById("data").value = "1{a: Faust, b {n: Goethe, v: JW}, c: Weimar}\n 2{a: Räuber, b {n: Schiller, v: F}, c: Weimar}";
             document.getElementById("flux").value = "as-lines|decode-formeta|fix|stream-to-xml(rootTag=\"collection\")";
             return true;
diff --git a/org.metafacture.fix/.launch/Generate Fix (fix) Language Infrastructure.launch b/org.metafacture.fix/.launch/Generate Fix (fix) Language Infrastructure.launch
index 6b079c3c..ef1daee7 100644
--- a/org.metafacture.fix/.launch/Generate Fix (fix) Language Infrastructure.launch	
+++ b/org.metafacture.fix/.launch/Generate Fix (fix) Language Infrastructure.launch	
@@ -8,7 +8,7 @@
 <listAttribute key="tasks">
 <listEntry value="build"/>
 </listAttribute>
-<stringAttribute key="org.eclipse.debug.core.ATTR_REFRESH_SCOPE" value="${working_set:&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;&#10;&lt;resources&gt;&#10;&lt;item path=&quot;/org.metafacture.fix&quot; type=&quot;4&quot;/&gt;&#10;&lt;item path=&quot;/org.metafacture.fix.ide&quot; type=&quot;4&quot;/&gt;&#10;&lt;item path=&quot;/org.metafacture.fix.web&quot; type=&quot;4&quot;/&gt;&#10;&lt;item path=&quot;/org.metafacture.fix.tests&quot; type=&quot;4&quot;/&gt;&#10;;&lt;/resources&gt;}"/>
+<stringAttribute key="org.eclipse.debug.core.ATTR_REFRESH_SCOPE" value="${working_set:&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;&#10;&lt;resources&gt;&#10;&lt;item path=&quot;/org.metafacture.metafix&quot; type=&quot;4&quot;/&gt;&#10;&lt;item path=&quot;/org.metafacture.metafix.ide&quot; type=&quot;4&quot;/&gt;&#10;&lt;item path=&quot;/org.metafacture.metafix.web&quot; type=&quot;4&quot;/&gt;&#10;&lt;item path=&quot;/org.metafacture.metafix.tests&quot; type=&quot;4&quot;/&gt;&#10;;&lt;/resources&gt;}"/>
 <booleanAttribute key="org.eclipse.jdt.launching.ATTR_USE_START_ON_FIRST_THREAD" value="true"/>
-<stringAttribute key="org.eclipse.jdt.launching.WORKING_DIRECTORY" value="${workspace_loc:/org.metafacture.fix}"/>
+<stringAttribute key="org.eclipse.jdt.launching.WORKING_DIRECTORY" value="${workspace_loc:/org.metafacture.metafix}"/>
 </launchConfiguration>
diff --git a/org.metafacture.fix/build.gradle b/org.metafacture.fix/build.gradle
index ea49e63d..8fd11152 100644
--- a/org.metafacture.fix/build.gradle
+++ b/org.metafacture.fix/build.gradle
@@ -1,19 +1,22 @@
 plugins {
   id 'com.adarshr.test-logger' version '1.7.0'
-  id 'maven'
+  id 'maven-publish'
 }
 
 dependencies {
-  compile "org.eclipse.xtext:org.eclipse.xtext:${versions.xtext}"
-  compile "org.eclipse.xtext:org.eclipse.xtext.xbase:${versions.xtext}"
-  compile "com.google.guava:guava:${versions.guava}"
+  implementation "org.eclipse.xtext:org.eclipse.xtext:${versions.xtext}"
+  implementation "org.eclipse.xtext:org.eclipse.xtext.xbase:${versions.xtext}"
+  implementation "com.google.guava:guava:${versions.guava}"
+  implementation "org.slf4j:slf4j-api:${versions.slf4j}"
 
-  testCompile "org.junit.jupiter:junit-jupiter-api:${versions.junit_jupiter}"
-  testCompile "org.junit.platform:junit-platform-launcher:${versions.junit_platform}"
-  testCompile "org.eclipse.xtext:org.eclipse.xtext.testing:${versions.xtext}"
-  testCompile "org.eclipse.xtext:org.eclipse.xtext.xbase.testing:${versions.xtext}"
+  testImplementation "org.junit.jupiter:junit-jupiter-api:${versions.junit_jupiter}"
+  testImplementation "org.junit.platform:junit-platform-launcher:${versions.junit_platform}"
+  testImplementation "org.eclipse.xtext:org.eclipse.xtext.testing:${versions.xtext}"
+  testImplementation "org.eclipse.xtext:org.eclipse.xtext.xbase.testing:${versions.xtext}"
 
-  testRuntime "org.junit.jupiter:junit-jupiter-engine:${versions.junit_jupiter}"
+  testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:${versions.junit_jupiter}"
+
+  runtimeOnly "org.slf4j:slf4j-simple:${versions.slf4j}"
 
   implementation "org.metafacture:metafacture-commons:${versions.metafacture}"
   implementation "org.metafacture:metafacture-mangling:${versions.metafacture}"
@@ -27,7 +30,7 @@ dependencies {
 
 configurations {
   mwe2 {
-    extendsFrom compile
+    extendsFrom implementation
   }
 }
 
@@ -42,25 +45,36 @@ test {
   useJUnitPlatform()
 }
 
-def xtextFile = 'src/main/java/org/metafacture/fix/Fix.xtext'
+task install(dependsOn: publishToMavenLocal,
+    description: "Installs the 'archives' artifacts into the local Maven repository. [deprecated]") {
+  doFirst { println "This task is deprecated; use 'publishToMavenLocal' instead." }
+}
+
+task validateFixFile(type: JavaExec) {
+  mainClass = 'org.metafacture.metafix.FixStandaloneSetup'
+  classpath = sourceSets.main.runtimeClasspath
+}
+
+def xtextFile = 'src/main/java/org/metafacture/metafix/Fix.xtext'
 
 task validateXtextLanguage(type: JavaExec) {
-  main = 'org.metafacture.fix.validation.XtextValidator'
+  mainClass = 'org.metafacture.metafix.validation.XtextValidator'
   classpath = sourceSets.main.runtimeClasspath
   args += xtextFile
 }
 
 task generateXtextLanguage(type: JavaExec) {
-  main = 'org.eclipse.emf.mwe2.launch.runtime.Mwe2Launcher'
+  mainClass = 'org.eclipse.emf.mwe2.launch.runtime.Mwe2Launcher'
   classpath = configurations.mwe2
-  inputs.file 'src/main/java/org/metafacture/fix/GenerateFix.mwe2'
+  inputs.file 'src/main/java/org/metafacture/metafix/GenerateFix.mwe2'
   inputs.file xtextFile
   outputs.dir 'src/main/xtext-gen'
-  args += 'src/main/java/org/metafacture/fix/GenerateFix.mwe2'
+  args += 'src/main/java/org/metafacture/metafix/GenerateFix.mwe2'
   args += '-p'
   args += "rootPath=/${projectDir}/.."
 }
 
+processResources.dependsOn(generateXtextLanguage)
 generateXtext.dependsOn(generateXtextLanguage)
 compileJava.dependsOn(generateXtextLanguage)
 clean.dependsOn(cleanGenerateXtextLanguage)
diff --git a/org.metafacture.fix/src/main/java/org/metafacture/fix/FixStandaloneSetup.java b/org.metafacture.fix/src/main/java/org/metafacture/fix/FixStandaloneSetup.java
deleted file mode 100644
index b4f86a0c..00000000
--- a/org.metafacture.fix/src/main/java/org/metafacture/fix/FixStandaloneSetup.java
+++ /dev/null
@@ -1,15 +0,0 @@
-package org.metafacture.fix;
-
-/**
- * Initialization support for running Xtext languages without Equinox extension registry.
- */
-public class FixStandaloneSetup extends FixStandaloneSetupGenerated {
-
-    public FixStandaloneSetup() {
-    }
-
-    public static void doSetup() {
-        new FixStandaloneSetup().createInjectorAndDoEMFRegistration();
-    }
-
-}
diff --git a/org.metafacture.fix/src/main/java/org/metafacture/fix/validation/XtextValidator.java b/org.metafacture.fix/src/main/java/org/metafacture/fix/validation/XtextValidator.java
deleted file mode 100644
index 793f2824..00000000
--- a/org.metafacture.fix/src/main/java/org/metafacture/fix/validation/XtextValidator.java
+++ /dev/null
@@ -1,55 +0,0 @@
-package org.metafacture.fix.validation;
-
-import com.google.inject.Injector;
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.emf.ecore.resource.ResourceSet;
-import org.eclipse.xtext.XtextStandaloneSetup;
-import org.eclipse.xtext.util.CancelIndicator;
-import org.eclipse.xtext.validation.CheckMode;
-import org.eclipse.xtext.validation.IResourceValidator;
-import org.eclipse.xtext.validation.Issue;
-
-import java.io.IOException;
-import java.util.List;
-
-public class XtextValidator {
-
-    private XtextValidator() {
-        throw new IllegalAccessError("Utility class");
-    }
-
-    public static boolean validate(final URI uri) throws IOException {
-        final Injector injector = new XtextStandaloneSetup().createInjectorAndDoEMFRegistration();
-        final Resource resource = injector.getInstance(ResourceSet.class).getResource(uri, true);
-        resource.load(null);
-
-        final List<Issue> issues = injector.getInstance(IResourceValidator.class)
-            .validate(resource, CheckMode.ALL, CancelIndicator.NullImpl);
-        final int count = issues.size();
-
-        if (count > 0) {
-            System.out.println(String.format("The Xtext file '%s' has %d issue%s:\n",
-                        resource.getURI(), count, count > 1 ? "s" : ""));
-
-            for (final Issue issue : issues) {
-                System.out.println(String.format("- %s: %s (%d:%d)",
-                            issue.getSeverity(), issue.getMessage(), issue.getLineNumber(), issue.getColumn()));
-            }
-
-            return false;
-        }
-
-        return true;
-    }
-
-    public static void main(final String[] args) throws IOException {
-        if (args == null || args.length != 1) {
-            throw new IllegalArgumentException(String.format("Usage: %s <xtext-file>",
-                        XtextValidator.class.getName()));
-        }
-
-        System.exit(validate(URI.createURI(args[0])) ? 0 : 1);
-    }
-
-}
diff --git a/org.metafacture.fix/src/main/java/org/metafacture/fix/Fix.xtext b/org.metafacture.fix/src/main/java/org/metafacture/metafix/Fix.xtext
similarity index 83%
rename from org.metafacture.fix/src/main/java/org/metafacture/fix/Fix.xtext
rename to org.metafacture.fix/src/main/java/org/metafacture/metafix/Fix.xtext
index 0da72b5d..91c7ccc4 100644
--- a/org.metafacture.fix/src/main/java/org/metafacture/fix/Fix.xtext
+++ b/org.metafacture.fix/src/main/java/org/metafacture/metafix/Fix.xtext
@@ -1,7 +1,7 @@
-grammar org.metafacture.fix.Fix
+grammar org.metafacture.metafix.Fix
   with org.eclipse.xtext.xbase.Xbase
 
-generate fix "http://www.metafacture.org/fix/Fix"
+generate fix "http://www.metafacture.org/metafix/Fix"
 
 Fix:
   elements += Expression*
@@ -9,11 +9,19 @@ Fix:
 
 Expression:
   Do |
+  Unless |
   If |
   MethodCall |
   {Expression} SL_COMMENT
 ;
 
+Unless:
+  'unless' name = ValidID '(' ( params += (QualifiedName|STRING) ( ',' params += (QualifiedName|STRING) )* )? ')' BEGIN
+    elements += Expression*
+  END
+  'end'
+;
+
 If:
   'if' name = ValidID '(' ( params += (QualifiedName|STRING) ( ',' params += (QualifiedName|STRING) )* )? ')' BEGIN
     elements += Expression*
diff --git a/org.metafacture.fix/src/main/java/org/metafacture/metafix/FixMethod.java b/org.metafacture.fix/src/main/java/org/metafacture/metafix/FixMethod.java
new file mode 100644
index 00000000..6b8f1ff4
--- /dev/null
+++ b/org.metafacture.fix/src/main/java/org/metafacture/metafix/FixMethod.java
@@ -0,0 +1,432 @@
+/*
+ * Copyright 2021 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.metafix;
+
+import org.metafacture.metamorph.maps.FileMap;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+enum FixMethod {
+
+    // RECORD-LEVEL METHODS:
+
+    set_field {
+        public void apply(final Map<String, Object> record, final List<String> params,
+                final Map<String, String> options) {
+            record.remove(params.get(0));
+            insert(InsertMode.REPLACE, record, split(params.get(0)), params.get(1));
+        }
+    },
+    set_array {
+        public void apply(final Map<String, Object> record, final List<String> params,
+                final Map<String, String> options) {
+            final String key = params.get(0);
+            final List<String> toAdd = params.subList(1, params.size());
+            if (key.endsWith(DOT_APPEND)) {
+                Metafix.addAll(record, key.replace(DOT_APPEND, EMPTY), toAdd);
+            }
+            else {
+                record.put(key, toAdd);
+            }
+        }
+    },
+    set_hash {
+        @SuppressWarnings("unchecked")
+        public void apply(final Map<String, Object> record, final List<String> params,
+                final Map<String, String> options) {
+            final String key = params.get(0);
+            final Object val = record.get(key.replace(DOT_APPEND, EMPTY));
+            if (key.endsWith(DOT_APPEND) && val instanceof List) {
+                ((List<Object>) val).add(options);
+            }
+            else {
+                record.put(key, options);
+            }
+        }
+    },
+    array { // array-from-hash
+        public void apply(final Map<String, Object> record, final List<String> params,
+                final Map<String, String> options) {
+            final String fieldName = params.get(0);
+            Metafix.asList(record.get(fieldName)).forEach(recordEntry -> {
+                if (recordEntry instanceof Map) {
+                    record.remove(fieldName);
+                    ((Map<?, ?>) recordEntry).entrySet().forEach(mapEntry -> {
+                        Metafix.add(record, fieldName, mapEntry.getKey());
+                        Metafix.add(record, fieldName, mapEntry.getValue());
+                    });
+                }
+            });
+        }
+    },
+    hash { // hash-from-array
+        public void apply(final Map<String, Object> record, final List<String> params,
+                final Map<String, String> options) {
+            final List<Object> values = Metafix.asList(record.get(params.get(0)));
+            final Map<String, Object> result = new HashMap<>();
+            for (int i = 0; i < values.size(); i = i + 1) {
+                if (i % 2 == 1) {
+                    result.put(values.get(i - 1).toString(), values.get(i));
+                }
+            }
+            record.put(params.get(0), result);
+        }
+    },
+    add_field {
+        public void apply(final Map<String, Object> record, final List<String> params,
+                final Map<String, String> options) {
+            insert(InsertMode.APPEND, record, split(params.get(0)), params.get(1));
+        }
+    },
+    move_field {
+        public void apply(final Map<String, Object> record, final List<String> params,
+                final Map<String, String> options) {
+            copy(record, params);
+            remove(record, split(params.get(0)));
+        }
+    },
+    copy_field {
+        public void apply(final Map<String, Object> record, final List<String> params,
+                final Map<String, String> options) {
+            copy(record, params);
+        }
+    },
+    remove_field {
+        public void apply(final Map<String, Object> record, final List<String> params,
+                final Map<String, String> options) {
+            params.forEach(p -> {
+                remove(record, split(p));
+            });
+        }
+    },
+    format {
+        public void apply(final Map<String, Object> record, final List<String> params,
+                final Map<String, String> options) {
+            final Collection<Object> oldVals = Metafix.asList(record.get(params.get(0)));
+            final String newVal = String.format(params.get(1), oldVals.toArray(new Object[] {}));
+            record.replace(params.get(0), Arrays.asList(newVal));
+        }
+    },
+    parse_text {
+        public void apply(final Map<String, Object> record, final List<String> params,
+                final Map<String, String> options) {
+            Metafix.asList(record.get(params.get(0))).forEach(v -> {
+                final Pattern p = Pattern.compile(params.get(1));
+                final Matcher m = p.matcher(v.toString());
+                if (m.matches()) {
+                    record.remove(params.get(0));
+
+                    /**
+                     * {@code Pattern.namedGroups()} not available as API,
+                     * see https://stackoverflow.com/a/65012527.
+                     *
+                     * Assumptions: 1. Named groups are not escaped/quoted;
+                     * 2. Named groups are not mixed with unnamed groups.
+                     */
+                    final Matcher groupMatcher = NAMED_GROUP_PATTERN.matcher(p.pattern());
+                    final Map<String, String> result = new LinkedHashMap<>();
+
+                    while (groupMatcher.find()) {
+                        final String group = groupMatcher.group(1);
+                        result.put(group, m.group(group));
+                    }
+
+                    if (!result.isEmpty()) {
+                        Metafix.add(record, params.get(0), result);
+                    }
+                    else {
+                        for (int i = 1; i <= m.groupCount(); i = i + 1) {
+                            Metafix.add(record, params.get(0), m.group(i));
+                        }
+                    }
+                }
+            });
+        }
+    },
+    paste {
+        public void apply(final Map<String, Object> record, final List<String> params,
+                final Map<String, String> options) {
+            final String joinChar = options.get("join_char");
+            insert(InsertMode.REPLACE, record, split(params.get(0)),
+                    params.subList(1, params.size()).stream()
+                            .filter(k -> literalString(k) || find(record, split(k)) != null)
+                            .map(k -> literalString(k) ? k.substring(1) : Metafix.asList(find(record, split(k))).iterator().next())
+                            .map(Object::toString).collect(Collectors.joining(joinChar != null ? joinChar : " ")));
+        }
+
+        private boolean literalString(final String s) {
+            return s.startsWith("~");
+        }
+    },
+    reject {
+        public void apply(final Map<String, Object> record, final List<String> params,
+                final Map<String, String> options) {
+            record.put("__reject", null);
+        }
+    },
+    retain {
+        public void apply(final Map<String, Object> record, final List<String> params,
+                final Map<String, String> options) {
+            record.keySet().retainAll(params);
+        }
+    },
+    vacuum {
+        public void apply(final Map<String, Object> record, final List<String> params,
+                final Map<String, String> options) {
+            record.values().removeIf(EMPTY::equals);
+        }
+    },
+    // FIELD-LEVEL METHODS:
+
+    substring {
+        @SuppressWarnings("checkstyle:MagicNumber") // TODO: switch to morph-style named params in general?
+        public void apply(final Map<String, Object> record, final List<String> params,
+                final Map<String, String> options) {
+            applyToFields(record, params,
+                s -> s.substring(Integer.parseInt(params.get(1)), Integer.parseInt(params.get(2)) - 1));
+        }
+    },
+    trim {
+        public void apply(final Map<String, Object> record, final List<String> params,
+                final Map<String, String> options) {
+            applyToFields(record, params, s -> s.trim());
+        }
+    },
+    upcase {
+        public void apply(final Map<String, Object> record, final List<String> params,
+                final Map<String, String> options) {
+            applyToFields(record, params, s -> s.toUpperCase());
+        }
+    },
+    downcase {
+        public void apply(final Map<String, Object> record, final List<String> params,
+                final Map<String, String> options) {
+            applyToFields(record, params, s -> s.toLowerCase());
+        }
+    },
+    capitalize {
+        public void apply(final Map<String, Object> record, final List<String> params,
+                final Map<String, String> options) {
+            applyToFields(record, params, s -> s.substring(0, 1).toUpperCase() + s.substring(1));
+        }
+    },
+    lookup {
+        public void apply(final Map<String, Object> record, final List<String> params,
+                final Map<String, String> options) {
+            applyToFields(record, params, s -> {
+                final Map<String, String> map = buildMap(options, params.size() <= 1 ? null : params.get(1));
+                return map.getOrDefault(s, map.get("__default")); // TODO Catmandu uses 'default'
+            });
+        }
+
+        private Map<String, String> buildMap(final Map<String, String> options, final String fileLocation) {
+            final String sep = "sep_char";
+            final Map<String, String> map = fileLocation != null ? fileMap(fileLocation, options.get(sep)) : options;
+            return map;
+        }
+
+        private Map<String, String> fileMap(final String location, final String separator) {
+            final FileMap fileMap = new FileMap();
+            fileMap.setSeparator(","); // CSV as default
+            if (separator != null) { // override with option
+                fileMap.setSeparator(separator);
+            }
+            fileMap.setFile(location);
+            return fileMap;
+        }
+    };
+
+    private static final Pattern NAMED_GROUP_PATTERN = Pattern.compile("\\(\\?<(.+?)>");
+
+    private static final String NESTED = "Nested non-map / non-list: ";
+    private static final String EMPTY = "";
+    private static final String APPEND = "$append";
+    private static final String DOT_APPEND = "." + APPEND;
+    private static final String LAST = "$last";
+
+    private static void applyToFields(final Map<String, Object> record, final List<String> params,
+            final Function<String, String> fun) {
+        final String key = params.get(0);
+        final Object found = find(record, split(key));
+        final boolean containsKey = found != null;
+        if (containsKey) {
+            remove(record, split(key));
+            new ArrayList<>(Metafix.asList(found)).forEach(old -> {
+                if (fun != null && old != null) {
+                    final String val = fun.apply(old.toString());
+                    insert(InsertMode.APPEND, record, split(key), val);
+                }
+            });
+        }
+    }
+
+    private static Object insert(final InsertMode mode, final Map<String, Object> map, final String[] keys, final String value) {
+        final String currentKey = keys[0];
+        if (keys.length == 1) {
+            mode.apply(map, currentKey, value);
+            return map;
+        }
+        final String[] remainingKeys = Arrays.copyOfRange(keys, 1, keys.length);
+        final Object nested = insertNested(mode, map, value, currentKey, remainingKeys);
+        map.put(currentKey, nested);
+        return map;
+    }
+
+    @SuppressWarnings("unchecked")
+    private static Object insertNested(final InsertMode mode, final Map<String, Object> map, final String value, final String currentKey,
+            final String[] remainingKeys) {
+        if (!map.containsKey(currentKey)) {
+            map.put(currentKey, new LinkedHashMap<String, Object>());
+        }
+        final Object nested = map.get(currentKey);
+        final Object result;
+        if (nested instanceof Map) {
+            result = insert(mode, (Map<String, Object>) nested, remainingKeys, value);
+        }
+        else if (nested instanceof List) {
+            processList(mode, value, remainingKeys, nested);
+            result = map.get(currentKey);
+        }
+        else {
+            throw new IllegalStateException(NESTED + nested);
+        }
+        return result;
+    }
+
+    @SuppressWarnings("unchecked")
+    private static void processList(final InsertMode mode, final String value, final String[] remainingKeys,
+            final Object nested) {
+        final List<Object> nestedList = (List<Object>) nested;
+        final Map<String, Object> nestedMap;
+        switch (remainingKeys[0]) {
+            case APPEND:
+                nestedMap = new LinkedHashMap<>();
+                nestedList.add(nestedMap);
+                insert(mode, nestedMap, Arrays.copyOfRange(remainingKeys, 1, remainingKeys.length), value);
+                break;
+            case LAST:
+                final Object last = nestedList.get(nestedList.size() - 1);
+                if (last instanceof Map) {
+                    nestedMap = (Map<String, Object>) last;
+                    insert(mode, nestedMap, Arrays.copyOfRange(remainingKeys, 1, remainingKeys.length), value);
+                }
+                break;
+            default:
+                nestedMap = new LinkedHashMap<>();
+                nestedList.add(nestedMap);
+                insert(mode, nestedMap, remainingKeys, value);
+                break;
+        }
+    }
+
+    @SuppressWarnings("checkstyle:ReturnCount")
+    static Object find(final Map<String, Object> map, final String[] keys) {
+        final String currentKey = keys[0];
+        if (!map.containsKey(currentKey)) {
+            return null;
+        }
+        if (keys.length == 1) {
+            return map.get(currentKey);
+        }
+        final String[] remainingKeys = Arrays.copyOfRange(keys, 1, keys.length);
+        return findNested(map, currentKey, remainingKeys);
+    }
+
+    private static Object findNested(final Map<String, Object> map, final String currentKey,
+            final String[] remainingKeys) {
+        final Object nested = map.get(currentKey);
+        // TODO: array of maps, like in insertNested
+        if (nested instanceof List) {
+            return ((List<?>) nested).stream().map(o -> findNested(map, currentKey, remainingKeys))
+                    .collect(Collectors.toList());
+        }
+        if (nested instanceof Map) {
+            @SuppressWarnings("unchecked")
+            final Object result = find((Map<String, Object>) nested, remainingKeys);
+            return result;
+        }
+        throw new IllegalStateException(NESTED + nested);
+    }
+
+    private static Object remove(final Map<String, Object> map, final String[] keys) {
+        final String currentKey = keys[0];
+        if (keys.length == 1) {
+            map.remove(currentKey);
+        }
+        if (!map.containsKey(currentKey)) {
+            return map;
+        }
+        final String[] remainingKeys = Arrays.copyOfRange(keys, 1, keys.length);
+        return removeNested(map, currentKey, remainingKeys);
+    }
+
+    private static Object removeNested(final Map<String, Object> map, final String currentKey,
+            final String[] remainingKeys) {
+        final Object nested = map.get(currentKey);
+        if (!(nested instanceof Map)) {
+            throw new IllegalStateException(NESTED + nested);
+        }
+        @SuppressWarnings("unchecked")
+        final Object result = remove((Map<String, Object>) nested, remainingKeys);
+        return result;
+    }
+
+    private static void copy(final Map<String, Object> record, final List<String> params) {
+        final String oldName = params.get(0);
+        final String newName = params.get(1);
+        final Object value = find(record, split(oldName));
+        if (value != null) {
+            final List<Object> vs = Metafix.asList(value);
+            for (final Object v : vs.stream().filter(v -> v != null).collect(Collectors.toList())) {
+                insert(InsertMode.APPEND, record, split(newName), v.toString());
+            }
+        }
+    }
+
+    static String[] split(final String s) {
+        return s.split("\\.");
+    }
+
+    private enum InsertMode {
+        REPLACE {
+            @Override
+            void apply(final Map<String, Object> map, final String key, final String value) {
+                map.put(key, value);
+            }
+        },
+        APPEND {
+            @Override
+            void apply(final Map<String, Object> map, final String key, final String value) {
+                final Object object = map.get(key);
+                map.put(key, object == null ? value : Metafix.merged(object, value));
+            }
+        };
+        abstract void apply(Map<String, Object> map, String key, String value);
+    }
+
+    abstract void apply(Map<String, Object> record, List<String> params, Map<String, String> options);
+}
diff --git a/org.metafacture.fix/src/main/java/org/metafacture/metafix/FixPredicate.java b/org.metafacture.fix/src/main/java/org/metafacture/metafix/FixPredicate.java
new file mode 100644
index 00000000..6d880836
--- /dev/null
+++ b/org.metafacture.fix/src/main/java/org/metafacture/metafix/FixPredicate.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2021 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.metafix;
+
+import java.util.List;
+import java.util.Map;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+enum FixPredicate {
+
+    contain {
+        public Predicate<Object> of(final Object value) {
+            return v -> v.toString().contains(value.toString());
+        }
+    },
+    equal {
+        public Predicate<Object> of(final Object value) {
+            return v ->  v.toString().equals(value.toString());
+        }
+    },
+    match {
+        public Predicate<Object> of(final Object value) {
+            return v -> v.toString().matches(value.toString());
+        }
+    };
+
+    abstract Predicate<Object> of(Object value);
+
+    enum Quantifier {
+
+        all {
+            @Override
+            public boolean test(final Map<String, Object> record, final FixPredicate p,
+                    final List<String> params) {
+                return test(record, params.get(0), s -> s.allMatch(p.of(params.get(1))));
+            }
+
+        },
+        any {
+            @Override
+            public boolean test(final Map<String, Object> record, final FixPredicate p,
+                    final List<String> params) {
+                return test(record, params.get(0), s -> s.anyMatch(p.of(params.get(1))));
+            }
+        },
+        none {
+            @Override
+            public boolean test(final Map<String, Object> record, final FixPredicate p,
+                    final List<String> params) {
+                final Object fieldValue = FixMethod.find(record, FixMethod.split(params.get(0)));
+                final String valueToTest = params.get(1);
+                return fieldValue == null || Metafix.asList(fieldValue).stream().noneMatch(p.of(valueToTest));
+            }
+        };
+
+        boolean test(final Map<String, Object> record, final String fieldName, final Predicate<Stream<Object>> f) {
+            final Object value = FixMethod.find(record, FixMethod.split(fieldName));
+            return value != null && f.test(Metafix.asList(value).stream());
+        }
+
+        abstract boolean test(Map<String, Object> record, FixPredicate p, List<String> params);
+    }
+}
diff --git a/org.metafacture.fix/src/main/java/org/metafacture/fix/FixRuntimeModule.java b/org.metafacture.fix/src/main/java/org/metafacture/metafix/FixRuntimeModule.java
similarity index 77%
rename from org.metafacture.fix/src/main/java/org/metafacture/fix/FixRuntimeModule.java
rename to org.metafacture.fix/src/main/java/org/metafacture/metafix/FixRuntimeModule.java
index 741d4bd0..59aaca06 100644
--- a/org.metafacture.fix/src/main/java/org/metafacture/fix/FixRuntimeModule.java
+++ b/org.metafacture.fix/src/main/java/org/metafacture/metafix/FixRuntimeModule.java
@@ -1,6 +1,6 @@
-package org.metafacture.fix;
+package org.metafacture.metafix;
 
-import org.metafacture.fix.interpreter.FixInterpreter;
+import org.metafacture.metafix.interpreter.FixInterpreter;
 
 /**
  * Use this class to register components to be used at runtime / without the Equinox extension registry.
diff --git a/org.metafacture.fix/src/main/java/org/metafacture/metafix/FixStandaloneSetup.java b/org.metafacture.fix/src/main/java/org/metafacture/metafix/FixStandaloneSetup.java
new file mode 100644
index 00000000..46df72ce
--- /dev/null
+++ b/org.metafacture.fix/src/main/java/org/metafacture/metafix/FixStandaloneSetup.java
@@ -0,0 +1,55 @@
+package org.metafacture.metafix;
+
+import org.metafacture.framework.MetafactureException;
+import org.metafacture.metafix.fix.Fix;
+import org.metafacture.metafix.validation.XtextValidator;
+
+import com.google.common.io.CharStreams;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.Reader;
+
+/**
+ * Initialization support for running Xtext languages without Equinox extension registry.
+ */
+public class FixStandaloneSetup extends FixStandaloneSetupGenerated {
+
+    public FixStandaloneSetup() {
+    }
+
+    public static void main(final String[] args) {
+        if (args != null && args.length == 1) {
+            System.exit(XtextValidator.validate(args[0], new FixStandaloneSetup()) ? 0 : 1);
+        }
+
+        throw new IllegalArgumentException(String.format("Usage: %s <fix-file>", FixStandaloneSetup.class.getName()));
+    }
+
+    public static Fix parseFix(final Reader fixDef) {
+        final String path;
+
+        try {
+            path = absPathToTempFile(fixDef, ".fix");
+        }
+        catch (final IOException e) {
+            throw new MetafactureException(e);
+        }
+
+        return (Fix) XtextValidator.getValidatedResource(path, new FixStandaloneSetup()).getContents().get(0);
+    }
+
+    public static String absPathToTempFile(final Reader fixDef, final String suffix) throws IOException {
+        // TODO: avoid temp file creation
+        final File file = File.createTempFile("metafix", suffix);
+        file.deleteOnExit();
+
+        try (FileWriter out = new FileWriter(file)) {
+            CharStreams.copy(fixDef, out);
+        }
+
+        return file.getAbsolutePath();
+    }
+
+}
diff --git a/org.metafacture.fix/src/main/java/org/metafacture/fix/GenerateFix.mwe2 b/org.metafacture.fix/src/main/java/org/metafacture/metafix/GenerateFix.mwe2
similarity index 93%
rename from org.metafacture.fix/src/main/java/org/metafacture/fix/GenerateFix.mwe2
rename to org.metafacture.fix/src/main/java/org/metafacture/metafix/GenerateFix.mwe2
index d7fc73be..1658438a 100644
--- a/org.metafacture.fix/src/main/java/org/metafacture/fix/GenerateFix.mwe2
+++ b/org.metafacture.fix/src/main/java/org/metafacture/metafix/GenerateFix.mwe2
@@ -1,4 +1,4 @@
-module org.metafacture.fix.GenerateFix
+module org.metafacture.metafix.GenerateFix
 
 import org.eclipse.xtext.xtext.generator.*
 import org.eclipse.xtext.xtext.generator.model.project.*
@@ -25,7 +25,7 @@ Workflow {
       }
     }
     language = StandardLanguage {
-      name = "org.metafacture.fix.Fix"
+      name = "org.metafacture.metafix.Fix"
       fileExtensions = "fix"
       serializer = {
         generateStub = false
diff --git a/org.metafacture.fix/src/main/java/org/metafacture/metafix/Metafix.java b/org.metafacture.fix/src/main/java/org/metafacture/metafix/Metafix.java
new file mode 100644
index 00000000..af50372c
--- /dev/null
+++ b/org.metafacture.fix/src/main/java/org/metafacture/metafix/Metafix.java
@@ -0,0 +1,292 @@
+/*
+ * Copyright 2013, 2019 Deutsche Nationalbibliothek and others
+ *
+ * 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.
+ */
+
+//TODO: move all classes here to fix package
+
+package org.metafacture.metafix;
+
+import org.metafacture.framework.StandardEventNames;
+import org.metafacture.framework.StreamPipe;
+import org.metafacture.framework.StreamReceiver;
+import org.metafacture.framework.helpers.DefaultStreamReceiver;
+import org.metafacture.mangling.StreamFlattener;
+import org.metafacture.metafix.fix.Expression;
+import org.metafacture.metafix.fix.Fix;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.Reader;
+import java.io.StringReader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Transforms a data stream sent via the {@link StreamReceiver} interface. Use
+ * {@link RecordTransformer} to transform based on a Fix DSL description.
+ *
+ * @author Markus Michael Geipel (Metamorph)
+ * @author Christoph Böhme (Metamorph)
+ * @author Fabian Steeg (Metafix)
+ */
+public class Metafix implements StreamPipe<StreamReceiver> {
+
+    public static final String VAR_START = "$[";
+    public static final String VAR_END = "]";
+    public static final Map<String, String> NO_VARS = Collections.emptyMap();
+    private static final String ENTITIES_NOT_BALANCED = "Entity starts and ends are not balanced";
+
+    private static final Logger LOG = LoggerFactory.getLogger(Metafix.class);
+
+    // TODO: Use SimpleRegexTrie / WildcardTrie for wildcard, alternation and character class support
+    private Map<String, Object> currentRecord = new LinkedHashMap<>();
+    private Fix fix;
+    private final List<Expression> expressions = new ArrayList<>();
+    private Map<String, String> vars = NO_VARS;
+    private final StreamFlattener flattener = new StreamFlattener();
+    private final Deque<Integer> entityCountStack = new LinkedList<>();
+    private int entityCount;
+    private StreamReceiver outputStreamReceiver;
+    private String recordIdentifier;
+    private List<Map<String, Object>> entities = new ArrayList<>();
+
+    public Metafix() {
+        init();
+    }
+
+    public Metafix(final String fixDef) throws FileNotFoundException {
+        this(fixDef, NO_VARS);
+    }
+
+    public Metafix(final String fixDef, final Map<String, String> vars) throws FileNotFoundException {
+        this(fixDef.endsWith(".fix") ? new FileReader(fixDef) : new StringReader(fixDef), vars);
+    }
+
+    public Metafix(final Reader morphDef) {
+        this(morphDef, NO_VARS);
+    }
+
+    public Metafix(final Reader fixDef, final Map<String, String> vars) {
+        buildPipeline(fixDef, vars);
+        init();
+    }
+
+    public List<Expression> getExpressions() {
+        return expressions;
+    }
+
+    private void init() {
+        flattener.setReceiver(new DefaultStreamReceiver() {
+            @Override
+            public void literal(final String name, final String value) {
+                // TODO: keep flattener as option?
+                // add(currentRecord, name, value);
+            }
+        });
+    }
+
+    private void buildPipeline(final Reader fixDef, final Map<String, String> theVars) {
+        final Fix f = FixStandaloneSetup.parseFix(fixDef);
+        this.fix = f;
+        this.vars = theVars;
+    }
+
+    @Override
+    public void startRecord(final String identifier) {
+        currentRecord = new LinkedHashMap<>();
+        LOG.debug("Start record: {}", identifier);
+        flattener.startRecord(identifier);
+        entityCountStack.clear();
+        entityCount = 0;
+        entityCountStack.add(Integer.valueOf(entityCount));
+        recordIdentifier = identifier;
+        entities = new ArrayList<>();
+        literal(StandardEventNames.ID, identifier);
+    }
+
+    @Override
+    public void endRecord() {
+        entityCountStack.removeLast();
+        if (!entityCountStack.isEmpty()) {
+            throw new IllegalStateException(ENTITIES_NOT_BALANCED);
+        }
+        flattener.endRecord();
+        LOG.debug("End record, walking fix: {}", currentRecord);
+        final RecordTransformer transformer = new RecordTransformer(currentRecord, vars, fix);
+        currentRecord = transformer.transform();
+        if (!currentRecord.containsKey("__reject")) {
+            outputStreamReceiver.startRecord(recordIdentifier);
+            LOG.debug("Sending results to {}", outputStreamReceiver);
+            currentRecord.keySet().stream().filter(k -> !k.startsWith("_")).forEach(k -> {
+                emit(k, currentRecord.get(k));
+            });
+            outputStreamReceiver.endRecord();
+        }
+    }
+
+    private void emit(final Object key, final Object val) {
+        if (val == null) {
+            return;
+        }
+        final List<?> vals = asList(val);
+        final boolean isMulti = vals.size() > 1 || val instanceof List;
+        if (isMulti) {
+            outputStreamReceiver.startEntity(key.toString() + "[]");
+        }
+        for (int i = 0; i < vals.size(); ++i) {
+            final Object value = vals.get(i);
+            if (value instanceof Map) {
+                final Map<?, ?> nested = (Map<?, ?>) value;
+                outputStreamReceiver.startEntity(isMulti ? "" : key.toString());
+                nested.entrySet().forEach(nestedEntry -> {
+                    emit(nestedEntry.getKey(), nestedEntry.getValue());
+                });
+                outputStreamReceiver.endEntity();
+            }
+            else {
+                outputStreamReceiver.literal(isMulti ? (i + 1) + "" : key.toString(), value.toString());
+            }
+        }
+        if (isMulti) {
+            outputStreamReceiver.endEntity();
+        }
+    }
+
+    @Override
+    public void startEntity(final String name) {
+        if (name == null) {
+            throw new IllegalArgumentException("Entity name must not be null.");
+        }
+        ++entityCount;
+        final Integer currentEntityIndex = entityCountStack.peek() - 1;
+        final Map<String, Object> previousEntity = currentEntityIndex < 0 ||
+                entities.size() <= currentEntityIndex ? null : entities.get(currentEntityIndex);
+        entityCountStack.push(Integer.valueOf(entityCount));
+        flattener.startEntity(name);
+        entities.add(currentEntity(name, previousEntity == null && entities.size() >= 0 ? currentRecord : previousEntity));
+    }
+
+    private Map<String, Object> currentEntity(final String name, final Map<String, Object> previousEntity) {
+        final Object existingValue = previousEntity != null ? previousEntity.get(name) : null;
+        final Map<String, Object> currentEntity;
+        if (existingValue != null && existingValue instanceof Map) {
+            @SuppressWarnings("unchecked")
+            final Map<String, Object> existingEntity = (Map<String, Object>) previousEntity.get(name);
+            currentEntity = existingEntity;
+        }
+        else {
+            currentEntity = new LinkedHashMap<>();
+            add(previousEntity != null ? previousEntity : currentRecord, name, currentEntity);
+        }
+        return currentEntity;
+    }
+
+    @Override
+    public void endEntity() {
+        entityCountStack.pop().intValue();
+        flattener.endEntity();
+    }
+
+    @Override
+    public void literal(final String name, final String value) {
+        LOG.debug("Putting '{}': '{}'", name, value);
+        final Integer currentEntityIndex = entityCountStack.peek() - 1;
+        final Map<String, Object> currentEntity = currentEntityIndex < 0 ||
+                entities.size() <= currentEntityIndex ? null : entities.get(currentEntityIndex);
+        add(currentEntity != null ? currentEntity : currentRecord, name, value);
+        // TODO: keep flattener as option?
+        // flattener.literal(name, value);
+    }
+
+    @Override
+    public void resetStream() {
+        outputStreamReceiver.resetStream();
+    }
+
+    @Override
+    public void closeStream() {
+        outputStreamReceiver.closeStream();
+    }
+
+    /**
+     * @param streamReceiver the outputHandler to set
+     */
+    @Override
+    public <R extends StreamReceiver> R setReceiver(final R streamReceiver) {
+        if (streamReceiver == null) {
+            throw new IllegalArgumentException("'streamReceiver' must not be null");
+        }
+        outputStreamReceiver = streamReceiver;
+        return streamReceiver;
+    }
+
+    public StreamReceiver getStreamReceiver() {
+        return outputStreamReceiver;
+    }
+
+    public Map<String, String> getVars() {
+        return vars;
+    }
+
+    public Map<String, Object> getCurrentRecord() {
+        return currentRecord;
+    }
+
+    static void addAll(final Map<String, Object> record, final String fieldName, final List<String> values) {
+        values.forEach(value -> {
+            add(record, fieldName, value);
+        });
+    }
+
+    static void addAll(final Map<String, Object> record, final Map<String, Object> values) {
+        values.entrySet().forEach(value -> {
+            add(record, value.getKey(), value.getValue());
+        });
+    }
+
+    static void add(final Map<String, Object> record, final String name, final Object newValue) {
+        final Object oldValue = record.get(name);
+        record.put(name, oldValue == null ? newValue : merged(oldValue, newValue));
+    }
+
+    @SuppressWarnings("unchecked")
+    static Object merged(final Object object1, final Object object2) {
+        if (object1 instanceof Map && object2 instanceof Map) {
+            ((Map<String, Object>) object1).putAll((Map<String, Object>) object2);
+            return object1;
+        }
+        final List<Object> list = asList(object1);
+        asList(object2).forEach(e -> {
+            list.add(e);
+        });
+        return list;
+    }
+
+    @SuppressWarnings("unchecked")
+    static List<Object> asList(final Object object) {
+        return new ArrayList<>(
+                object instanceof List ? (List<Object>) object : Arrays.asList(object));
+    }
+
+}
diff --git a/org.metafacture.fix/src/main/java/org/metafacture/metafix/RecordTransformer.java b/org.metafacture.fix/src/main/java/org/metafacture/metafix/RecordTransformer.java
new file mode 100644
index 00000000..500423ee
--- /dev/null
+++ b/org.metafacture.fix/src/main/java/org/metafacture/metafix/RecordTransformer.java
@@ -0,0 +1,187 @@
+/*
+ * Copyright 2021 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.metafix;
+
+import org.metafacture.commons.StringUtil;
+import org.metafacture.framework.MetafactureException;
+import org.metafacture.metafix.FixPredicate.Quantifier;
+import org.metafacture.metafix.fix.Do;
+import org.metafacture.metafix.fix.ElsIf;
+import org.metafacture.metafix.fix.Else;
+import org.metafacture.metafix.fix.Expression;
+import org.metafacture.metafix.fix.Fix;
+import org.metafacture.metafix.fix.If;
+import org.metafacture.metafix.fix.MethodCall;
+import org.metafacture.metafix.fix.Options;
+import org.metafacture.metafix.fix.Unless;
+
+import com.google.common.collect.ImmutableMap;
+import org.eclipse.emf.common.util.EList;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * Transform a record using a Fix
+ *
+ * @author Fabian Steeg
+ *
+ */
+class RecordTransformer {
+
+    private static final Logger LOG = LoggerFactory.getLogger(RecordTransformer.class);
+
+    private Fix fix;
+    private Map<String, Object> record;
+    private Map<String, String> vars;
+
+    RecordTransformer(final Map<String, Object> record, final Map<String, String> vars, final Fix fix) {
+        this.record = new LinkedHashMap<>(record);
+        this.vars = vars;
+        this.fix = fix;
+    }
+
+    Map<String, Object> transform() {
+        processSubexpressions(fix.getElements());
+        return record;
+    }
+
+    Map<String, Object> getRecord() {
+        return record;
+    }
+
+    private String resolveVars(final String string) {
+        return string == null ? null : StringUtil.format(string, Metafix.VAR_START, Metafix.VAR_END, false, vars);
+    }
+
+    private void processSubexpressions(final List<Expression> expressions) {
+        for (final Expression sub : expressions) {
+            final EList<String> params = sub.getParams();
+            if (sub instanceof Do) {
+                processBind((Do) sub, params);
+            }
+            else if (sub instanceof If) {
+                processIf((If) sub, params);
+            }
+            else if (sub instanceof Unless) {
+                processUnless((Unless) sub, params);
+            }
+            else {
+                processFunction(sub, params);
+            }
+        }
+    }
+
+    private void processBind(final Do theDo, final EList<String> params) {
+        if (theDo.getName().equals("list")) { // TODO impl multiple binds via FixBind enum
+            final Map<String, String> options = options(theDo.getOptions());
+            final Map<String, Object> fullRecord = new LinkedHashMap<>(record);
+            final Object values = FixMethod.find(record, FixMethod.split(options.get("path")));
+            Metafix.asList(values).stream().filter(val -> val != null).forEach(val -> {
+                // for each val, bind the current record/scope/context to the given var name:
+                record = new LinkedHashMap<>(ImmutableMap.of(options.get("var"), val));
+                processSubexpressions(theDo.getElements());
+                record.remove(options.get("var"));
+                // and remember the things we added while bound (this probably needs some tweaking):
+                Metafix.addAll(fullRecord, record);
+            });
+            record = fullRecord;
+        }
+        else {
+            LOG.warn("Unprocessed bind: {}", theDo);
+            // TODO, possibly: use morph collectors here
+            // final CollectFactory collectFactory = new CollectFactory();
+            // final Map<String, String> attributes = resolvedAttributeMap(params, theDo.getOptions());
+            // final Collect collect = collectFactory.newInstance(expression.getName(), attributes);
+        }
+    }
+
+    private void processIf(final If ifExp, final EList<String> parameters) {
+        final ElsIf elsIfExp = ifExp.getElseIf();
+        final Else elseExp = ifExp.getElse();
+        if (testConditional(ifExp.getName(), parameters)) {
+            processSubexpressions(ifExp.getElements());
+        }
+        else if (elsIfExp != null && testConditional(elsIfExp.getName(), elsIfExp.getParams())) {
+            processSubexpressions(elsIfExp.getElements());
+        }
+        else if (elseExp != null) {
+            processSubexpressions(elseExp.getElements());
+        }
+    }
+
+    private void processUnless(final Unless unless, final EList<String> parameters) {
+        if (!testConditional(unless.getName(), parameters)) {
+            processSubexpressions(unless.getElements());
+        }
+    }
+
+    private boolean testConditional(final String conditional, final EList<String> params) {
+        LOG.debug("<IF>: {} parameters: {}", conditional, params);
+        boolean result = false;
+        if ("exists".equals(conditional)) {
+            return record.containsKey(params.get(0));
+        }
+        if (!conditional.contains("_")) {
+            throw new IllegalArgumentException("Missing quantifier prefix (all_, any_, none_) for " + conditional);
+        }
+        final String[] quantifierAndPredicate = conditional.split("_");
+        try {
+            final Quantifier quantifier = FixPredicate.Quantifier.valueOf(quantifierAndPredicate[0]);
+            final FixPredicate predicate = FixPredicate.valueOf(quantifierAndPredicate[1]);
+            result = quantifier.test(record, predicate, params);
+        }
+        catch (final IllegalArgumentException e) {
+            throw new MetafactureException(e);
+        }
+        // TODO, possibly: use morph functions here (& in processFunction):
+        // final FunctionFactory functionFactory = new FunctionFactory();
+        // functionFactory.registerClass("not_equals", NotEquals.class);
+        // functionFactory.registerClass("replace_all", Replace.class);
+        // final Function function = functionFactory.newInstance(conditional,
+        // resolvedAttributeMap(parameters, theIf.getOptions()));
+        return result;
+    }
+
+    private void processFunction(final Expression expression, final List<String> params) {
+        try {
+            final FixMethod method = FixMethod.valueOf(expression.getName());
+            final List<String> resolvedParams = params.stream().map(this::resolveVars).collect(Collectors.toList());
+            final Map<String, String> options = options(((MethodCall) expression).getOptions());
+            method.apply(record, resolvedParams, options);
+        }
+        catch (final IllegalArgumentException e) {
+            throw new MetafactureException(e);
+        }
+    }
+
+    private Map<String, String> options(final Options options) {
+        final Map<String, String> map = new HashMap<>();
+        if (options != null) {
+            for (int i = 0; i < options.getKeys().size(); i += 1) {
+                map.put(options.getKeys().get(i), options.getValues().get(i));
+            }
+        }
+        return map;
+    }
+
+}
diff --git a/org.metafacture.fix/src/main/java/org/metafacture/fix/interpreter/FixInterpreter.java b/org.metafacture.fix/src/main/java/org/metafacture/metafix/interpreter/FixInterpreter.java
similarity index 81%
rename from org.metafacture.fix/src/main/java/org/metafacture/fix/interpreter/FixInterpreter.java
rename to org.metafacture.fix/src/main/java/org/metafacture/metafix/interpreter/FixInterpreter.java
index 73eaf5d4..9a8f8960 100644
--- a/org.metafacture.fix/src/main/java/org/metafacture/fix/interpreter/FixInterpreter.java
+++ b/org.metafacture.fix/src/main/java/org/metafacture/metafix/interpreter/FixInterpreter.java
@@ -1,13 +1,13 @@
-package org.metafacture.fix.interpreter;
+package org.metafacture.metafix.interpreter;
 
-import org.metafacture.fix.fix.Do;
-import org.metafacture.fix.fix.ElsIf;
-import org.metafacture.fix.fix.Else;
-import org.metafacture.fix.fix.Expression;
-import org.metafacture.fix.fix.Fix;
-import org.metafacture.fix.fix.If;
-import org.metafacture.fix.fix.MethodCall;
-import org.metafacture.metamorph.Metafix;
+import org.metafacture.metafix.Metafix;
+import org.metafacture.metafix.fix.Do;
+import org.metafacture.metafix.fix.ElsIf;
+import org.metafacture.metafix.fix.Else;
+import org.metafacture.metafix.fix.Expression;
+import org.metafacture.metafix.fix.Fix;
+import org.metafacture.metafix.fix.If;
+import org.metafacture.metafix.fix.MethodCall;
 
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.xtext.xbase.interpreter.impl.XbaseInterpreter;
@@ -32,7 +32,8 @@ public void run(final Metafix metafixParam, final EObject program) {
         }
     }
 
-    private void process(final Expression expression) { // checkstyle-disable-line CyclomaticComplexity|NPathComplexity
+    @SuppressWarnings({"checkstyle:CyclomaticComplexity", "checkstyle:NPathComplexity"})
+    private void process(final Expression expression) {
         metafix.getExpressions().add(expression);
 
         boolean matched = false;
diff --git a/org.metafacture.fix/src/main/java/org/metafacture/fix/jvmmodel/FixJvmModelInferrer.java b/org.metafacture.fix/src/main/java/org/metafacture/metafix/jvmmodel/FixJvmModelInferrer.java
similarity index 92%
rename from org.metafacture.fix/src/main/java/org/metafacture/fix/jvmmodel/FixJvmModelInferrer.java
rename to org.metafacture.fix/src/main/java/org/metafacture/metafix/jvmmodel/FixJvmModelInferrer.java
index 90eb7af8..ae08a5cf 100644
--- a/org.metafacture.fix/src/main/java/org/metafacture/fix/jvmmodel/FixJvmModelInferrer.java
+++ b/org.metafacture.fix/src/main/java/org/metafacture/metafix/jvmmodel/FixJvmModelInferrer.java
@@ -1,7 +1,7 @@
-package org.metafacture.fix.jvmmodel;
+package org.metafacture.metafix.jvmmodel;
 
-import org.metafacture.fix.fix.Fix;
-import org.metafacture.metamorph.Metafix;
+import org.metafacture.metafix.Metafix;
+import org.metafacture.metafix.fix.Fix;
 
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.xtext.common.types.JvmGenericType;
diff --git a/org.metafacture.fix/src/main/java/org/metafacture/fix/parser/antlr/FixTokenSource.java b/org.metafacture.fix/src/main/java/org/metafacture/metafix/parser/antlr/FixTokenSource.java
similarity index 84%
rename from org.metafacture.fix/src/main/java/org/metafacture/fix/parser/antlr/FixTokenSource.java
rename to org.metafacture.fix/src/main/java/org/metafacture/metafix/parser/antlr/FixTokenSource.java
index d824e398..baf82e83 100644
--- a/org.metafacture.fix/src/main/java/org/metafacture/fix/parser/antlr/FixTokenSource.java
+++ b/org.metafacture.fix/src/main/java/org/metafacture/metafix/parser/antlr/FixTokenSource.java
@@ -1,6 +1,6 @@
-package org.metafacture.fix.parser.antlr;
+package org.metafacture.metafix.parser.antlr;
 
-import org.metafacture.fix.parser.antlr.internal.InternalFixParser;
+import org.metafacture.metafix.parser.antlr.internal.InternalFixParser;
 
 import org.antlr.runtime.Token;
 import org.antlr.runtime.TokenSource;
diff --git a/org.metafacture.fix/src/main/java/org/metafacture/fix/scoping/FixScopeProvider.java b/org.metafacture.fix/src/main/java/org/metafacture/metafix/scoping/FixScopeProvider.java
similarity index 87%
rename from org.metafacture.fix/src/main/java/org/metafacture/fix/scoping/FixScopeProvider.java
rename to org.metafacture.fix/src/main/java/org/metafacture/metafix/scoping/FixScopeProvider.java
index c5da0baa..14f0a75a 100644
--- a/org.metafacture.fix/src/main/java/org/metafacture/fix/scoping/FixScopeProvider.java
+++ b/org.metafacture.fix/src/main/java/org/metafacture/metafix/scoping/FixScopeProvider.java
@@ -1,4 +1,4 @@
-package org.metafacture.fix.scoping;
+package org.metafacture.metafix.scoping;
 
 /**
  * This class contains custom scoping description.
diff --git a/org.metafacture.fix/src/main/java/org/metafacture/fix/validation/FixValidator.java b/org.metafacture.fix/src/main/java/org/metafacture/metafix/validation/FixValidator.java
similarity index 84%
rename from org.metafacture.fix/src/main/java/org/metafacture/fix/validation/FixValidator.java
rename to org.metafacture.fix/src/main/java/org/metafacture/metafix/validation/FixValidator.java
index 53af9a76..600112f1 100644
--- a/org.metafacture.fix/src/main/java/org/metafacture/fix/validation/FixValidator.java
+++ b/org.metafacture.fix/src/main/java/org/metafacture/metafix/validation/FixValidator.java
@@ -1,4 +1,4 @@
-package org.metafacture.fix.validation;
+package org.metafacture.metafix.validation;
 
 /**
  * This class contains custom validation rules.
diff --git a/org.metafacture.fix/src/main/java/org/metafacture/metafix/validation/XtextValidator.java b/org.metafacture.fix/src/main/java/org/metafacture/metafix/validation/XtextValidator.java
new file mode 100644
index 00000000..a8de336b
--- /dev/null
+++ b/org.metafacture.fix/src/main/java/org/metafacture/metafix/validation/XtextValidator.java
@@ -0,0 +1,78 @@
+package org.metafacture.metafix.validation;
+
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.xtext.ISetup;
+import org.eclipse.xtext.XtextStandaloneSetup;
+import org.eclipse.xtext.resource.XtextResource;
+import org.eclipse.xtext.resource.XtextResourceSet;
+import org.eclipse.xtext.util.CancelIndicator;
+import org.eclipse.xtext.validation.CheckMode;
+import org.eclipse.xtext.validation.Issue;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+
+public class XtextValidator {
+
+    private static final Logger LOG = LoggerFactory.getLogger(XtextValidator.class);
+
+    private XtextValidator() {
+        throw new IllegalAccessError("Utility class");
+    }
+
+    private static boolean validate(final XtextResource resource, final ISetup setup) {
+        final List<Issue> issues = resource.getResourceServiceProvider()
+            .getResourceValidator().validate(resource, CheckMode.ALL, CancelIndicator.NullImpl);
+
+        final int count = issues.size();
+
+        if (count > 0) {
+            LOG.warn("The {} file '{}' has {} issue{}:",
+                    setup.getClass().getSimpleName(), resource.getURI().toFileString(), count, count > 1 ? "s" : "");
+
+            issues.forEach(i -> LOG.warn("- {}: {} ({}:{})",
+                        i.getSeverity(), i.getMessage(), i.getLineNumber(), i.getColumn()));
+
+            return false;
+        }
+
+        return true;
+    }
+
+    public static boolean validate(final String path, final ISetup setup) {
+        return validate(getResource(path, setup), setup);
+    }
+
+    private static XtextResource getResource(final String path, final ISetup setup) {
+        final File file = new File(path);
+        String absolutePath;
+
+        try {
+            absolutePath = file.getCanonicalPath();
+        }
+        catch (final IOException e) {
+            absolutePath = file.getAbsolutePath();
+        }
+
+        return (XtextResource) setup.createInjectorAndDoEMFRegistration()
+            .getInstance(XtextResourceSet.class).getResource(URI.createFileURI(absolutePath), true);
+    }
+
+    public static XtextResource getValidatedResource(final String path, final ISetup setup) {
+        final XtextResource resource = getResource(path, setup);
+        validate(resource, setup);
+        return resource;
+    }
+
+    public static void main(final String[] args) {
+        if (args != null && args.length == 1) {
+            System.exit(validate(args[0], new XtextStandaloneSetup()) ? 0 : 1);
+        }
+
+        throw new IllegalArgumentException(String.format("Usage: %s <xtext-file>", XtextValidator.class.getName()));
+    }
+
+}
diff --git a/org.metafacture.fix/src/main/java/org/metafacture/metamorph/FixBuilder.java b/org.metafacture.fix/src/main/java/org/metafacture/metamorph/FixBuilder.java
deleted file mode 100644
index 3e118919..00000000
--- a/org.metafacture.fix/src/main/java/org/metafacture/metamorph/FixBuilder.java
+++ /dev/null
@@ -1,525 +0,0 @@
-/*
- * Copyright 2013, 2020 Deutsche Nationalbibliothek and others
- *
- * 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.metamorph;
-
-import org.metafacture.commons.StringUtil;
-import org.metafacture.fix.fix.Do;
-import org.metafacture.fix.fix.Expression;
-import org.metafacture.fix.fix.Fix;
-import org.metafacture.fix.fix.If;
-import org.metafacture.fix.fix.MethodCall;
-import org.metafacture.fix.fix.Options;
-import org.metafacture.metamorph.api.Collect;
-import org.metafacture.metamorph.api.ConditionAware;
-import org.metafacture.metamorph.api.FlushListener;
-import org.metafacture.metamorph.api.Function;
-import org.metafacture.metamorph.api.InterceptorFactory;
-import org.metafacture.metamorph.api.NamedValuePipe;
-import org.metafacture.metamorph.functions.Constant;
-import org.metafacture.metamorph.functions.NotEquals;
-import org.metafacture.metamorph.functions.Replace;
-
-import com.google.common.collect.Multimap;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.xtext.xbase.lib.Pair;
-
-import java.util.Deque;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.regex.Pattern;
-
-/**
- * Builds a {@link Metafix} from a Fix DSL description
- *
- * @author Markus Michael Geipel (MorphBuilder)
- * @author Christoph Böhme (MorphBuilder)
- * @author Fabian Steeg (FixBuilder)
- *
- */
-public class FixBuilder { // checkstyle-disable-line ClassDataAbstractionCoupling|ClassFanOutComplexity
-
-    static final String ARRAY_MARKER = "[]";
-    private static final String FLUSH_WITH = "flushWith";
-    private static final String RECORD = "record";
-
-    private final Deque<StackFrame> stack = new LinkedList<>();
-    private final InterceptorFactory interceptorFactory;
-    private final Metafix metafix;
-
-    private CollectFactory collectFactory;
-    private FunctionFactory functionFactory;
-
-    public FixBuilder(final Metafix metafix, final InterceptorFactory interceptorFactory) {
-        this.metafix = metafix;
-        this.interceptorFactory = interceptorFactory;
-
-        stack.push(new StackFrame(metafix));
-
-        collectFactory = new CollectFactory();
-        functionFactory = new FunctionFactory();
-        // morph: not-equals, replace, fix: not_equals, replace_all
-        functionFactory.registerClass("not_equals", NotEquals.class);
-        functionFactory.registerClass("replace_all", Replace.class);
-    }
-
-    Metafix getMetafix() {
-        return metafix;
-    }
-
-    public void walk(final Fix fix) {
-        processSubexpressions(fix.getElements(), null);
-    }
-
-    private void processBind(final Expression expression, final EList<String> params) {
-        final String firstParam = resolvedAttribute(params, 1);
-        final Do theDo = (Do) expression;
-        Collect collect = null;
-
-        // Special bind cases, no generic no-args collectors
-        switch (expression.getName()) {
-            case "entity":
-                collect = createEntity(firstParam);
-                break;
-            case "array":
-                collect = createEntity(firstParam + ARRAY_MARKER);
-                break;
-            case "map":
-                final NamedValuePipe enterDataMap = enterDataMap(params, false);
-                processSubexpressions(theDo.getElements(), firstParam);
-                exitData();
-                if (enterDataMap instanceof Entity) {
-                    exitCollectorAndFlushWith(firstParam);
-                }
-                return;
-            default:
-                break;
-        }
-
-        // try generic no-args collectors, registered in collectFactory
-        if (collect == null) {
-            if (!collectFactory.containsKey(expression.getName())) {
-                throw new IllegalArgumentException("Collector " + expression.getName() +
-                        " not found");
-            }
-            final Map<String, String> attributes = resolvedAttributeMap(params, theDo.getOptions());
-            // flushWith should not be passed to the headPipe object via a
-            // setter (see newInstance):
-            attributes.remove(FLUSH_WITH);
-            collect = collectFactory.newInstance(expression.getName(), attributes);
-        }
-        if (collect != null) {
-            stack.push(new StackFrame(collect));
-            processSubexpressions(theDo.getElements(), firstParam);
-            // must be set after recursive calls to flush descendants before parent
-            final String flushWith = resolvedAttribute(resolvedAttributeMap(params, theDo.getOptions()), FLUSH_WITH);
-            exitCollectorAndFlushWith(flushWith);
-        }
-    }
-
-    protected final String resolveVars(final String string) {
-        return string == null ? null : StringUtil.format(string, Metafix.VAR_START, Metafix.VAR_END, false, metafix.getVars());
-    }
-
-    protected final Map<String, String> resolvedAttributeMap(final List<String> params, final Options options) {
-        final Map<String, String> attributes = new HashMap<String, String>();
-        if (options == null) {
-            return attributes;
-        }
-        final EList<String> keys = options.getKeys();
-        final EList<String> values = options.getValues();
-        for (int i = 0; i < keys.size() && i < values.size(); i = i + 1) {
-            attributes.put(resolveVars(keys.get(i)), resolveVars(values.get(i)));
-        }
-        return attributes;
-    }
-
-    private Collect createEntity(final String name) {
-        final Entity entity = new Entity(() -> metafix.getStreamReceiver());
-        entity.setName(name);
-        return entity;
-    }
-
-    protected void exitCollectorAndFlushWith(final String flushWith) {
-        final StackFrame currentCollect = stack.pop();
-        final NamedValuePipe tailPipe = currentCollect.getPipe();
-
-        final NamedValuePipe interceptor = interceptorFactory.createNamedValueInterceptor();
-        final NamedValuePipe delegate;
-        if (interceptor == null || tailPipe instanceof Entity) {
-            // The result of entity collectors cannot be intercepted
-            // because they only use the receive/emit interface for
-            // signalling while the actual data is transferred using
-            // a custom mechanism. In order for this to work the Entity
-            // class checks whether source and receiver are an
-            // instances of Entity. If an interceptor is inserted between
-            // entity elements this mechanism will break.
-            delegate = tailPipe;
-        }
-        else {
-            delegate = interceptor;
-            delegate.addNamedValueSource(tailPipe);
-        }
-
-        final StackFrame parent = stack.peek();
-
-        if (parent.isInEntity()) {
-            ((Entity) parent.getPipe()).setNameSource(delegate);
-        }
-        else if (parent.isInCondition()) {
-            ((ConditionAware) parent.getPipe()).setConditionSource(delegate);
-        }
-        else {
-            parent.getPipe().addNamedValueSource(delegate);
-        }
-        final Collect collector = (Collect) tailPipe;
-        if (null != flushWith) {
-            collector.setWaitForFlush(true);
-            registerFlush(flushWith, collector);
-        }
-    }
-
-    private void registerFlush(final String flushWith, final FlushListener flushListener) {
-        final String[] keysSplit = Pattern.compile("|", Pattern.LITERAL).split(flushWith);
-        for (final String key : keysSplit) {
-            final FlushListener interceptor = interceptorFactory.createFlushInterceptor(flushListener);
-            final FlushListener delegate;
-            if (interceptor == null) {
-                delegate = flushListener;
-            }
-            else {
-                delegate = interceptor;
-            }
-            if (key.equals(RECORD)) {
-                metafix.registerRecordEndFlush(delegate);
-            }
-            else {
-                metafix.registerNamedValueReceiver(key, new Flush(delegate));
-            }
-        }
-    }
-
-    private void processSubexpressions(final List<Expression> expressions, final String superSource) {
-        for (final Expression sub : expressions) {
-            final EList<String> p = sub.getParams();
-            String source = resolvedAttribute(p, 1);
-            if (source == null && superSource != null) {
-                source = superSource;
-            }
-            if (sub instanceof Do) {
-                processBind(sub, p);
-            }
-            else if (sub instanceof If) {
-                processConditional(sub, p);
-            }
-            else {
-                processFunction(sub, p, source);
-            }
-        }
-    }
-
-    private void processConditional(final Expression expression, final EList<String> p) {
-        final boolean isTopLevelIf = stack.peek().pipe instanceof Metafix;
-        // If we're at the top level, we wrap the If into a collector:
-        if (isTopLevelIf) {
-            final Collect collect = collectFactory.newInstance("choose");
-            stack.push(new StackFrame(collect));
-        }
-        enterIf();
-        final If theIf = (If) expression;
-        enterDataMap(p, false);
-        final Map<String, String> attributes = resolvedAttributeMap(p, null);
-        attributes.put("string", resolvedAttribute(p, 2)); // for contains & equals morph functions
-        // TODO: support morph functions: regexp -> match, morph quantors as prefixes: none_, all_, any_
-        runMetamorphFunction(expression.getName(), attributes);
-        exitData();
-        // The Metamorph IF acts like a guard, executing not nested statements, but following statements:
-        exitIf();
-        processSubexpressions(theIf.getElements(), resolvedAttribute(p, 1));
-        // As a draft for a record mode, we might do something like this instead:
-        if (metafix.isRecordMode() && testConditional(theIf.getName(), p)) {
-            processSubexpressions(theIf.getElements(), resolvedAttribute(p, 1));
-        }
-        // If we're at the top level, we close the wrapping collector:
-        if (isTopLevelIf) {
-            exitCollectorAndFlushWith(RECORD);
-        }
-    }
-
-    private boolean testConditional(final String conditional, final EList<String> p) {
-        System.out.printf("<IF>: %s p: %s\n", conditional, p);
-        boolean result = false;
-        final String field = resolvedAttribute(p, 1);
-        final String value = resolvedAttribute(p, 2);
-        final Multimap<String, String> map = metafix.getCurrentRecord();
-        System.out.printf("<%s>: field: %s value: %s in: %s\n", conditional, field, value, map);
-        switch (conditional) {
-            case "any_match":
-                result = map.containsKey(field) && map.get(field).stream().anyMatch(v -> v.matches(value));
-                break;
-            case "all_match":
-                result = map.containsKey(field) && map.get(field).stream().allMatch(v -> v.matches(value));
-                break;
-            default:
-        }
-        return result;
-    }
-
-    private void processFunction(final Expression expression, final List<String> params, final String source) {
-        final FixFunction functionToRun = findFixFunction(expression);
-        if (functionToRun != null) {
-            System.out.printf("Running Fix function %s, params %s, source %s\n", expression.getName(), params, source);
-            functionToRun.apply(this, expression, params, source);
-        }
-        else {
-            final Options options = ((MethodCall) expression).getOptions();
-            final Map<String, String> attributes = resolvedAttributeMap(params, options);
-            runMetamorphFunction(expression.getName(), attributes);
-        }
-    }
-
-    private FixFunction findFixFunction(final Expression expression) {
-        for (final FixFunction exp : FixFunction.values()) {
-            if (exp.name().equalsIgnoreCase(expression.getName())) {
-                return exp;
-            }
-        }
-        return null;
-    }
-
-    private void runMetamorphFunction(final String name, final Map<String, String> attributes) {
-        if (functionFactory.containsKey(name)) {
-            final String flushWith = attributes.remove(FLUSH_WITH);
-            final Function function = functionFactory.newInstance(name, attributes);
-            if (null != flushWith) {
-                registerFlush(flushWith, function);
-            }
-            function.setMaps(metafix);
-
-            final StackFrame head = stack.peek();
-            final NamedValuePipe interceptor = interceptorFactory.createNamedValueInterceptor();
-            final NamedValuePipe delegate;
-            if (interceptor == null) {
-                delegate = function;
-            }
-            else {
-                delegate = interceptor;
-                function.addNamedValueSource(delegate);
-            }
-            delegate.addNamedValueSource(head.getPipe());
-            head.setPipe(function);
-        }
-        else {
-            throw new IllegalArgumentException(name + " not found");
-        }
-    }
-
-    void exitData() {
-        final NamedValuePipe dataPipe = stack.pop().getPipe();
-
-        final NamedValuePipe interceptor = interceptorFactory.createNamedValueInterceptor();
-        final NamedValuePipe delegate;
-        if (interceptor == null) {
-            delegate = dataPipe;
-        }
-        else {
-            delegate = interceptor;
-            delegate.addNamedValueSource(dataPipe);
-        }
-
-        final StackFrame parent = stack.peek();
-
-        if (parent.isInEntity()) {
-            ((Entity) parent.getPipe()).setNameSource(delegate);
-        }
-        else if (parent.isInCondition()) {
-            ((ConditionAware) parent.getPipe()).setConditionSource(delegate);
-        }
-        else {
-            parent.getPipe().addNamedValueSource(delegate);
-        }
-    }
-
-    NamedValuePipe enterDataMap(final List<String> params, final boolean standalone) {
-        Entity entity = null;
-        final Data data = new Data();
-        String dataName = resolvedAttribute(params, 2);
-        final String resolvedAttribute = resolvedAttribute(params, 2);
-        if (resolvedAttribute != null && resolvedAttribute.contains(".")) {
-            final String[] keyElements = resolvedAttribute.split("\\.");
-            final Pair<Entity, Entity> firstAndLast = createEntities(keyElements);
-            firstAndLast.getValue().addNamedValueSource(data);
-            entity = firstAndLast.getKey();
-            stack.push(new StackFrame(entity));
-            dataName = keyElements[keyElements.length - 1];
-        }
-        data.setName(dataName);
-        final String source = resolvedAttribute(params, 1);
-        metafix.registerNamedValueReceiver(source, getDelegate(data));
-        final StackFrame frame = new StackFrame(data);
-        if (!standalone) {
-            frame.setInEntity(true);
-        }
-        stack.push(frame);
-        return entity != null ? entity : data;
-    }
-
-    void enterDataAdd(final List<String> params) {
-        final String resolvedAttribute = resolvedAttribute(params, 1);
-        if (resolvedAttribute.contains(".")) {
-            addNestedField(params, resolvedAttribute);
-        }
-        else {
-            final Data newDate = new Data();
-            newDate.setName(resolvedAttribute);
-            final Constant constant = new Constant();
-            constant.setValue(resolvedAttribute(params, 2));
-            newDate.addNamedValueSource(constant);
-            metafix.registerNamedValueReceiver("_id", constant);
-            stack.push(new StackFrame(newDate));
-        }
-    }
-
-    void enterDataFunction(final String fieldName, final NamedValuePipe function, final boolean standalone) {
-        if (standalone) {
-            final Data data = new Data();
-            data.setName("@" + fieldName);
-            metafix.registerNamedValueReceiver(fieldName, getDelegate(data, function));
-            stack.push(new StackFrame(data));
-            return;
-        }
-        final StackFrame head = stack.peek();
-        final NamedValuePipe interceptor = interceptorFactory.createNamedValueInterceptor();
-        final NamedValuePipe delegate;
-        if (interceptor == null) {
-            delegate = function;
-        }
-        else {
-            delegate = interceptor;
-            function.addNamedValueSource(delegate);
-        }
-        delegate.addNamedValueSource(head.getPipe());
-        head.setPipe(function);
-    }
-
-    void enterIf() {
-        assert stack.peek().getPipe() instanceof ConditionAware :
-                "statement `if` is not allowed in the current element";
-
-        stack.peek().setInCondition(true);
-    }
-
-    void exitIf() {
-        stack.peek().setInCondition(false);
-    }
-
-    private void addNestedField(final List<String> params, final String resolvedAttribute) {
-        final String[] keyElements = resolvedAttribute.split("\\.");
-        final Pair<Entity, Entity> firstAndLast = createEntities(keyElements);
-        final Constant constant = new Constant();
-        constant.setValue(resolvedAttribute(params, 2));
-        final Data newData = new Data();
-        newData.setName(keyElements[keyElements.length - 1]);
-        newData.addNamedValueSource(constant);
-        firstAndLast.getValue().addNamedValueSource(newData);
-        metafix.registerNamedValueReceiver("_id", constant);
-        stack.push(new StackFrame(firstAndLast.getKey()));
-    }
-
-    private Pair<Entity, Entity> createEntities(final String[] keyElements) {
-        Entity firstEntity = null;
-        Entity lastEntity = null;
-        for (int i = 0; i < keyElements.length - 1; i = i + 1) {
-            final Entity currentEntity = new Entity(() -> metafix.getStreamReceiver());
-            currentEntity.setName(keyElements[i]);
-            if (firstEntity == null) {
-                firstEntity = currentEntity;
-            }
-            if (lastEntity != null) {
-                lastEntity.addNamedValueSource(currentEntity);
-            }
-            lastEntity = currentEntity;
-        }
-        return new Pair<>(firstEntity, lastEntity);
-    }
-
-    private NamedValuePipe getDelegate(final NamedValuePipe dataForDelegate) {
-        return getDelegate(dataForDelegate, interceptorFactory.createNamedValueInterceptor());
-    }
-
-    private NamedValuePipe getDelegate(final NamedValuePipe dataForDelegate, final NamedValuePipe interceptor) {
-        final NamedValuePipe delegate;
-
-        if (interceptor == null) {
-            delegate = dataForDelegate;
-        }
-        else {
-            delegate = interceptor;
-            dataForDelegate.addNamedValueSource(delegate);
-        }
-
-        return delegate;
-    }
-
-    private String resolvedAttribute(final List<String> params, final int i) {
-        return params.size() < i ? null : resolveVars(params.get(i - 1));
-    }
-
-    private String resolvedAttribute(final Map<String, String> attributes, final String string) {
-        return resolveVars(attributes.get(string));
-    }
-
-    private static class StackFrame {
-
-        private NamedValuePipe pipe;
-
-        private boolean inEntity;
-
-        private boolean inCondition;
-
-        private StackFrame(final NamedValuePipe pipe) {
-            this.pipe = pipe;
-        }
-
-        public void setInCondition(final boolean inCondition) {
-            this.inCondition = inCondition;
-        }
-
-        public boolean isInCondition() {
-            return inCondition;
-        }
-
-        public NamedValuePipe getPipe() {
-            return pipe;
-        }
-
-        public void setPipe(final NamedValuePipe pipe) {
-            this.pipe = pipe;
-        }
-
-        public void setInEntity(final boolean inEntity) {
-            this.inEntity = inEntity;
-        }
-
-        public boolean isInEntity() {
-            return inEntity;
-        }
-
-    }
-
-}
diff --git a/org.metafacture.fix/src/main/java/org/metafacture/metamorph/FixFunction.java b/org.metafacture.fix/src/main/java/org/metafacture/metamorph/FixFunction.java
deleted file mode 100644
index 1f298241..00000000
--- a/org.metafacture.fix/src/main/java/org/metafacture/metamorph/FixFunction.java
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * Copyright 2020 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.metamorph;
-
-import org.metafacture.fix.fix.Expression;
-import org.metafacture.fix.fix.MethodCall;
-import org.metafacture.fix.fix.Options;
-import org.metafacture.metamorph.api.NamedValuePipe;
-import org.metafacture.metamorph.functions.Lookup;
-import org.metafacture.metamorph.maps.FileMap;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-enum FixFunction {
-    // fix-style functions, not (like) in morph
-    MAP {
-        public void apply(final FixBuilder builder, final Expression expression, final List<String> params,
-                final String source) {
-            final NamedValuePipe enterDataMap = builder.enterDataMap(params, false);
-            builder.exitData();
-            if (enterDataMap instanceof Entity) {
-                builder.exitCollectorAndFlushWith(null);
-            }
-        }
-    },
-    ADD_FIELD {
-        public void apply(final FixBuilder builder, final Expression expression, final List<String> params,
-                final String source) {
-            builder.enterDataAdd(params);
-            builder.exitData();
-        }
-    },
-    LOOKUP {
-        public void apply(final FixBuilder builder, final Expression expression, final List<String> params,
-                final String source) {
-            final Lookup lookup = new Lookup();
-            lookup.setMaps(builder.getMetafix());
-            final Map<String, String> map = buildMap(expression);
-            final String name = map.hashCode() + "";
-            lookup.setMap(name);
-            builder.getMetafix().putMap(name, map);
-            builder.enterDataFunction(source, lookup, false);
-        }
-
-        private Map<String, String> buildMap(final Expression expression) {
-            final Map<String, String> options = options((MethodCall) expression);
-            final String file = options.get("in");
-            final String sep = "separator";
-            final boolean useFileMap = file != null &&
-                    (options.size() == 1 || options.size() == 2 && options.containsKey(sep));
-            final Map<String, String> map = useFileMap ? fileMap(file, options.get(sep)) : options;
-            return map;
-        }
-
-        private Map<String, String> options(final MethodCall method) {
-            final Options options = method.getOptions();
-            final Map<String, String> map = new HashMap<>();
-            if (options != null) {
-                for (int i = 0; i < options.getKeys().size(); i += 1) {
-                    map.put(options.getKeys().get(i), options.getValues().get(i));
-                }
-            }
-            return map;
-        }
-
-        private Map<String, String> fileMap(final String secondParam, final String separator) {
-            final FileMap fileMap = new FileMap();
-            if (separator != null) {
-                fileMap.setSeparator(separator);
-            }
-            fileMap.setFile(secondParam);
-            return fileMap;
-        }
-
-    };
-    public abstract void apply(FixBuilder builder, Expression expression, List<String> params, String source);
-}
diff --git a/org.metafacture.fix/src/main/java/org/metafacture/metamorph/Metafix.java b/org.metafacture.fix/src/main/java/org/metafacture/metamorph/Metafix.java
deleted file mode 100644
index 7c3e68fd..00000000
--- a/org.metafacture.fix/src/main/java/org/metafacture/metamorph/Metafix.java
+++ /dev/null
@@ -1,550 +0,0 @@
-/*
- * Copyright 2013, 2019 Deutsche Nationalbibliothek and others
- *
- * 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.metamorph;
-
-import org.metafacture.commons.tries.SimpleRegexTrie;
-import org.metafacture.fix.FixStandaloneSetup;
-import org.metafacture.fix.fix.Expression;
-import org.metafacture.fix.fix.Fix;
-import org.metafacture.flowcontrol.StreamBuffer;
-import org.metafacture.framework.StandardEventNames;
-import org.metafacture.framework.StreamPipe;
-import org.metafacture.framework.StreamReceiver;
-import org.metafacture.framework.helpers.DefaultStreamReceiver;
-import org.metafacture.mangling.StreamFlattener;
-import org.metafacture.metamorph.api.FlushListener;
-import org.metafacture.metamorph.api.InterceptorFactory;
-import org.metafacture.metamorph.api.Maps;
-import org.metafacture.metamorph.api.MorphErrorHandler;
-import org.metafacture.metamorph.api.NamedValuePipe;
-import org.metafacture.metamorph.api.NamedValueReceiver;
-import org.metafacture.metamorph.api.NamedValueSource;
-import org.metafacture.metamorph.api.SourceLocation;
-
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.Multimap;
-import com.google.common.io.CharStreams;
-import com.google.inject.Injector;
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.xtext.resource.XtextResource;
-import org.eclipse.xtext.resource.XtextResourceSet;
-import org.eclipse.xtext.util.CancelIndicator;
-import org.eclipse.xtext.validation.CheckMode;
-import org.eclipse.xtext.validation.IResourceValidator;
-import org.eclipse.xtext.validation.Issue;
-
-import java.io.Closeable;
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileReader;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.Reader;
-import java.io.StringReader;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Deque;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Transforms a data stream sent via the {@link StreamReceiver} interface. Use
- * {@link FixBuilder} to create an instance based on a Fix DSL description.
- *
- * @author Markus Michael Geipel (Metamorph)
- * @author Christoph Böhme (Metamorph)
- * @author Fabian Steeg (Metafix)
- */
-// TODO: implement ConditionAware to support top-level `if` like in MetafixRecordTest
-public class Metafix implements StreamPipe<StreamReceiver>, NamedValuePipe, Maps { // checkstyle-disable-line ClassDataAbstractionCoupling|ClassFanOutComplexity
-
-    public static final String ELSE_KEYWORD = "_else";
-    public static final char FEEDBACK_CHAR = '@';
-    public static final char ESCAPE_CHAR = '\\';
-    public static final String METADATA = "__meta";
-    public static final String VAR_START = "$[";
-    public static final String VAR_END = "]";
-
-    private static final String ENTITIES_NOT_BALANCED = "Entity starts and ends are not balanced";
-    private static final Object ELSE_NESTED_KEYWORD = "_elseNested";
-    private static final Object ELSE_FLATTENED_KEYWORD = "_elseFlattened";
-
-    private static final InterceptorFactory NULL_INTERCEPTOR_FACTORY = new NullInterceptorFactory();
-    private static final Map<String, String> NO_VARS = Collections.emptyMap();
-
-    private Multimap<String, String> currentRecord = HashMultimap.create();
-
-    // warning: auxiliary class WildcardRegistry in WildcardDataRegistry.java should not be accessed from outside its own source file
-    //private final Registry<NamedValueReceiver> dataRegistry = new WildcardRegistry<>();
-    private final Registry<NamedValueReceiver> dataRegistry = new Registry<NamedValueReceiver>() {
-        private final SimpleRegexTrie<NamedValueReceiver> trie = new SimpleRegexTrie<>();
-
-        @Override
-        public void register(final String path, final NamedValueReceiver value) {
-            trie.put(path, value);
-        }
-
-        @Override
-        public List<NamedValueReceiver> get(final String path) {
-            return trie.get(path);
-        }
-    };
-
-    private final List<Closeable> resources = new ArrayList<>();
-    private final List<NamedValueReceiver> elseSources = new ArrayList<>();
-    private final Map<String, Map<String, String>> maps = new HashMap<>();
-    private final StreamFlattener flattener = new StreamFlattener();
-
-    private final Deque<Integer> entityCountStack = new LinkedList<>();
-    private int currentEntityCount;
-    private int entityCount;
-
-    private StreamReceiver outputStreamReceiver;
-    private MorphErrorHandler errorHandler = new DefaultErrorHandler();
-    private int recordCount;
-    private final List<FlushListener> recordEndListener = new ArrayList<>();
-
-    private final List<Expression> expressions = new ArrayList<>();
-    private Map<String, String> vars = NO_VARS;
-
-    private boolean elseNested;
-    private boolean elseNestedEntityStarted;
-    private String currentLiteralName;
-
-    private final StreamBuffer buffer = new StreamBuffer();
-    private boolean needsReplay;
-    private Fix fix;
-    private InterceptorFactory interceptorFactory;
-    private boolean recordMode;
-
-    public Metafix() {
-        init();
-    }
-
-    public Metafix(final String fixDef) throws FileNotFoundException {
-        this(fixDef, NO_VARS);
-    }
-
-    public Metafix(final String fixDef, final Map<String, String> vars) throws FileNotFoundException {
-        this(fixDef, vars, NULL_INTERCEPTOR_FACTORY);
-    }
-
-    public Metafix(final String fixDef, final InterceptorFactory interceptorFactory) throws FileNotFoundException {
-        this(fixDef, NO_VARS, interceptorFactory);
-    }
-
-    public Metafix(final String fixDef, final Map<String, String> vars, final InterceptorFactory interceptorFactory) throws FileNotFoundException {
-        this(fixDef.endsWith(".fix") ? new FileReader(fixDef) : new StringReader(fixDef), vars, interceptorFactory);
-    }
-
-    public Metafix(final Reader morphDef) {
-        this(morphDef, NO_VARS);
-    }
-
-    public Metafix(final Reader fixDef, final Map<String, String> vars) {
-        this(fixDef, vars, NULL_INTERCEPTOR_FACTORY);
-    }
-
-    public Metafix(final Reader fixDef, final InterceptorFactory interceptorFactory) {
-        this(fixDef, NO_VARS, interceptorFactory);
-    }
-
-    public Metafix(final Reader fixDef, final Map<String, String> vars, final InterceptorFactory interceptorFactory) {
-        buildPipeline(fixDef, vars, interceptorFactory);
-        init();
-    }
-
-    public Metafix(final InputStream fixDef) {
-        this(fixDef, NO_VARS);
-    }
-
-    public Metafix(final InputStream fixDef, final Map<String, String> vars) {
-        this(fixDef, vars, NULL_INTERCEPTOR_FACTORY);
-    }
-
-    public Metafix(final InputStream fixDef, final InterceptorFactory interceptorFactory) {
-        this(fixDef, NO_VARS, interceptorFactory);
-    }
-
-    public Metafix(final InputStream fixDef, final Map<String, String> vars, final InterceptorFactory interceptorFactory) {
-        this(new InputStreamReader(fixDef), vars, interceptorFactory);
-    }
-
-    public List<Expression> getExpressions() {
-        return expressions;
-    }
-
-    private void init() {
-        flattener.setReceiver(new DefaultStreamReceiver() {
-            @Override
-            public void literal(final String name, final String value) {
-                dispatch(name, value, getElseSources(), false);
-            }
-        });
-    }
-
-    private void buildPipeline(final Reader fixDef, final Map<String, String> theVars, final InterceptorFactory interceptorF) {
-        final Fix f = parseFix(fixDef);
-        this.fix = f;
-        this.vars = theVars;
-        this.interceptorFactory = interceptorF;
-        // TODO: FixInterpreter no longer needed?
-        // new FixInterpreter().run(this, fix);
-        new FixBuilder(this, interceptorFactory).walk(fix);
-    }
-
-    private Fix parseFix(final Reader fixDef) {
-        // TODO: do this only once per application
-        final Injector injector = new FixStandaloneSetup().createInjectorAndDoEMFRegistration();
-        FixStandaloneSetup.doSetup();
-
-        try {
-            final URI uri = URI.createFileURI(absPathToTempFile(fixDef, ".fix"));
-            final Resource resource = injector.getInstance(XtextResourceSet.class).getResource(uri, true);
-            final IResourceValidator validator = ((XtextResource) resource).getResourceServiceProvider().getResourceValidator();
-
-            for (final Issue issue : validator.validate(resource, CheckMode.ALL, CancelIndicator.NullImpl)) {
-                System.err.println(issue.getMessage());
-            }
-
-            return (Fix) resource.getContents().get(0);
-        }
-        catch (final IOException e) {
-            e.printStackTrace();
-            return null;
-        }
-    }
-
-    public static String absPathToTempFile(final Reader fixDef, final String suffix) throws IOException {
-        // TODO: avoid temp file creation
-        final File file = File.createTempFile("metafix", suffix);
-        file.deleteOnExit();
-
-        try (FileWriter out = new FileWriter(file)) {
-            CharStreams.copy(fixDef, out);
-        }
-
-        return file.getAbsolutePath();
-    }
-
-    protected List<NamedValueReceiver> getElseSources() {
-        return elseSources;
-    }
-
-    protected void setEntityMarker(final String entityMarker) {
-        flattener.setEntityMarker(entityMarker);
-    }
-
-    protected void setErrorHandler(final MorphErrorHandler errorHandler) {
-        this.errorHandler = errorHandler;
-    }
-
-    protected void registerNamedValueReceiver(final String source, final NamedValueReceiver data) {
-        if (ELSE_NESTED_KEYWORD.equals(source)) {
-            elseNested = true;
-        }
-        if (ELSE_KEYWORD.equals(source) || ELSE_FLATTENED_KEYWORD.equals(source) || elseNested) {
-            if (elseSources.isEmpty()) {
-                elseSources.add(data);
-            }
-            else {
-                System.out.println("Only one of '_else', '_elseFlattened' and '_elseNested' is allowed. Ignoring the superflous ones.");
-            }
-        }
-        else {
-            dataRegistry.register(source, data);
-        }
-    }
-
-    @Override
-    public void startRecord(final String identifier) {
-        buffer.clear();
-        buffer.startRecord(identifier);
-
-        System.out.printf("Start record: %s\n", currentRecord);
-        flattener.startRecord(identifier);
-        entityCountStack.clear();
-
-        entityCount = 0;
-        currentEntityCount = 0;
-        entityCountStack.add(Integer.valueOf(entityCount));
-
-        ++recordCount;
-        recordCount %= Integer.MAX_VALUE;
-
-        if (!recordMode) {
-            outputStreamReceiver.startRecord(identifier);
-        }
-        else if (!needsReplay) {
-            needsReplay = true;
-            currentRecord = HashMultimap.create();
-            outputStreamReceiver.startRecord(identifier);
-        }
-        dispatch(StandardEventNames.ID, identifier, null, false);
-    }
-
-    @Override
-    public void endRecord() {
-        for (final FlushListener listener : recordEndListener) {
-            listener.flush(recordCount, currentEntityCount);
-        }
-
-        entityCountStack.removeLast();
-
-        if (!entityCountStack.isEmpty()) {
-            throw new IllegalStateException(ENTITIES_NOT_BALANCED);
-        }
-
-        flattener.endRecord();
-        buffer.endRecord();
-        if (recordMode && needsReplay) {
-            System.out.printf("End record, replay with: %s\n", currentRecord);
-            new FixBuilder(this, interceptorFactory).walk(fix);
-            buffer.replay();
-            needsReplay = false;
-        }
-        outputStreamReceiver.endRecord();
-    }
-
-    @Override
-    public void startEntity(final String name) {
-        if (name == null) {
-            throw new IllegalArgumentException("Entity name must not be null.");
-        }
-
-        ++entityCount;
-        currentEntityCount = entityCount;
-        entityCountStack.push(Integer.valueOf(entityCount));
-
-        flattener.startEntity(name);
-        buffer.startEntity(name);
-    }
-
-    @Override
-    public void endEntity() {
-        dispatch(flattener.getCurrentPath(), "", getElseSources(), true);
-        currentEntityCount = entityCountStack.pop().intValue();
-        flattener.endEntity();
-        buffer.endEntity();
-    }
-
-    @Override
-    public void literal(final String name, final String value) {
-        currentLiteralName = name;
-        flattener.literal(name, value);
-        buffer.literal(name, value);
-    }
-
-    @Override
-    public void resetStream() {
-        // TODO: Implement proper reset handling
-        outputStreamReceiver.resetStream();
-        buffer.clear();
-    }
-
-    @Override
-    public void closeStream() {
-        for (final Closeable closeable : resources) {
-            try {
-                closeable.close();
-            }
-            catch (final IOException e) {
-                errorHandler.error(e);
-            }
-        }
-
-        outputStreamReceiver.closeStream();
-        buffer.clear();
-    }
-
-    private void dispatch(final String path, final String value, final List<NamedValueReceiver> fallback, final boolean endEntity) {
-        final List<NamedValueReceiver> matchingData = findMatchingData(path, fallback);
-
-        if (matchingData != null) {
-            send(path, value, matchingData);
-        }
-        else if (fallback != null) {
-            if (endEntity) {
-                if (elseNestedEntityStarted) {
-                    outputStreamReceiver.endEntity();
-                    elseNestedEntityStarted = false;
-                }
-            }
-            else {
-                final String entityName = elseNested ? flattener.getCurrentEntityName() : null;
-
-                if (entityName != null) {
-                    if (findMatchingData(entityName, fallback) == null) {
-                        if (!elseNestedEntityStarted) {
-                            outputStreamReceiver.startEntity(entityName);
-                            elseNestedEntityStarted = true;
-                        }
-
-                        send(escapeFeedbackChar(currentLiteralName), value, fallback);
-                    }
-                }
-                else {
-                    send(escapeFeedbackChar(path), value, fallback);
-                }
-            }
-        }
-    }
-
-    private List<NamedValueReceiver> findMatchingData(final String path, final List<NamedValueReceiver> fallback) {
-        final List<NamedValueReceiver> matchingData = dataRegistry.get(path);
-        return matchingData != null && !matchingData.isEmpty() ? matchingData : null;
-    }
-
-    private void send(final String key, final String value, final List<NamedValueReceiver> dataList) {
-        System.out.printf("Sending '%s':'%s' to %s\n", key, value, dataList);
-        currentRecord.put(key, value);
-        for (final NamedValueReceiver data : dataList) {
-            data.receive(key, value, null, recordCount, currentEntityCount);
-        }
-    }
-
-    /**
-     * @param streamReceiver the outputHandler to set
-     */
-    @Override
-    public <R extends StreamReceiver> R setReceiver(final R streamReceiver) {
-        if (streamReceiver == null) {
-            throw new IllegalArgumentException("'streamReceiver' must not be null");
-        }
-
-        outputStreamReceiver = streamReceiver;
-        buffer.setReceiver(this);
-        return streamReceiver;
-    }
-
-    public StreamReceiver getStreamReceiver() {
-        return outputStreamReceiver;
-    }
-
-    @Override
-    public void receive(final String name, final String value, final NamedValueSource source, final int recordCountParam, final int entityCountParam) {
-        if (name == null) {
-            throw new IllegalArgumentException(
-                    "encountered literal with name='null'. This indicates a bug in a function or a collector.");
-        }
-
-        if (startsWithFeedbackChar(name)) {
-            dispatch(name, value, null, false);
-            return;
-        }
-
-        final String unescapedName;
-
-        if (name.length() > 1 && name.charAt(0) == ESCAPE_CHAR && (name.charAt(1) == FEEDBACK_CHAR || name.charAt(1) == ESCAPE_CHAR)) {
-            unescapedName = name.substring(1);
-        }
-        else {
-            unescapedName = name;
-        }
-        outputStreamReceiver.literal(unescapedName, value);
-    }
-
-    private boolean startsWithFeedbackChar(final String name) {
-        return name.length() != 0 && name.charAt(0) == FEEDBACK_CHAR;
-    }
-
-    private String escapeFeedbackChar(final String name) {
-        return name == null ? null : (startsWithFeedbackChar(name) ? ESCAPE_CHAR : "") + name;
-    }
-
-    @Override
-    public Map<String, String> getMap(final String mapName) {
-        return maps.getOrDefault(mapName, Collections.emptyMap());
-    }
-
-    @Override
-    public String getValue(final String mapName, final String key) {
-        final Map<String, String> map = getMap(mapName);
-        return map.containsKey(key) ? map.get(key) : map.get(Maps.DEFAULT_MAP_KEY);
-    }
-
-    @Override
-    public Map<String, String> putMap(final String mapName, final Map<String, String> map) {
-        if (map instanceof Closeable) {
-            final Closeable closable = (Closeable) map;
-            resources.add(closable);
-        }
-
-        return maps.put(mapName, map);
-    }
-
-    @Override
-    public String putValue(final String mapName, final String key, final String value) {
-        return maps.computeIfAbsent(mapName, k -> new HashMap<>()).put(key, value);
-    }
-
-    @Override
-    public Collection<String> getMapNames() {
-        return Collections.unmodifiableSet(maps.keySet());
-    }
-
-    public void registerRecordEndFlush(final FlushListener flushListener) {
-        recordEndListener.add(flushListener);
-    }
-
-    @Override
-    public void addNamedValueSource(final NamedValueSource namedValueSource) {
-        namedValueSource.setNamedValueReceiver(this);
-    }
-
-    @Override
-    public void setNamedValueReceiver(final NamedValueReceiver receiver) {
-        throw new UnsupportedOperationException("The Metafix object cannot act as a NamedValueSender");
-    }
-
-    @Override
-    public void setSourceLocation(final SourceLocation sourceLocation) {
-        // Nothing to do
-        // Metafix does not have a source location (we could
-        // in theory use the location of the module in a flux
-        // script)
-    }
-
-    @Override
-    public SourceLocation getSourceLocation() {
-        // Metafix does not have a source location
-        return null;
-    }
-
-    public Map<String, String> getVars() {
-        return vars;
-    }
-
-    public Multimap<String, String> getCurrentRecord() {
-        return currentRecord;
-    }
-
-    public void setRecordMode(final boolean recordMode) {
-        this.recordMode = recordMode;
-    }
-
-    public boolean isRecordMode() {
-        return recordMode;
-    }
-
-}
diff --git a/org.metafacture.fix/src/main/java/org/metafacture/metamorph/MetafixFilter.java b/org.metafacture.fix/src/main/java/org/metafacture/metamorph/MetafixFilter.java
deleted file mode 100644
index 667507b5..00000000
--- a/org.metafacture.fix/src/main/java/org/metafacture/metamorph/MetafixFilter.java
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
- * Copyright 2013, 2021 Deutsche Nationalbibliothek and others
- *
- * 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.metamorph;
-
-import org.metafacture.flowcontrol.StreamBuffer;
-import org.metafacture.framework.FluxCommand;
-import org.metafacture.framework.StreamReceiver;
-import org.metafacture.framework.annotations.Description;
-import org.metafacture.framework.annotations.In;
-import org.metafacture.framework.annotations.Out;
-import org.metafacture.framework.helpers.DefaultStreamPipe;
-import org.metafacture.javaintegration.SingleValue;
-import org.metafacture.metamorph.api.InterceptorFactory;
-
-import java.io.FileNotFoundException;
-import java.util.Map;
-
-/**
- * Filters a stream based on a fix definition. A record is accepted if the
- * morph returns at least one non empty value.
- *
- * @author Markus Michael Geipel
- * @author Fabian Steeg, hbz (adapted for Metafix)
- *
- */
-@Description("Filters a stream based on a fix definition. A record is accepted if the fix returns at least one non empty value.")
-@In(StreamReceiver.class)
-@Out(StreamReceiver.class)
-@FluxCommand("fix-filter")
-public final class MetafixFilter extends DefaultStreamPipe<StreamReceiver> {
-
-    private final StreamBuffer buffer = new StreamBuffer();
-    private final SingleValue singleValue = new SingleValue();
-    private final Metafix metafix;
-
-    public MetafixFilter(final String morphDef) throws FileNotFoundException {
-        metafix = new Metafix(morphDef);
-        metafix.setReceiver(singleValue);
-    }
-
-    public MetafixFilter(final Metafix metamorph) {
-        this.metafix = metamorph;
-        metamorph.setReceiver(singleValue);
-    }
-
-    public MetafixFilter(final String morphDef, final Map<String, String> vars) throws FileNotFoundException {
-        metafix = new Metafix(morphDef, vars);
-        metafix.setReceiver(singleValue);
-    }
-
-    public MetafixFilter(final String morphDef, final InterceptorFactory interceptorFactory) throws FileNotFoundException {
-        metafix = new Metafix(morphDef, interceptorFactory);
-        metafix.setReceiver(singleValue);
-    }
-
-    @Override
-    protected void onSetReceiver() {
-        buffer.setReceiver(getReceiver());
-    }
-
-    private void dispatch() {
-        final String key = singleValue.getValue();
-        if (!key.isEmpty()) {
-            buffer.replay();
-        }
-        buffer.clear();
-    }
-
-    @Override
-    public void startRecord(final String identifier) {
-        buffer.startRecord(identifier);
-        metafix.startRecord(identifier);
-    }
-
-    @Override
-    public void endRecord() {
-        buffer.endRecord();
-        metafix.endRecord();
-        dispatch();
-    }
-
-    @Override
-    public void startEntity(final String name) {
-        buffer.startEntity(name);
-        metafix.startEntity(name);
-    }
-
-    @Override
-    public void endEntity() {
-        buffer.endEntity();
-        metafix.endEntity();
-    }
-
-    @Override
-    public void literal(final String name, final String value) {
-        buffer.literal(name, value);
-        metafix.literal(name, value);
-    }
-
-    @Override
-    protected void onResetStream() {
-        buffer.clear();
-        metafix.resetStream();
-    }
-
-    @Override
-    protected void onCloseStream() {
-        buffer.clear();
-        metafix.closeStream();
-    }
-}
diff --git a/org.metafacture.fix/src/main/resources/flux-commands.properties b/org.metafacture.fix/src/main/resources/flux-commands.properties
index f765ad3c..1659127a 100644
--- a/org.metafacture.fix/src/main/resources/flux-commands.properties
+++ b/org.metafacture.fix/src/main/resources/flux-commands.properties
@@ -12,5 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-fix org.metafacture.metamorph.Metafix
-fix-filter org.metafacture.metamorph.MetafixFilter
+fix org.metafacture.metafix.Metafix
diff --git a/org.metafacture.fix/src/test/java/org/metafacture/fix/tests/FixParsingTest.java b/org.metafacture.fix/src/test/java/org/metafacture/metafix/FixParsingTest.java
similarity index 96%
rename from org.metafacture.fix/src/test/java/org/metafacture/fix/tests/FixParsingTest.java
rename to org.metafacture.fix/src/test/java/org/metafacture/metafix/FixParsingTest.java
index e4bb4a25..60397ff0 100644
--- a/org.metafacture.fix/src/test/java/org/metafacture/fix/tests/FixParsingTest.java
+++ b/org.metafacture.fix/src/test/java/org/metafacture/metafix/FixParsingTest.java
@@ -1,6 +1,7 @@
-package org.metafacture.fix.tests;
+package org.metafacture.metafix;
 
-import org.metafacture.fix.fix.Fix;
+import org.metafacture.metafix.fix.Fix;
+import org.metafacture.metafix.tests.FixInjectorProvider;
 
 import com.google.inject.Inject;
 import org.eclipse.emf.common.util.EList;
diff --git a/org.metafacture.fix/src/test/java/org/metafacture/fix/tests/InterpreterTest.java b/org.metafacture.fix/src/test/java/org/metafacture/metafix/InterpreterTest.java
similarity index 85%
rename from org.metafacture.fix/src/test/java/org/metafacture/fix/tests/InterpreterTest.java
rename to org.metafacture.fix/src/test/java/org/metafacture/metafix/InterpreterTest.java
index ed8e3ffe..588452f7 100644
--- a/org.metafacture.fix/src/test/java/org/metafacture/fix/tests/InterpreterTest.java
+++ b/org.metafacture.fix/src/test/java/org/metafacture/metafix/InterpreterTest.java
@@ -1,8 +1,8 @@
-package org.metafacture.fix.tests;
+package org.metafacture.metafix;
 
-import org.metafacture.fix.fix.Fix;
-import org.metafacture.fix.interpreter.FixInterpreter;
-import org.metafacture.metamorph.Metafix;
+import org.metafacture.metafix.fix.Fix;
+import org.metafacture.metafix.interpreter.FixInterpreter;
+import org.metafacture.metafix.tests.FixInjectorProvider;
 
 import com.google.inject.Inject;
 import org.eclipse.xtext.testing.InjectWith;
@@ -37,8 +37,9 @@ public void shouldInterpretSimple() throws Exception {
     }
 
     @Test
+    @SuppressWarnings("checkstyle:MagicNumber")
     public void shouldInterpretNested() throws Exception {
-        interpret(3, // checkstyle-disable-line MagicNumber
+        interpret(3,
                 "do marc_each()",
                 "\tif marc_has(f700)",
                 "\t\tmarc_map(f700a,authors.$append)",
diff --git a/org.metafacture.fix/src/test/java/org/metafacture/metamorph/MetafixIfTest.java b/org.metafacture.fix/src/test/java/org/metafacture/metafix/MetafixBindTest.java
similarity index 54%
rename from org.metafacture.fix/src/test/java/org/metafacture/metamorph/MetafixIfTest.java
rename to org.metafacture.fix/src/test/java/org/metafacture/metafix/MetafixBindTest.java
index 98868eee..b55e81ea 100644
--- a/org.metafacture.fix/src/test/java/org/metafacture/metamorph/MetafixIfTest.java
+++ b/org.metafacture.fix/src/test/java/org/metafacture/metafix/MetafixBindTest.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.metafacture.metamorph;
+package org.metafacture.metafix;
 
 import org.metafacture.framework.StreamReceiver;
 
@@ -30,15 +30,13 @@
 import java.util.Arrays;
 
 /**
- * Tests the `if` Metamorph mechanism adapted for Metafix via DSL.
- *
- * See https://github.com/metafacture/metafacture-fix/issues/10
+ * Test Metafix binds.
  *
  * @author Fabian Steeg
  */
 @ExtendWith(MockitoExtension.class)
 @SuppressWarnings("checkstyle:MultipleStringLiterals")
-public class MetafixIfTest {
+public class MetafixBindTest {
 
     @RegisterExtension
     private MockitoRule mockitoRule = MockitoJUnit.rule();
@@ -46,145 +44,241 @@ public class MetafixIfTest {
     @Mock
     private StreamReceiver streamReceiver;
 
-    public MetafixIfTest() {
+    public MetafixBindTest() {
     }
 
     @Test
-    public void ifTopLevel() {
-        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(//
-                "map('name')",
-                "if contains('name', 'University')", //
-                "  add_field('type', 'Organization')", //
-                "end"), //
+    public void doList() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "do list('path': 'name', 'var': 'n')",
+                " upcase('n')",
+                " trim('n')",
+                " copy_field('n', 'author')",
+                "end",
+                "remove_field('name')"),
             i -> {
                 i.startRecord("1");
-                i.literal("name", "A University");
+                i.literal("name", " A University");
+                i.literal("name", "Max ");
                 i.endRecord();
             }, o -> {
                 o.get().startRecord("1");
-                o.get().literal("name", "A University");
-                o.get().literal("type", "Organization");
+                o.get().startEntity("author[]");
+                o.get().literal("1", "A UNIVERSITY");
+                o.get().literal("2", "MAX");
+                o.get().endEntity();
                 o.get().endRecord();
             });
     }
 
     @Test
-    public void ifTopLevelWithEqualsFunction() {
-        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(//
-                "if equals('name', 'University')", //
-                "  add_field('type', 'Organization')", //
-                "end", //
-                "map('name')"),
+    public void doListPathWithDots() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "do list('path': 'some.name', 'var': 'n')",
+                " upcase('n')",
+                " trim('n')",
+                " copy_field('n', 'author')",
+                "end",
+                "remove_field('some')"),
             i -> {
                 i.startRecord("1");
-                i.literal("name", "University");
+                i.startEntity("some");
+                i.literal("name", " A University");
+                i.literal("name", "Max ");
+                i.endEntity();
                 i.endRecord();
             }, o -> {
                 o.get().startRecord("1");
-                o.get().literal("name", "University");
-                o.get().literal("type", "Organization");
+                o.get().startEntity("author[]");
+                o.get().literal("1", "A UNIVERSITY");
+                o.get().literal("2", "MAX");
+                o.get().endEntity();
                 o.get().endRecord();
             });
     }
 
     @Test
-    public void ifInCollector() {
-        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(//
-                "do entity('author')",
-                " map('name')",
-                " if contains('name', 'University')", //
-                "  add_field('type', 'Organization')", //
-                " end",
-                "end"), //
+    public void doListWithAppendAndLast() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "do list('path': 'creator', 'var': 'c')",
+                " set_array('author')",
+                " copy_field('c.name', 'author.$append.name')",
+                " add_field('author.$last.type', 'Default')",
+                "end",
+                "remove_field('creator')"),
             i -> {
                 i.startRecord("1");
+                i.startEntity("creator");
                 i.literal("name", "A University");
+                i.endEntity();
+                i.startEntity("creator");
+                i.literal("name", "Max");
+                i.endEntity();
                 i.endRecord();
-            }, o -> {
+            }, (o, f) -> {
                 o.get().startRecord("1");
-                o.get().startEntity("author");
-                o.get().literal("type", "Organization");
+                o.get().startEntity("author[]");
+                o.get().startEntity("");
                 o.get().literal("name", "A University");
+                // o.get().literal("type", "Default"); // FIXME: bind scope broken
                 o.get().endEntity();
+                o.get().startEntity("");
+                o.get().literal("name", "Max");
+                o.get().literal("type", "Default");
+                f.apply(2).endEntity();
                 o.get().endRecord();
             });
     }
 
     @Test
-    public void ifTopLevelMultiRecords() {
-        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(//
-                "map('name')",
-                "if contains('name', 'University')", //
-                "  add_field('type', 'Organization')", //
-                "end"), //
+    public void doListEntitesToLiterals() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "do list('path': 'creator', 'var': 'c')",
+                " upcase('c.name')",
+                " trim('c.name')",
+                " copy_field('c.name', 'author')",
+                "end",
+                "remove_field('creator')"),
             i -> {
                 i.startRecord("1");
-                i.literal("name", "Max");
-                i.endRecord();
-                i.startRecord("2");
-                i.literal("name", "A University");
-                i.endRecord();
-                i.startRecord("3");
-                i.literal("name", "Mary");
+                i.startEntity("creator");
+                i.literal("name", " A University");
+                i.endEntity();
+                i.startEntity("creator");
+                i.literal("name", "Max ");
+                i.endEntity();
                 i.endRecord();
             }, o -> {
                 o.get().startRecord("1");
-                o.get().literal("name", "Max");
+                o.get().startEntity("author[]");
+                o.get().literal("1", "A UNIVERSITY");
+                o.get().literal("2", "MAX");
+                o.get().endEntity();
                 o.get().endRecord();
-                o.get().startRecord("2");
+            });
+    }
+
+    @Test
+    public void doListEntitesToEntities() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "do list('path': 'creator.name', 'var': 'c')",
+                " set_array('author')",
+                " copy_field('c', 'author.$append.name')",
+                " if all_contain('c', 'University')",
+                "  add_field('author.$last.type', 'Organization')",
+                " else",
+                "  add_field('author.$last.type', 'Person')", //",
+                " end",
+                "end",
+                "remove_field('creator')"),
+            i -> {
+                i.startRecord("1");
+                i.startEntity("creator");
+                i.literal("name", "A University");
+                i.endEntity();
+                i.startEntity("creator");
+                i.literal("name", "Max");
+                i.endEntity();
+                i.endRecord();
+            }, (o, f) -> {
+                o.get().startRecord("1");
+                o.get().startEntity("author[]");
+                o.get().startEntity("");
                 o.get().literal("name", "A University");
                 o.get().literal("type", "Organization");
-                o.get().endRecord();
-                o.get().startRecord("3");
-                o.get().literal("name", "Mary");
+                o.get().endEntity();
+                o.get().startEntity("");
+                o.get().literal("name", "Max");
+                o.get().literal("type", "Person");
+                f.apply(2).endEntity();
                 o.get().endRecord();
             });
     }
 
     @Test
-    public void ifTopLevelMultiRecordsMapField() {
-        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(//
-                "if contains('name', 'University')", //
-                "  map('name', 'orgName')", //
-                "end"), //
+    @Disabled("TODO: how to handle repeated entities: turn to array vs. merge because it's the same?")
+    public void doListEntitesWithFieldsToEntities() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "do list('path': 'creator', 'var': 'c')",
+                " set_array('author')",
+                " copy_field('c.name', 'author.$append.name')",
+                " if all_contain('c.type', 'corporate')",
+                "  add_field('author.$last.type', 'Organization')",
+                " end",
+                " if all_contain('c.type', 'personal')",
+                "  add_field('author.$last.type', 'Person')", //",
+                " end",
+                "end",
+                "remove_field('creator')"),
             i -> {
                 i.startRecord("1");
+                i.startEntity("creator");
+                i.literal("name", "A University");
+                i.literal("type", "corporate");
+                i.endEntity();
+                i.startEntity("creator");
                 i.literal("name", "Max");
+                i.literal("type", "personal");
+                i.endEntity();
                 i.endRecord();
-                i.startRecord("2");
+            }, (o, f) -> {
+                o.get().startRecord("1");
+                o.get().startEntity("author[]");
+                o.get().startEntity("");
+                o.get().literal("name", "A University");
+                o.get().literal("type", "Organization");
+                o.get().endEntity();
+                o.get().startEntity("");
+                o.get().literal("name", "Max");
+                o.get().literal("type", "Person");
+                f.apply(2).endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    @Disabled("implement Fix-style binds with collectors?")
+    public void ifInCollector() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "do entity('author')",
+                " map('name')",
+                " if all_contain('name', 'University')",
+                "  add_field('type', 'Organization')",
+                " end",
+                "end"),
+            i -> {
+                i.startRecord("1");
                 i.literal("name", "A University");
                 i.endRecord();
-                i.startRecord("3");
-                i.literal("name", "Mary");
-                i.endRecord();
             }, o -> {
                 o.get().startRecord("1");
-                o.get().endRecord();
-                o.get().startRecord("2");
-                o.get().literal("orgName", "A University");
-                o.get().endRecord();
-                o.get().startRecord("3");
+                o.get().startEntity("author");
+                o.get().literal("type", "Organization");
+                o.get().literal("name", "A University");
+                o.get().endEntity();
                 o.get().endRecord();
             });
     }
 
     @Test
-    @Disabled // TODO: in collector, `map` not firing when `if` fails
+    @Disabled("implement Fix-style binds with collectors?")
     public void ifInCollectorMultiRecords() {
-        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(//
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
                 "do entity('author')",
                 " map('name')",
-                " if contains('name', 'University')", //
-                "  add_field('type', 'Organization')", //
+                " if all_contain('name', 'University')",
+                "  add_field('type', 'Organization')",
                 " end",
-                "end"), //
+                "end"),
             i -> {
                 i.startRecord("1");
                 i.literal("name", "Max");
                 i.endRecord();
+
                 i.startRecord("2");
                 i.literal("name", "A University");
                 i.endRecord();
+
                 i.startRecord("3");
                 i.literal("name", "Mary");
                 i.endRecord();
@@ -194,12 +288,14 @@ public void ifInCollectorMultiRecords() {
                 o.get().literal("name", "Max");
                 o.get().endEntity();
                 o.get().endRecord();
+
                 o.get().startRecord("2");
                 o.get().startEntity("author");
                 o.get().literal("type", "Organization");
                 o.get().literal("name", "A University");
                 o.get().endEntity();
                 o.get().endRecord();
+
                 o.get().startRecord("3");
                 o.get().startEntity("author");
                 o.get().literal("name", "Mary");
@@ -209,43 +305,19 @@ public void ifInCollectorMultiRecords() {
     }
 
     @Test
-    // Without `entity`, but nested.entity.syntax: two entities, same name
-    public void mapAndTestNestedTwoEntities() {
-        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(//
-                "map('name', 'author.name')",
-                "if contains('name', 'University')", //
-                " add_field('author.type', 'Organization')", //
-                "end"), //
-            i -> {
-                i.startRecord("1");
-                i.literal("name", "A University");
-                i.endRecord();
-            }, o -> {
-                o.get().startRecord("1");
-                o.get().startEntity("author");
-                o.get().literal("type", "Organization");
-                o.get().endEntity();
-                o.get().startEntity("author");
-                o.get().literal("name", "A University");
-                o.get().endEntity();
-                o.get().endRecord();
-            });
-    }
-
-    @Test
-    // Top-level `if` constructs internally wrap a choose collector:
+    @Disabled("implement Fix-style binds with collectors?")
     public void ifInCollectorChoose() {
-        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(//
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
                 "do choose(flushWith: 'record')",
-                " if contains('name', 'University')", //
-                "  add_field('type', 'Organization')", //
-                " end", //
-                "end"), //
+                " if all_contain('name', 'University')",
+                "  add_field('type', 'Organization')",
+                " end",
+                "end"),
             i -> {
                 i.startRecord("1");
                 i.literal("name", "Max University");
                 i.endRecord();
-                //
+
                 i.startRecord("2");
                 i.literal("name", "Max Musterman");
                 i.endRecord();
@@ -253,28 +325,29 @@ public void ifInCollectorChoose() {
                 o.get().startRecord("1");
                 o.get().literal("type", "Organization");
                 o.get().endRecord();
-                //
+
                 o.get().startRecord("2");
                 o.get().endRecord();
             });
     }
 
     @Test
+    @Disabled("implement Fix-style binds with collectors?")
     public void ifInCollectorCombine() {
-        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(//
-                "do combine(name: 'fullName', value: '${first} ${last}')", //
-                " if contains('author.type', 'Person')", //
-                "  map('author.first', 'first')", //
-                "  map('author.last', 'last')", //
-                " end", //
-                "end"), //
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "do combine(name: 'fullName', value: '${first} ${last}')",
+                " if all_contain('author.type', 'Person')",
+                "  map('author.first', 'first')",
+                "  map('author.last', 'last')",
+                " end",
+                "end"),
             i -> {
                 i.startRecord("1");
                 i.startEntity("author");
                 i.literal("type", "Organization");
                 i.endEntity();
                 i.endRecord();
-                //
+
                 i.startRecord("2");
                 i.startEntity("author");
                 i.literal("first", "Max");
@@ -285,33 +358,11 @@ public void ifInCollectorCombine() {
             }, o -> {
                 o.get().startRecord("1");
                 o.get().endRecord();
-                //
+
                 o.get().startRecord("2");
                 o.get().literal("fullName", "Max Musterman");
                 o.get().endRecord();
             });
     }
 
-    @Test
-    @Disabled // TODO: second `add_field` not firing
-    public void ifTopLevelMultipleAddField() {
-        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(//
-                "map('name')",
-                "if contains('name', 'University')", //
-                "  add_field('type', 'Organization')", //
-                "  add_field('comment', 'type was guessed')", //
-                "end"), //
-            i -> {
-                i.startRecord("1");
-                i.literal("name", "A University");
-                i.endRecord();
-            }, o -> {
-                o.get().startRecord("1");
-                o.get().literal("name", "A University");
-                o.get().literal("type", "Organization");
-                o.get().literal("comment", "type was guessed");
-                o.get().endRecord();
-            });
-    }
-
 }
diff --git a/org.metafacture.fix/src/test/java/org/metafacture/metafix/MetafixIfTest.java b/org.metafacture.fix/src/test/java/org/metafacture/metafix/MetafixIfTest.java
new file mode 100644
index 00000000..52da1754
--- /dev/null
+++ b/org.metafacture.fix/src/test/java/org/metafacture/metafix/MetafixIfTest.java
@@ -0,0 +1,520 @@
+/*
+ * Copyright 2021 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.metafix;
+
+import org.metafacture.framework.StreamReceiver;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.Arrays;
+
+/**
+ * Test Metafix `if` conditionals.
+ *
+ * @author Fabian Steeg
+ */
+@ExtendWith(MockitoExtension.class)
+@SuppressWarnings("checkstyle:MultipleStringLiterals")
+public class MetafixIfTest {
+
+    @RegisterExtension
+    private MockitoRule mockitoRule = MockitoJUnit.rule();
+
+    @Mock
+    private StreamReceiver streamReceiver;
+
+    public MetafixIfTest() {
+    }
+
+    @Test
+    public void ifAny() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "if any_contain('name', 'University')",
+                "  add_field('type', 'Organization')",
+                "end"),
+            i -> {
+                i.startRecord("1");
+                i.literal("name", "Mary");
+                i.literal("name", "A University");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.literal("name", "Mary");
+                i.literal("name", "Max");
+                i.endRecord();
+
+                i.startRecord("3");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().startEntity("name[]");
+                o.get().literal("1", "Mary");
+                o.get().literal("2", "A University");
+                o.get().endEntity();
+                o.get().literal("type", "Organization");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().startEntity("name[]");
+                o.get().literal("1", "Mary");
+                o.get().literal("2", "Max");
+                o.get().endEntity();
+                o.get().endRecord();
+
+                o.get().startRecord("3");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void ifAll() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "if all_contain('name', 'University')",
+                "  add_field('type', 'Organization')",
+                "end"),
+            i -> {
+                i.startRecord("1");
+                i.literal("name", "Mary");
+                i.literal("name", "A University");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.literal("name", "Great University");
+                i.literal("name", "A University");
+                i.endRecord();
+
+                i.startRecord("3");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().startEntity("name[]");
+                o.get().literal("1", "Mary");
+                o.get().literal("2", "A University");
+                o.get().endEntity();
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().startEntity("name[]");
+                o.get().literal("1", "Great University");
+                o.get().literal("2", "A University");
+                o.get().endEntity();
+                o.get().literal("type", "Organization");
+                o.get().endRecord();
+
+                o.get().startRecord("3");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    @SuppressWarnings("checkstyle:ExecutableStatementCount")
+    public void ifNone() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "if none_contain('author.name', 'University')",
+                "  add_field('type', 'Person')",
+                "end"),
+            i -> {
+                i.startRecord("1");
+                i.startEntity("author");
+                i.literal("name", "Mary");
+                i.literal("name", "A University");
+                i.endEntity();
+                i.endRecord();
+
+                i.startRecord("2");
+                i.startEntity("author");
+                i.literal("name", "Max");
+                i.literal("name", "Mary");
+                i.endEntity();
+                i.endRecord();
+
+                i.startRecord("3");
+                i.endRecord();
+            }, (o, f) -> {
+                o.get().startRecord("1");
+                o.get().startEntity("author");
+                o.get().startEntity("name[]");
+                o.get().literal("1", "Mary");
+                o.get().literal("2", "A University");
+                f.apply(2).endEntity();
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().startEntity("author");
+                o.get().startEntity("name[]");
+                o.get().literal("1", "Max");
+                o.get().literal("2", "Mary");
+                f.apply(2).endEntity();
+                o.get().literal("type", "Person");
+                o.get().endRecord();
+
+                o.get().startRecord("3");
+                o.get().literal("type", "Person");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void ifEqual() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "if all_equal('name', 'University')",
+                "  add_field('type', 'Organization')",
+                "end"),
+            i -> {
+                i.startRecord("1");
+                i.literal("name", "University");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().literal("name", "University");
+                o.get().literal("type", "Organization");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void ifContainMoveField() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "if all_contain('name', 'University')",
+                "  move_field('name', 'orgName')",
+                "end"),
+            i -> {
+                i.startRecord("1");
+                i.literal("name", "Max");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.literal("name", "A University");
+                i.endRecord();
+
+                i.startRecord("3");
+                i.literal("name", "Mary");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().literal("name", "Max");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().literal("orgName", "A University");
+                o.get().endRecord();
+
+                o.get().startRecord("3");
+                o.get().literal("name", "Mary");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void moveAndAddIfContain() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(// TODO: dot notation in contain etc.
+                "move_field('name', 'author.name')",
+                "if all_contain('author.name', 'University')",
+                " add_field('author.type', 'Organization')",
+                "end"),
+            i -> {
+                i.startRecord("1");
+                i.literal("name", "A University");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().startEntity("author");
+                o.get().literal("name", "A University");
+                o.get().literal("type", "Organization");
+                o.get().endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void ifContainMultipleAddField() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "if all_contain('name', 'University')",
+                "  add_field('type', 'Organization')",
+                "  add_field('comment', 'type was guessed')",
+                "end"),
+            i -> {
+                i.startRecord("1");
+                i.literal("name", "A University");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().literal("name", "A University");
+                o.get().literal("type", "Organization");
+                o.get().literal("comment", "type was guessed");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void ifAnyMatch() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "if any_match('name', '.*University.*')",
+                "  add_field('type', 'Organization')",
+                "end"),
+            i -> {
+                i.startRecord("1");
+                i.literal("name", "Max");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.literal("name", "Some University");
+                i.literal("name", "Filibandrina");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().literal("name", "Max");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().startEntity("name[]");
+                o.get().literal("1", "Some University");
+                o.get().literal("2", "Filibandrina");
+                o.get().endEntity();
+                o.get().literal("type", "Organization");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void ifAllMatch() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "if all_match('name', '.*University.*')",
+                "  add_field('type', 'Organization')",
+                "end"),
+            i -> {
+                i.startRecord("1");
+                i.literal("name", "Max");
+                i.literal("name", "A University");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.literal("name", "Some University");
+                i.literal("name", "University Filibandrina");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().startEntity("name[]");
+                o.get().literal("1", "Max");
+                o.get().literal("2", "A University");
+                o.get().endEntity();
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().startEntity("name[]");
+                o.get().literal("1", "Some University");
+                o.get().literal("2", "University Filibandrina");
+                o.get().endEntity();
+                o.get().literal("type", "Organization");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void ifAnyMatchNested() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(// TODO: dot notation in match etc.
+                "if any_match('author.name.label', '.*University.*')",
+                "  add_field('author.type', 'Organization')",
+                "end"),
+            i -> {
+                i.startRecord("1");
+                i.startEntity("author");
+                i.startEntity("name");
+                i.literal("label", "Max");
+                i.endEntity();
+                i.endEntity();
+                i.endRecord();
+
+                i.startRecord("2");
+                i.startEntity("author");
+                i.startEntity("name");
+                i.literal("label", "Some University");
+                i.endEntity();
+                i.endEntity();
+                i.endRecord();
+            }, (o, f) -> {
+                o.get().startRecord("1");
+                o.get().startEntity("author");
+                o.get().startEntity("name");
+                o.get().literal("label", "Max");
+                f.apply(2).endEntity();
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().startEntity("author");
+                o.get().startEntity("name");
+                o.get().literal("label", "Some University");
+                o.get().endEntity();
+                o.get().literal("type", "Organization");
+                o.get().endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void ifAnyMatchFirstRecord() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "if any_match('name', '.*University.*')",
+                "  add_field('type', 'Organization')",
+                "end"),
+            i -> {
+                i.startRecord("1");
+                i.literal("name", "Some University");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.literal("name", "Max");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().literal("name", "Some University");
+                o.get().literal("type", "Organization");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().literal("name", "Max");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void ifAnyMatchLastRecord() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "if any_match('name', '.*University.*')",
+                "  add_field('type', 'Organization')",
+                "end"),
+            i -> {
+                i.startRecord("1");
+                i.literal("name", "Max");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.literal("name", "Some University");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().literal("name", "Max");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().literal("name", "Some University");
+                o.get().literal("type", "Organization");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void unlessAnyMatch() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "unless any_match('name', '.*University.*')",
+                "  add_field('type', 'Person')",
+                "end"),
+            i -> {
+                i.startRecord("1");
+                i.literal("name", "Max");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.literal("name", "Some University");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().literal("name", "Max");
+                o.get().literal("type", "Person");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().literal("name", "Some University");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void ifAnyMatchElse() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "if any_match('name', '.*University.*')",
+                "  add_field('type', 'Organization')",
+                "else",
+                "  add_field('type', 'Person')",
+                "end"),
+            i -> {
+                i.startRecord("1");
+                i.literal("name", "Max");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.literal("name", "Some University");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().literal("name", "Max");
+                o.get().literal("type", "Person");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().literal("name", "Some University");
+                o.get().literal("type", "Organization");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void ifAnyMatchElsif() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "if any_match('name', '.*University.*')",
+                "  add_field('type', 'Organization')",
+                "elsif any_match('name', '[^ ]* [^ ]*')",
+                "  add_field('type', 'Person')",
+                "else",
+                "  add_field('type', 'Unknown')",
+                "end"),
+            i -> {
+                i.startRecord("1");
+                i.literal("name", "Max Power");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.literal("name", "Some University");
+                i.endRecord();
+
+                i.startRecord("3");
+                i.literal("name", "Filibandrina");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().literal("name", "Max Power");
+                o.get().literal("type", "Person");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().literal("name", "Some University");
+                o.get().literal("type", "Organization");
+                o.get().endRecord();
+
+                o.get().startRecord("3");
+                o.get().literal("name", "Filibandrina");
+                o.get().literal("type", "Unknown");
+                o.get().endRecord();
+            });
+    }
+}
diff --git a/org.metafacture.fix/src/test/java/org/metafacture/metafix/MetafixLookupTest.java b/org.metafacture.fix/src/test/java/org/metafacture/metafix/MetafixLookupTest.java
new file mode 100644
index 00000000..967c4585
--- /dev/null
+++ b/org.metafacture.fix/src/test/java/org/metafacture/metafix/MetafixLookupTest.java
@@ -0,0 +1,173 @@
+/*
+ * Copyright 2021 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.metafix;
+
+import org.metafacture.framework.StreamReceiver;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.Arrays;
+
+/**
+ * Tests Metafix lookup. Following the cheat sheet examples at
+ * https://github.com/LibreCat/Catmandu/wiki/Fixes-Cheat-Sheet
+ *
+ * @author Fabian Steeg
+ */
+@ExtendWith(MockitoExtension.class)
+@SuppressWarnings("checkstyle:MultipleStringLiterals")
+public class MetafixLookupTest {
+
+    @RegisterExtension
+    private MockitoRule mockitoRule = MockitoJUnit.rule();
+
+    @Mock
+    private StreamReceiver streamReceiver;
+
+    public MetafixLookupTest() {
+    }
+
+    @Test
+    public void inline() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "lookup('title', Aloha: Alohaeha, 'Moin': 'Moin zäme', __default: Tach)"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.literal("title", "Aloha");
+                i.literal("title", "Moin");
+                i.literal("title", "Hey");
+                i.endRecord();
+
+                i.startRecord("3");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().startEntity("title[]");
+                o.get().literal("1", "Alohaeha");
+                o.get().literal("2", "Moin zäme");
+                o.get().literal("3", "Tach");
+                o.get().endEntity();
+                o.get().endRecord();
+
+                o.get().startRecord("3");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void inlineDotNotationNested() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "lookup('data.title', Aloha: Alohaeha, 'Moin': 'Moin zäme', __default: Tach)"),
+            i -> {
+                i.startRecord("1");
+                i.startEntity("data");
+                i.literal("title", "Aloha");
+                i.literal("title", "Moin");
+                i.literal("title", "Hey");
+                i.endEntity();
+                i.endRecord();
+            }, (o, f) -> {
+                o.get().startRecord("1");
+                o.get().startEntity("data");
+                o.get().startEntity("title[]");
+                o.get().literal("1", "Alohaeha");
+                o.get().literal("2", "Moin zäme");
+                o.get().literal("3", "Tach");
+                f.apply(2).endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void csv() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "lookup('title', 'src/test/java/org/metafacture/metafix/maps/test.csv')"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+
+                i.startRecord("2");
+
+                i.literal("title", "Aloha");
+                i.literal("title", "Moin");
+                i.literal("title", "Hey");
+                i.endRecord();
+
+                i.startRecord("3");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().startEntity("title[]");
+                o.get().literal("1", "Alohaeha");
+                o.get().literal("2", "Moin zäme");
+                o.get().literal("3", "Tach");
+                o.get().endEntity();
+                o.get().endRecord();
+
+                o.get().startRecord("3");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void tsv() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "lookup('title', 'src/test/java/org/metafacture/metafix/maps/test.tsv', sep_char:'\t')"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.literal("title", "Aloha");
+                i.literal("title", "Moin");
+                i.literal("title", "Hey");
+                i.endRecord();
+
+                i.startRecord("3");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().startEntity("title[]");
+                o.get().literal("1", "Alohaeha");
+                o.get().literal("2", "Moin zäme");
+                o.get().literal("3", "Tach");
+                o.get().endEntity();
+                o.get().endRecord();
+
+                o.get().startRecord("3");
+                o.get().endRecord();
+            });
+    }
+}
diff --git a/org.metafacture.fix/src/test/java/org/metafacture/metafix/MetafixMethodTest.java b/org.metafacture.fix/src/test/java/org/metafacture/metafix/MetafixMethodTest.java
new file mode 100644
index 00000000..2469f9d9
--- /dev/null
+++ b/org.metafacture.fix/src/test/java/org/metafacture/metafix/MetafixMethodTest.java
@@ -0,0 +1,485 @@
+/*
+ * Copyright 2021 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.metafix;
+
+import org.metafacture.framework.MetafactureException;
+import org.metafacture.framework.StreamReceiver;
+
+import com.google.common.collect.ImmutableMap;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.Arrays;
+
+/**
+ * Tests Metafix field level methods. Following the cheat sheet examples at
+ * https://github.com/LibreCat/Catmandu/wiki/Fixes-Cheat-Sheet
+ *
+ * @author Fabian Steeg
+ */
+@ExtendWith(MockitoExtension.class)
+@SuppressWarnings("checkstyle:MultipleStringLiterals")
+public class MetafixMethodTest {
+
+    @RegisterExtension
+    private MockitoRule mockitoRule = MockitoJUnit.rule();
+
+    @Mock
+    private StreamReceiver streamReceiver;
+
+    public MetafixMethodTest() {
+    }
+
+    @Test
+    public void upcase() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "upcase('title')"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.literal("title", "marc");
+                i.literal("title", "json");
+                i.endRecord();
+
+                i.startRecord("3");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().startEntity("title[]");
+                o.get().literal("1", "MARC");
+                o.get().literal("2", "JSON");
+                o.get().endEntity();
+                o.get().endRecord();
+
+                o.get().startRecord("3");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void upcaseDotNotationNested() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "upcase('data.title')"),
+            i -> {
+                i.startRecord("1");
+                i.startEntity("data");
+                i.literal("title", "marc");
+                i.literal("title", "json");
+                i.endEntity();
+                i.endRecord();
+            }, (o, f) -> {
+                o.get().startRecord("1");
+                o.get().startEntity("data");
+                o.get().startEntity("title[]");
+                o.get().literal("1", "MARC");
+                o.get().literal("2", "JSON");
+                f.apply(2).endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void downcase() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "downcase('title')"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.literal("title", "MARC");
+                i.literal("title", "Json");
+                i.endRecord();
+
+                i.startRecord("3");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().startEntity("title[]");
+                o.get().literal("1", "marc");
+                o.get().literal("2", "json");
+                o.get().endEntity();
+                o.get().endRecord();
+
+                o.get().startRecord("3");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void capitalize() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "capitalize('title')"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.literal("title", "marc");
+                i.literal("title", "json");
+                i.endRecord();
+
+                i.startRecord("3");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().startEntity("title[]");
+                o.get().literal("1", "Marc");
+                o.get().literal("2", "Json");
+                o.get().endEntity();
+                o.get().endRecord();
+
+                o.get().startRecord("3");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void substring() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "substring('title', '0', '2')"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.literal("title", "marc");
+                i.literal("title", "json");
+                i.endRecord();
+
+                i.startRecord("3");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().startEntity("title[]");
+                o.get().literal("1", "m");
+                o.get().literal("2", "j");
+                o.get().endEntity();
+                o.get().endRecord();
+
+                o.get().startRecord("3");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void substringWithVar() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "substring('title', '0', '$[end]')"),
+                ImmutableMap.of("end", "3"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.literal("title", "marc");
+                i.literal("title", "json");
+                i.endRecord();
+
+                i.startRecord("3");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().startEntity("title[]");
+                o.get().literal("1", "ma");
+                o.get().literal("2", "js");
+                o.get().endEntity();
+                o.get().endRecord();
+
+                o.get().startRecord("3");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void trim() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "trim('title')"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.literal("title", "  marc  ");
+                i.literal("title", "  json  ");
+                i.endRecord();
+
+                i.startRecord("3");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().startEntity("title[]");
+                o.get().literal("1", "marc");
+                o.get().literal("2", "json");
+                o.get().endEntity();
+                o.get().endRecord();
+
+                o.get().startRecord("3");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void format() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "format(number,'%-5s: %s')"), // TODO actual number formatting with JSON-equiv record
+            i -> {
+                i.startRecord("1");
+                i.literal("number", "41");
+                i.literal("number", "15");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().startEntity("number[]");
+                o.get().literal("1", "41   : 15");
+                o.get().endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void parseText() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "parse_text(date, '(\\\\d{4})-(\\\\d{2})-(\\\\d{2})')"),
+            i -> {
+                i.startRecord("1");
+                i.literal("date", "2015-03-07");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().startEntity("date[]");
+                o.get().literal("1", "2015");
+                o.get().literal("2", "03");
+                o.get().literal("3", "07");
+                o.get().endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void parseTextNamedGroups() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "parse_text(date, '(?<year>\\\\d{4})-(?<month>\\\\d{2})-(?<day>\\\\d{2})')"),
+            i -> {
+                i.startRecord("1");
+                i.literal("date", "2015-03-07");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().startEntity("date");
+                o.get().literal("year", "2015");
+                o.get().literal("month", "03");
+                o.get().literal("day", "07");
+                o.get().endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void parseTextNestedNamedGroups() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "parse_text(data, '.(?<outer1>.(?<inner1>.).(?<inner2>.).).(?<outer2>.).')"),
+            i -> {
+                i.startRecord("1");
+                i.literal("data", "abcdefghi");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().startEntity("data");
+                o.get().literal("outer1", "bcdef");
+                o.get().literal("inner1", "c");
+                o.get().literal("inner2", "e");
+                o.get().literal("outer2", "h");
+                o.get().endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void parseTextMixedGroups() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "parse_text(data, '(?<a>.)(.)(?<c>.)')"
+            ),
+            i -> {
+                i.startRecord("1");
+                i.literal("data", "abc");
+                i.endRecord();
+            },
+            o -> {
+                o.get().startRecord("1");
+                o.get().startEntity("data");
+                o.get().literal("a", "a");
+                o.get().literal("c", "c");
+                o.get().endEntity();
+                o.get().endRecord();
+            }
+        );
+    }
+
+    @Test
+    public void parseTextEscapedGroups() {
+        Assertions.assertThrows(MetafactureException.class, () ->
+            MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                    "parse_text(data, '(?<a>.)(.)\\\\(?<c>.\\\\)')"
+                ),
+                i -> {
+                    i.startRecord("1");
+                    i.literal("data", "ab(<c>c)");
+                    i.endRecord();
+                },
+                o -> {
+                }
+            ),
+            "No group with name <c>"
+        );
+    }
+
+    @Test
+    public void parseTextQuotedGroups() {
+        Assertions.assertThrows(MetafactureException.class, () ->
+            MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                    "parse_text(data, '(?<a>.)(.)\\\\Q(?<c>.)\\\\E')"
+                ),
+                i -> {
+                    i.startRecord("1");
+                    i.literal("data", "ab(?<c>.)");
+                    i.endRecord();
+                },
+                o -> {
+                }
+            ),
+            "No group with name <c>"
+        );
+    }
+
+    @Test
+    @Disabled("Use SimpleRegexTrie/WildcardTrie")
+    public void alternation() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "trim('title-1|title-2')"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.literal("title-1", "  marc  ");
+                i.literal("title-2", "  json  ");
+                i.endRecord();
+
+                i.startRecord("3");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().literal("title-2", "marc");
+                o.get().literal("title-1", "json");
+                o.get().endRecord();
+
+                o.get().startRecord("3");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    @Disabled("Use SimpleRegexTrie/WildcardTrie")
+    public void wildcard() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "trim('title-?')"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.literal("title-1", "  marc  ");
+                i.literal("title-2", "  json  ");
+                i.endRecord();
+
+                i.startRecord("3");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().literal("title-2", "marc");
+                o.get().literal("title-1", "json");
+                o.get().endRecord();
+
+                o.get().startRecord("3");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    @Disabled("Use SimpleRegexTrie")
+    public void characterClass() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "trim('title-[12]')"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.literal("title-1", "  marc  ");
+                i.literal("title-2", "  json  ");
+                i.endRecord();
+
+                i.startRecord("3");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().literal("title-2", "marc");
+                o.get().literal("title-1", "json");
+                o.get().endRecord();
+
+                o.get().startRecord("3");
+                o.get().endRecord();
+            });
+    }
+}
diff --git a/org.metafacture.fix/src/test/java/org/metafacture/metafix/MetafixRecordTest.java b/org.metafacture.fix/src/test/java/org/metafacture/metafix/MetafixRecordTest.java
new file mode 100644
index 00000000..7d431db9
--- /dev/null
+++ b/org.metafacture.fix/src/test/java/org/metafacture/metafix/MetafixRecordTest.java
@@ -0,0 +1,703 @@
+/*
+ * Copyright 2021 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.metafix;
+
+import org.metafacture.framework.StreamReceiver;
+
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.Arrays;
+
+/**
+ * Tests Metafix record level methods. Following the cheat sheet
+ * examples at https://github.com/LibreCat/Catmandu/wiki/Fixes-Cheat-Sheet
+ *
+ * @author Fabian Steeg
+ */
+@ExtendWith(MockitoExtension.class)
+@SuppressWarnings("checkstyle:MultipleStringLiterals")
+public class MetafixRecordTest {
+
+    @RegisterExtension
+    private MockitoRule mockitoRule = MockitoJUnit.rule();
+
+    @Mock
+    private StreamReceiver streamReceiver;
+
+    public MetafixRecordTest() {
+    }
+
+    @Test
+    public void entitiesPassThrough() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "vacuum()"),
+            i -> {
+                i.startRecord("1");
+                i.startEntity("deep");
+                i.startEntity("nested");
+                i.literal("key", "val");
+                i.endEntity();
+                i.endEntity();
+                i.endRecord();
+            }, (o, f) -> {
+                o.get().startRecord("1");
+                o.get().startEntity("deep");
+                o.get().startEntity("nested");
+                o.get().literal("key", "val");
+                f.apply(2).endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void internalIdUsage() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "copy_field('_id', id)"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+            }, (o, f) -> {
+                o.get().startRecord("1");
+                o.get().literal("id", "1");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    @Disabled("TODO: how to handle repeated entities: turn to array vs. merge because it's the same?")
+    public void entitiesPassThroughRepeatEntity() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "vacuum()"),
+            i -> {
+                i.startRecord("1");
+                i.startEntity("some");
+                i.literal("key", "val1");
+                i.endEntity();
+                i.startEntity("some");
+                i.literal("key", "val2");
+                i.endEntity();
+                i.endRecord();
+            }, (o, f) -> {
+                o.get().startRecord("1");
+                o.get().startEntity("some[]");
+                o.get().startEntity("");
+                o.get().literal("key", "val1");
+                o.get().endEntity();
+                o.get().startEntity("");
+                o.get().literal("key", "val2");
+                f.apply(2).endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    @SuppressWarnings("checkstyle:MagicNumber")
+    public void entitiesPassThroughRepeatNestedEntity() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "vacuum()"),
+            i -> {
+                i.startRecord("1");
+                i.startEntity("deep");
+                i.startEntity("nested");
+                i.literal("key", "val1");
+                i.endEntity();
+                i.startEntity("nested");
+                i.literal("key", "val2");
+                i.endEntity();
+                i.endEntity();
+                i.endRecord();
+            }, (o, f) -> {
+                o.get().startRecord("1");
+                o.get().startEntity("deep");
+                o.get().startEntity("nested");
+                o.get().startEntity("key[]");
+                o.get().literal("1", "val1");
+                o.get().literal("2", "val2");
+                f.apply(3).endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void setEmpty() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "set_field('my.nested.name','patrick')",
+                "set_field('your.nested.name','nicolas')"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+            }, (o, f) -> {
+                o.get().startRecord("1");
+                o.get().startEntity("my");
+                o.get().startEntity("nested");
+                o.get().literal("name", "patrick");
+                f.apply(2).endEntity();
+                o.get().startEntity("your");
+                o.get().startEntity("nested");
+                o.get().literal("name", "nicolas");
+                f.apply(2).endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void setExisting() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "set_field('my.nested.name','patrick')",
+                "set_field('your.nested.name','nicolas')"),
+            i -> {
+                i.startRecord("1");
+                i.startEntity("my");
+                i.startEntity("nested");
+                i.literal("name", "max");
+                i.endEntity();
+                i.endEntity();
+                i.startEntity("your");
+                i.startEntity("nested");
+                i.literal("name", "mo");
+                i.endEntity();
+                i.endEntity();
+                i.endRecord();
+            }, (o, f) -> {
+                o.get().startRecord("1");
+                o.get().startEntity("my");
+                o.get().startEntity("nested");
+                o.get().literal("name", "patrick");
+                f.apply(2).endEntity();
+                o.get().startEntity("your");
+                o.get().startEntity("nested");
+                o.get().literal("name", "nicolas");
+                f.apply(2).endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    @SuppressWarnings("checkstyle:ExecutableStatementCount")
+    public void add() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "add_field('my.name','patrick')",
+                "add_field('my.name','nicolas')"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.startEntity("my");
+                i.literal("name", "max");
+                i.endEntity();
+                i.endRecord();
+
+                i.startRecord("3");
+                i.endRecord();
+            }, (o, f) -> {
+                o.get().startRecord("1");
+                o.get().startEntity("my");
+                o.get().startEntity("name[]");
+                o.get().literal("1", "patrick");
+                o.get().literal("2", "nicolas");
+                f.apply(2).endEntity();
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().startEntity("my");
+                o.get().startEntity("name[]");
+                o.get().literal("1", "max");
+                o.get().literal("2", "patrick");
+                o.get().literal("3", "nicolas");
+                f.apply(2).endEntity();
+                o.get().endRecord();
+
+                o.get().startRecord("3");
+                o.get().startEntity("my");
+                o.get().startEntity("name[]");
+                o.get().literal("1", "patrick");
+                o.get().literal("2", "nicolas");
+                f.apply(2).endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void move() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(// TODO: dot noation in move_field
+                "move_field('my.name','your.name')",
+                "move_field('missing','whatever')"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.startEntity("my");
+                i.literal("name", "max");
+                i.endEntity();
+                i.endRecord();
+
+                i.startRecord("3");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().startEntity("my");
+                o.get().endEntity();
+                o.get().startEntity("your");
+                o.get().literal("name", "max");
+                o.get().endEntity();
+                o.get().endRecord();
+
+                o.get().startRecord("3");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void copy() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(// TODO dot notation in copy_field
+                "copy_field('your.name','your.name2')"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.startEntity("your");
+                i.literal("name", "max");
+                i.endEntity();
+                i.endRecord();
+
+                i.startRecord("3");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().startEntity("your");
+                o.get().literal("name", "max");
+                o.get().literal("name2", "max");
+                o.get().endEntity();
+                o.get().endRecord();
+
+                o.get().startRecord("3");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void copyIntoArrayOfStrings() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                // "set_array('author')", <- results in separate objects/entities here
+                "copy_field('your.name','author.name')",
+                "remove_field('your')"),
+            i -> {
+                i.startRecord("1");
+                i.startEntity("your");
+                i.literal("name", "maxi-mi");
+                i.literal("name", "maxi-ma");
+                i.endEntity();
+                i.endRecord();
+            }, (o, f) -> {
+                o.get().startRecord("1");
+                o.get().startEntity("author");
+                o.get().startEntity("name[]");
+                o.get().literal("1", "maxi-mi");
+                o.get().literal("2", "maxi-ma");
+                f.apply(2).endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void copyIntoArrayOfObjects() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "set_array('author')",
+                "copy_field('your.name','author.name')",
+                "remove_field('your')"),
+            i -> {
+                i.startRecord("1");
+                i.startEntity("your");
+                i.literal("name", "max");
+                i.endEntity();
+                i.startEntity("your");
+                i.literal("name", "mo");
+                i.endEntity();
+                i.endRecord();
+            }, (o, f) -> {
+                o.get().startRecord("1");
+                o.get().startEntity("author[]");
+                o.get().startEntity("");
+                o.get().literal("name", "max");
+                o.get().endEntity();
+                o.get().startEntity("");
+                o.get().literal("name", "mo");
+                f.apply(2).endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void copyIntoArrayTopLevel() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "set_array('author')",
+                "copy_field('your.name', 'author')",
+                "remove_field('your')"),
+            i -> {
+                i.startRecord("1");
+                i.startEntity("your");
+                i.literal("name", "maxi-mi");
+                i.literal("name", "maxi-ma");
+                i.endEntity();
+                i.endRecord();
+            }, (o, f) -> {
+                o.get().startRecord("1");
+                o.get().startEntity("author[]");
+                o.get().literal("1", "maxi-mi");
+                o.get().literal("2", "maxi-ma");
+                o.get().endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void removeLiteral() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "remove_field('your.name')"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.startEntity("your");
+                i.literal("name", "max");
+                i.endEntity();
+                i.endRecord();
+
+                i.startRecord("3");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().startEntity("your");
+                o.get().endEntity();
+                o.get().endRecord();
+
+                o.get().startRecord("3");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void removeLiteralAndEntity() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "remove_field('your.name')",
+                "remove_field('your')"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.startEntity("your");
+                i.literal("name", "max");
+                i.endEntity();
+                i.endRecord();
+
+                i.startRecord("3");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().endRecord();
+
+                o.get().startRecord("3");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void removeEntity() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "remove_field('your')"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.startEntity("your");
+                i.literal("name", "max");
+                i.endEntity();
+                i.endRecord();
+
+                i.startRecord("3");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().endRecord();
+
+                o.get().startRecord("2");
+                o.get().endRecord();
+
+                o.get().startRecord("3");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void setArray() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "set_array('foo','a','b','c')"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().startEntity("foo[]");
+                o.get().literal("1", "a");
+                o.get().literal("2", "b");
+                o.get().literal("3", "c");
+                o.get().endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void setHash() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "set_hash('foo','a': 'b','c': 'd')"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().startEntity("foo");
+                o.get().literal("a", "b");
+                o.get().literal("c", "d");
+                o.get().endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void paste() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "paste('my.string','m.n.z','m.n.a','m.n.b','m.n.c','m.n.d','m.n.e')",
+                "remove_field('m')"),
+            i -> {
+                i.startRecord("1");
+                i.startEntity("m");
+                i.startEntity("n");
+                i.literal("a", "eeny");
+                i.literal("b", "meeny");
+                i.literal("c", "miny");
+                i.literal("d", "moe");
+                i.endEntity();
+                i.endEntity();
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().startEntity("my");
+                o.get().literal("string", "eeny meeny miny moe");
+                o.get().endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void pasteWithCustomSep() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "paste('my.string','a','b','c','d','join_char': ', ')",
+                "remove_field('a','b','c','d')"),
+            i -> {
+                i.startRecord("1");
+                i.literal("a", "eeny");
+                i.literal("b", "meeny");
+                i.literal("c", "miny");
+                i.literal("d", "moe");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().startEntity("my");
+                o.get().literal("string", "eeny, meeny, miny, moe");
+                o.get().endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void pasteWithLiteralStrings() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "paste('my.string','~Hi','a','~how are you?')",
+                "remove_field('a','b','c','d')"),
+            i -> {
+                i.startRecord("1");
+                i.literal("a", "eeny");
+                i.literal("b", "meeny");
+                i.literal("c", "miny");
+                i.literal("d", "moe");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().startEntity("my");
+                o.get().literal("string", "Hi eeny how are you?");
+                o.get().endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void hashFromArray() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "set_array('foo','a','b','c','d')",
+                "hash('foo')"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().startEntity("foo");
+                o.get().literal("a", "b");
+                o.get().literal("c", "d");
+                o.get().endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void arrayFromHash() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "set_hash('foo','a': 'b','c': 'd')",
+                "array('foo')"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("1");
+                o.get().startEntity("foo[]");
+                o.get().literal("1", "a");
+                o.get().literal("2", "b");
+                o.get().literal("3", "c");
+                o.get().literal("4", "d");
+                o.get().endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void reject() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "if exists ('_metadata.error')",
+                "  reject()",
+                "end"),
+            i -> {
+                i.startRecord("1");
+                i.literal("_metadata.error", "details");
+                i.endRecord();
+                i.startRecord("2");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("2");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void appendArray() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "set_array('nums', '1')",
+                "set_array('nums.$append', '2', '3')"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+            }, (o, f) -> {
+                o.get().startRecord("1");
+                o.get().startEntity("nums[]");
+                o.get().literal("1", "1");
+                o.get().literal("2", "2");
+                o.get().literal("3", "3");
+                o.get().endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void mixedArray() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "set_array('@context', 'https://w3id.org/kim/lrmi-profile/draft/context.jsonld')",
+                "set_hash('@context.$append', '@language': 'de')"),
+            i -> {
+                i.startRecord("1");
+                i.endRecord();
+            }, (o, f) -> {
+                o.get().startRecord("1");
+                o.get().startEntity("@context[]");
+                o.get().literal("1", "https://w3id.org/kim/lrmi-profile/draft/context.jsonld");
+                o.get().startEntity("");
+                o.get().literal("@language", "de");
+                f.apply(2).endEntity();
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void retain() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "retain('1','3')"),
+            i -> {
+                i.startRecord("1");
+                i.literal("1", "one");
+                i.literal("2", "two");
+                i.literal("3", "tre");
+                i.literal("4", "for");
+                i.endRecord();
+            }, (o, f) -> {
+                o.get().startRecord("1");
+                o.get().literal("1", "one");
+                o.get().literal("3", "tre");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void vacuum() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "vacuum()"),
+            i -> {
+                i.startRecord("1");
+                i.literal("1", "one");
+                i.literal("2", "");
+                i.literal("3", "tre");
+                i.literal("4", "");
+                i.endRecord();
+            }, (o, f) -> {
+                o.get().startRecord("1");
+                o.get().literal("1", "one");
+                o.get().literal("3", "tre");
+                o.get().endRecord();
+            });
+    }
+}
diff --git a/org.metafacture.fix/src/test/java/org/metafacture/metafix/MetafixSelectorTest.java b/org.metafacture.fix/src/test/java/org/metafacture/metafix/MetafixSelectorTest.java
new file mode 100644
index 00000000..934412ad
--- /dev/null
+++ b/org.metafacture.fix/src/test/java/org/metafacture/metafix/MetafixSelectorTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2021 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.metafix;
+
+import org.metafacture.framework.StreamReceiver;
+
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.Arrays;
+
+/**
+ * Test Metafix selectors.
+ *
+ * @author Fabian Steeg
+ *
+ */
+@ExtendWith(MockitoExtension.class)
+@Disabled("TODO: support Fix-style selectors https://github.com/LibreCat/Catmandu/wiki/Selectors")
+public final class MetafixSelectorTest {
+
+    @RegisterExtension
+    private MockitoRule mockitoRule = MockitoJUnit.rule();
+
+    @Mock
+    private StreamReceiver streamReceiver;
+
+    public MetafixSelectorTest() { }
+
+    @Test
+    public void reject() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "reject exists(error)"),
+            i -> {
+                i.startRecord("1");
+                i.literal("error", "details");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("2");
+                o.get().literal("name", "Mary");
+                o.get().endRecord();
+            });
+    }
+
+    @Test
+    public void rejectWithExplicitConditional() {
+        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(
+                "if exists(error)",
+                "  reject()",
+                "end"),
+            i -> {
+                i.startRecord("1");
+                i.literal("error", "details");
+                i.endRecord();
+
+                i.startRecord("2");
+                i.endRecord();
+            }, o -> {
+                o.get().startRecord("2");
+                o.get().literal("name", "Mary");
+                o.get().endRecord();
+            });
+    }
+
+}
diff --git a/org.metafacture.fix/src/test/java/org/metafacture/metamorph/MetafixTestHelpers.java b/org.metafacture.fix/src/test/java/org/metafacture/metafix/MetafixTestHelpers.java
similarity index 63%
rename from org.metafacture.fix/src/test/java/org/metafacture/metamorph/MetafixTestHelpers.java
rename to org.metafacture.fix/src/test/java/org/metafacture/metafix/MetafixTestHelpers.java
index 08d01a60..b3c5f9b9 100644
--- a/org.metafacture.fix/src/test/java/org/metafacture/metamorph/MetafixTestHelpers.java
+++ b/org.metafacture.fix/src/test/java/org/metafacture/metafix/MetafixTestHelpers.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 hbz NRW
+ * Copyright 2020, 2021 hbz NRW
  *
  * Licensed under the Apache License, Version 2.0 the "License";
  * you may not use this file except in compliance with the License.
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.metafacture.metamorph;
+package org.metafacture.metafix;
 
 import org.metafacture.framework.StreamReceiver;
 
@@ -23,8 +23,8 @@
 import org.mockito.exceptions.base.MockitoAssertionError;
 
 import java.io.FileNotFoundException;
-import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 import java.util.function.IntFunction;
@@ -42,13 +42,28 @@ private MetafixTestHelpers() { }
 
     public static void assertFix(final StreamReceiver receiver, final List<String> fixDef, final Consumer<Metafix> in,
             final Consumer<Supplier<StreamReceiver>> out) {
-        assertFix(receiver, fixDef, in, (s, f) -> out.accept(s));
+        assertFix(receiver, fixDef, in, (s, f) -> out.accept(s), Metafix.NO_VARS);
     }
 
-    public static void assertFix(final StreamReceiver receiver, final List<String> fixLines, final Consumer<Metafix> in,
+    public static void assertFix(final StreamReceiver receiver, final List<String> fixDef, final Consumer<Metafix> in,
             final BiConsumer<Supplier<StreamReceiver>, IntFunction<StreamReceiver>> out) {
+        assertFix(receiver, fixDef, in, out, Metafix.NO_VARS);
+    }
+
+    public static void assertFix(final StreamReceiver receiver, final List<String> fixDef, final Map<String, String> vars,
+            final Consumer<Metafix> in, final Consumer<Supplier<StreamReceiver>> out) {
+        assertFix(receiver, fixDef, in, (s, f) -> out.accept(s), vars);
+    }
+
+    public static void assertFix(final StreamReceiver receiver, final List<String> fixDef, final Map<String, String> vars,
+            final Consumer<Metafix> in, final BiConsumer<Supplier<StreamReceiver>, IntFunction<StreamReceiver>> out) {
+        assertFix(receiver, fixDef, in, out, vars);
+    }
+
+    private static void assertFix(final StreamReceiver receiver, final List<String> fixLines, final Consumer<Metafix> in,
+            final BiConsumer<Supplier<StreamReceiver>, IntFunction<StreamReceiver>> out, final Map<String, String> vars) {
         final String fixString = String.join("\n", fixLines);
-        final Metafix metafix = fix(receiver, fixString);
+        final Metafix metafix = fix(receiver, fixString, vars);
         final InOrder ordered = Mockito.inOrder(receiver);
         try {
             in.accept(metafix);
@@ -62,11 +77,11 @@ public static void assertFix(final StreamReceiver receiver, final List<String> f
         }
     }
 
-    static Metafix fix(final StreamReceiver receiver, final String fix) {
+    private static Metafix fix(final StreamReceiver receiver, final String fix, final Map<String, String> vars) {
         System.out.println("\nFix string: " + fix);
         Metafix metafix = null;
         try {
-            metafix = new Metafix(fix, Collections.emptyMap());
+            metafix = new Metafix(fix, vars);
             metafix.setReceiver(receiver);
         }
         catch (final FileNotFoundException e) {
diff --git a/org.metafacture.fix/src/test/java/org/metafacture/metamorph/maps/test.csv b/org.metafacture.fix/src/test/java/org/metafacture/metafix/maps/test.csv
similarity index 100%
rename from org.metafacture.fix/src/test/java/org/metafacture/metamorph/maps/test.csv
rename to org.metafacture.fix/src/test/java/org/metafacture/metafix/maps/test.csv
diff --git a/org.metafacture.fix/src/test/java/org/metafacture/metamorph/maps/test.tsv b/org.metafacture.fix/src/test/java/org/metafacture/metafix/maps/test.tsv
similarity index 100%
rename from org.metafacture.fix/src/test/java/org/metafacture/metamorph/maps/test.tsv
rename to org.metafacture.fix/src/test/java/org/metafacture/metafix/maps/test.tsv
diff --git a/org.metafacture.fix/src/test/java/org/metafacture/metamorph/MetafixApiTest.java b/org.metafacture.fix/src/test/java/org/metafacture/metamorph/MetafixApiTest.java
deleted file mode 100644
index 2efed161..00000000
--- a/org.metafacture.fix/src/test/java/org/metafacture/metamorph/MetafixApiTest.java
+++ /dev/null
@@ -1,214 +0,0 @@
-/*
- * Copyright 2013, 2019 Deutsche Nationalbibliothek and others
- *
- * 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.metamorph;
-
-import org.metafacture.framework.helpers.DefaultStreamReceiver;
-import org.metafacture.metamorph.api.Maps;
-import org.metafacture.metamorph.api.NamedValueReceiver;
-
-import org.junit.Assert;
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.junit.jupiter.api.extension.RegisterExtension;
-import org.mockito.ArgumentMatchers;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.junit.MockitoJUnit;
-import org.mockito.junit.MockitoRule;
-import org.mockito.junit.jupiter.MockitoExtension;
-
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * Tests the basic functionality of Metafix via API.
- *
- * @author Markus Michael Geipel (MetamorphTest)
- * @author Christoph Böhme (rewrite MetamorphTest)
- * @author Fabian Steeg (MetafixApiTest)
- */
-@ExtendWith(MockitoExtension.class)
-public class MetafixApiTest {
-
-    private static final String OUT_NAME = "outName";
-
-    private static final String TEST_ENTITY = "testEntity";
-    private static final String TEST_LITERAL = "testLiteral";
-    private static final String TEST_MAP = "testMap";
-    private static final String TEST_VALUE = "testValue";
-
-    @RegisterExtension
-    private MockitoRule mockitoRule = MockitoJUnit.rule();
-
-    @Mock
-    private NamedValueReceiver namedValueReceiver;
-
-    private Metafix metafix;
-
-    public MetafixApiTest() {
-    }
-
-    @BeforeEach
-    public void createSystemUnderTest() {
-        metafix = new Metafix();
-        metafix.setReceiver(new DefaultStreamReceiver());
-    }
-
-    @Test
-    public void shouldMapMatchingPath() {
-        setupSimpleMappingMorph();
-
-        metafix.startRecord("");
-        metafix.literal(TEST_ENTITY + "." + TEST_LITERAL, TEST_VALUE);
-
-        receive();
-    }
-
-    @Test
-    public void shouldNotMapNonMatchingPath() {
-        setupSimpleMappingMorph();
-
-        metafix.startRecord("");
-        metafix.literal("nonMatching.path", TEST_VALUE);
-
-        neverReceive();
-    }
-
-    @Test
-    public void shouldMapMatchingLiteralInMatchingEntity() {
-        setupSimpleMappingMorph();
-
-        metafix.startRecord("");
-        metafix.startEntity(TEST_ENTITY);
-        metafix.literal(TEST_LITERAL, TEST_VALUE);
-
-        receive();
-    }
-
-    @Test
-    public void shouldNotMapNonMatchingLiteralInMatchingEntity() {
-        setupSimpleMappingMorph();
-
-        metafix.startRecord("");
-        metafix.startEntity(TEST_ENTITY);
-        metafix.literal("nonMatching", TEST_VALUE);
-
-        neverReceive();
-    }
-
-    @Test
-    public void shouldNotMapMatchingLiteralInNonMatchingEntity() {
-        setupSimpleMappingMorph();
-
-        metafix.startRecord("");
-        metafix.startEntity("nonMatching");
-        metafix.literal(TEST_LITERAL, TEST_VALUE);
-
-        neverReceive();
-    }
-
-    @Test
-    public void shouldNotMapLiteralWithoutMatchingEntity() {
-        setupSimpleMappingMorph();
-
-        metafix.startRecord("");
-        metafix.literal(TEST_LITERAL, TEST_VALUE);
-
-        neverReceive();
-    }
-
-    @Test
-    public void shouldReturnValueFromNestedMap() {
-        final Map<String, String> map = new HashMap<>();
-        map.put(OUT_NAME, TEST_VALUE);
-
-        metafix.putMap(TEST_MAP, map);
-
-        Assert.assertNotNull(metafix.getMap(TEST_MAP));
-        Assert.assertEquals(TEST_VALUE, metafix.getValue(TEST_MAP, OUT_NAME));
-    }
-
-    @Test
-    public void shouldReturnDefaultValueIfMapIsKnownButNameIsUnknown() {
-        final Map<String, String> map = new HashMap<>();
-        map.put(Maps.DEFAULT_MAP_KEY, "defaultValue");
-
-        metafix.putMap(TEST_MAP, map);
-
-        Assert.assertEquals("defaultValue", metafix.getValue(TEST_MAP, "nameNotInMap"));
-    }
-
-    @Test
-    public void shouldFeedbackLiteralsStartingWithAtIntoMetamorph() {
-        final Data dataIn;
-        dataIn = new Data();
-        dataIn.setName("@feedback");
-        metafix.addNamedValueSource(dataIn);
-        metafix.registerNamedValueReceiver(TEST_LITERAL, dataIn);
-
-        final Data dataOut = new Data();
-        dataOut.setName(OUT_NAME);
-        dataOut.setNamedValueReceiver(namedValueReceiver);
-        metafix.registerNamedValueReceiver("@feedback", dataOut);
-
-        metafix.startRecord("");
-        metafix.literal(TEST_LITERAL, TEST_VALUE);
-
-        receive();
-    }
-
-    @Test
-    public void shouldThrowIllegalStateExceptionIfEntityIsNotClosed() {
-        Assertions.assertThrows(IllegalStateException.class, () -> {
-            metafix.startRecord("");
-            metafix.startEntity(TEST_ENTITY);
-            metafix.startEntity(TEST_ENTITY);
-            metafix.endEntity();
-            metafix.endRecord(); // Exception expected
-        });
-    }
-
-    /**
-     * Creates the Metafix object structure that corresponds to the Metafix DSL
-     * statement {@code map(testEntity.testLiteral, outName)}.
-     */
-    private void setupSimpleMappingMorph() {
-        final Data data = new Data();
-        data.setName(OUT_NAME);
-        data.setNamedValueReceiver(namedValueReceiver);
-        metafix.registerNamedValueReceiver(TEST_ENTITY + '.' + TEST_LITERAL, data);
-    }
-
-    private void receive() {
-        Mockito.verify(namedValueReceiver).receive(
-                ArgumentMatchers.eq(OUT_NAME),
-                ArgumentMatchers.eq(TEST_VALUE),
-                ArgumentMatchers.isA(Data.class),
-                ArgumentMatchers.anyInt(),
-                ArgumentMatchers.anyInt()
-        );
-
-        Mockito.verifyNoMoreInteractions(namedValueReceiver);
-    }
-
-    private void neverReceive() {
-        Mockito.verifyZeroInteractions(namedValueReceiver);
-    }
-
-}
diff --git a/org.metafacture.fix/src/test/java/org/metafacture/metamorph/MetafixDslTest.java b/org.metafacture.fix/src/test/java/org/metafacture/metamorph/MetafixDslTest.java
deleted file mode 100644
index 35a03553..00000000
--- a/org.metafacture.fix/src/test/java/org/metafacture/metamorph/MetafixDslTest.java
+++ /dev/null
@@ -1,955 +0,0 @@
-/*
- * Copyright 2013, 2019 Deutsche Nationalbibliothek and others
- *
- * 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.metamorph;
-
-import org.metafacture.framework.StreamReceiver;
-
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.junit.jupiter.api.extension.RegisterExtension;
-import org.mockito.ArgumentMatchers;
-import org.mockito.InOrder;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.junit.MockitoJUnit;
-import org.mockito.junit.MockitoRule;
-import org.mockito.junit.jupiter.MockitoExtension;
-import com.google.common.collect.ImmutableMap;
-
-import java.io.FileNotFoundException;
-import java.net.URISyntaxException;
-import java.util.Collections;
-import java.util.Map;
-
-/**
- * Tests the basic functionality of Metafix via DSL.
- *
- * @author Christoph Böhme (MetamorphTest)
- * @author Fabian Steeg (MetafixDslTest)
- */
-@ExtendWith(MockitoExtension.class)
-public class MetafixDslTest {
-
-    private static final String LITERAL_A = "lit-A";
-    private static final String LITERAL_ALOHA = "Aloha";
-    private static final String LITERAL_B = "lit-B";
-    private static final String LITERAL_HAWAII = "Hawaii";
-    private static final String LITERAL_MOIN = "Moin";
-    private static final String LITERAL_MOIN_MOIN = "Moin Moin";
-    private static final String LITERAL_LANGEOOG = "Langeoog";
-    private static final String LITERAL_BALTRUM = "Baltrum";
-
-    @RegisterExtension
-    private MockitoRule mockitoRule = MockitoJUnit.rule();
-
-    @Mock
-    private StreamReceiver streamReceiver;
-
-    public MetafixDslTest() {
-    }
-
-    @Test
-    public void shouldMapLiteral() {
-        final Metafix metafix = fix(
-                "map(a,b)"
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("a", LITERAL_ALOHA);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).literal("b", LITERAL_ALOHA);
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldMapAndFilterNeqLiteral() {
-        final Metafix metafix = fix(
-                "do map(a,b)", // checkstyle-disable-line MultipleStringLiterals
-                "  not_equals(string: '')",
-                "end" // checkstyle-disable-line MultipleStringLiterals
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("a", "");
-        metafix.literal("a", LITERAL_ALOHA);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).literal("b", LITERAL_ALOHA);
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldMapAndFilterEqLiteral() {
-        final Metafix metafix = fix(
-                "do map(a,b)", // checkstyle-disable-line MultipleStringLiterals
-                "  equals(string: '')",
-                "end" // checkstyle-disable-line MultipleStringLiterals
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("a", "");
-        metafix.literal("a", LITERAL_ALOHA);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).literal("b", "");
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldMapAndFilterRegexLiteral() {
-        final Metafix metafix = fix(
-                "do map(a,b)", // checkstyle-disable-line MultipleStringLiterals
-                "  regexp(match: '.+')",
-                "end" // checkstyle-disable-line MultipleStringLiterals
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("a", "");
-        metafix.literal("a", LITERAL_ALOHA);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).literal("b", LITERAL_ALOHA);
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldMapAndChangeLiteralSingle() {
-        final Metafix metafix = fix(
-                "do map(a,b)", // checkstyle-disable-line MultipleStringLiterals
-                "  replace_all(pattern: 'a-val', with: 'b-val')",
-                "end" // checkstyle-disable-line MultipleStringLiterals
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("a", "a-val");
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).literal("b", "b-val");
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldMapAndChangeLiteralMulti() {
-        final Metafix metafix = fix(
-                "do map(a,b)",
-                "  replace_all(pattern: 'a-val', with: 'b-val')",
-                "  compose(prefix: 'pre-')",
-                "  compose(postfix: '-post')",
-                "end" // checkstyle-disable-line MultipleStringLiterals
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("a", "a-val");
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).literal("b", "pre-b-val-post");
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldMapNested() {
-        final Metafix metafix = fix(
-                "map(a,b.c)"
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("a", LITERAL_ALOHA);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).startEntity("b");
-        ordered.verify(streamReceiver).literal("c", LITERAL_ALOHA);
-        ordered.verify(streamReceiver).endEntity();
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldMapNestedMulti() {
-        final Metafix metafix = fix(
-                "map(a,b)",
-                "map(a.c, b.c)",
-                "map(a.d, b.d)"
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("a.c", LITERAL_A);
-        metafix.literal("a.d", LITERAL_B);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).startEntity("b");
-        ordered.verify(streamReceiver).literal("c", LITERAL_A);
-        ordered.verify(streamReceiver).literal("d", LITERAL_B);
-        ordered.verify(streamReceiver).endEntity();
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldAddLiteral() {
-        final Metafix metafix = fix(
-                "add_field(a,'A')"
-        );
-
-        metafix.startRecord("1");
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).literal("a", "A");
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldAddEntity() {
-        final Metafix metafix = fix(
-                "add_field(a.b,'AB')"
-        );
-
-        metafix.startRecord("1");
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).startEntity("a");
-        ordered.verify(streamReceiver).literal("b", "AB");
-        ordered.verify(streamReceiver).endEntity();
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldAddEntityNested() {
-        final Metafix metafix = fix(
-                "add_field(a.b.c.d.e,'ABCDE')"
-        );
-
-        metafix.startRecord("1");
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).startEntity("a");
-        ordered.verify(streamReceiver).startEntity("b");
-        ordered.verify(streamReceiver).startEntity("c");
-        ordered.verify(streamReceiver).startEntity("d");
-        ordered.verify(streamReceiver).literal("e", "ABCDE");
-        ordered.verify(streamReceiver, Mockito.times(4)).endEntity(); // checkstyle-disable-line MagicNumber
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldReplaceInLiteral() {
-        final Metafix metafix = fix(
-                "do map(a)", // checkstyle-disable-line MultipleStringLiterals
-                "  replace_all(pattern: 'a', with: 'b')",
-                "end"
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("a", LITERAL_ALOHA);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).literal("a", LITERAL_ALOHA.replaceAll("a", "b"));
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldReplaceWithEntities() {
-        final Metafix metafix = fix(
-                "do map(a.b, a.b)",
-                "  replace_all(pattern: 'a', with: 'b')",
-                "end"
-        );
-
-        metafix.startRecord("1");
-        metafix.startEntity("a");
-        metafix.literal("b", LITERAL_ALOHA);
-        metafix.endEntity();
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).startEntity("a");
-        ordered.verify(streamReceiver).literal("b", LITERAL_ALOHA.replaceAll("a", "b"));
-        ordered.verify(streamReceiver).endEntity();
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldTrim() {
-        final Metafix metafix = fix(
-                "do map(a,b)",
-                "  trim()",
-                "end"
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("a", "\t" + LITERAL_ALOHA + " ");
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).literal("b", LITERAL_ALOHA);
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void appendLiteral() {
-        final Metafix metafix = fix(
-                "do map(a)",
-                "  compose(postfix: 'eha')",
-                "end"
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("a", LITERAL_ALOHA);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).literal("a", LITERAL_ALOHA + "eha"); // checkstyle-disable-line MultipleStringLiterals
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void prependLiteral() {
-        final Metafix metafix = fix(
-                "do map(a)",
-                "  compose(prefix: 'eha')",
-                "end"
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("a", LITERAL_ALOHA);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).literal("a", "eha" + LITERAL_ALOHA);
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void prependLiteralWithVarVal() {
-        final Metafix metafix = fix(
-                ImmutableMap.of("pre", "eha"),
-                "do map(a)",
-                "  compose(prefix: '$[pre]')",
-                "end"
-        );
-        metafix.startRecord("1");
-        metafix.literal("a", LITERAL_ALOHA);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).literal("a", "eha" + LITERAL_ALOHA);
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void prependLiteralWithVarKey() {
-        final Metafix metafix = fix(
-                ImmutableMap.of("composeOperation", "prefix"),
-                "do map(a)",
-                "  compose('$[composeOperation]': 'eha')",
-                "end"
-        );
-        metafix.startRecord("1");
-        metafix.literal("a", LITERAL_ALOHA);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).literal("a", "eha" + LITERAL_ALOHA);
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldHandleUnmatchedLiteralsInElseSource() {
-        final Metafix metafix = fix(
-                "map(Sylt,Hawaii)",
-                "map(_else)"
-        );
-
-        metafix.startRecord("1");
-        metafix.literal(LITERAL_LANGEOOG, LITERAL_MOIN);
-        metafix.literal("Sylt", LITERAL_ALOHA);
-        metafix.literal(LITERAL_BALTRUM, LITERAL_MOIN_MOIN);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).literal(LITERAL_LANGEOOG, LITERAL_MOIN);
-        ordered.verify(streamReceiver).literal(LITERAL_HAWAII, LITERAL_ALOHA);
-        ordered.verify(streamReceiver).literal(LITERAL_BALTRUM, LITERAL_MOIN_MOIN);
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldAllowTreatingEntityEndEventsAsLiterals() {
-        final Metafix metafix = fix(
-                "map(e1)",
-                "map(e1.e2)",
-                "map(e1.e2.d)"
-        );
-
-        metafix.startRecord("entity end info");
-        metafix.startEntity("e1");
-        metafix.startEntity("e2");
-        metafix.literal("d", "a");
-        metafix.endEntity();
-        metafix.endEntity();
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("entity end info");
-        ordered.verify(streamReceiver).literal("e1.e2.d", "a");
-        ordered.verify(streamReceiver).literal("e1.e2", "");
-        ordered.verify(streamReceiver).literal("e1", "");
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldLookupInline() {
-        verifyLookup(fix(
-                "do map(a)", // checkstyle-disable-line MultipleStringLiterals
-                "  lookup(Aloha: Alohaeha, 'Moin': 'Moin zäme', __default: Tach)", // checkstyle-disable-line MultipleStringLiterals
-                "end"
-        ));
-    }
-
-    @Test
-    public void shouldLookupInTsvFile() throws URISyntaxException {
-        verifyLookup(fix(
-                "do map(a)",
-                "  lookup(in: 'src/test/java/org/metafacture/metamorph/maps/test.tsv')",
-                "end"
-        ));
-    }
-
-    @Test
-    public void shouldLookupInCsvFile() throws URISyntaxException {
-        verifyLookup(fix(
-                "do map(a)",
-                "  lookup(in: 'src/test/java/org/metafacture/metamorph/maps/test.csv', separator: ',')",
-                "end"
-        ));
-    }
-
-    private void verifyLookup(final Metafix metafix) {
-        metafix.startRecord("1");
-        metafix.literal("a", LITERAL_ALOHA);
-        metafix.literal("a", LITERAL_MOIN);
-        metafix.literal("a", LITERAL_HAWAII);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).literal("a", "Alohaeha"); // checkstyle-disable-line MultipleStringLiterals
-        ordered.verify(streamReceiver).literal("a", "Moin zäme"); // checkstyle-disable-line MultipleStringLiterals
-        ordered.verify(streamReceiver).literal("a", "Tach"); // checkstyle-disable-line MultipleStringLiterals
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldMapAndLookupInline() {
-        verifyMapAndLookup(fix(
-                "do map(a,b)",
-                "  lookup(Aloha: Alohaeha, 'Moin': 'Moin zäme', __default: Tach)", // checkstyle-disable-line MultipleStringLiterals
-                "end"
-        ));
-    }
-
-    @Test
-    public void shouldMapAndLookupInTsvFile() {
-        verifyMapAndLookup(fix(
-                "do map(a,b)",
-                "  lookup(in: 'src/test/java/org/metafacture/metamorph/maps/test.tsv')", // checkstyle-disable-line MultipleStringLiterals
-                "end"
-        ));
-    }
-
-    @Test
-    public void shouldMapAndLookupInCsvFile() {
-        verifyMapAndLookup(fix(
-                "do map(a,b)",
-                "  lookup(in: 'src/test/java/org/metafacture/metamorph/maps/test.csv', separator: ',')", // checkstyle-disable-line MultipleStringLiterals
-                "end"
-        ));
-    }
-
-    private void verifyMapAndLookup(final Metafix metafix) {
-        metafix.startRecord("1");
-        metafix.literal("a", LITERAL_ALOHA);
-        metafix.literal("a", LITERAL_MOIN);
-        metafix.literal("a", LITERAL_HAWAII);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).literal("b", "Alohaeha");
-        ordered.verify(streamReceiver).literal("b", "Moin zäme");
-        ordered.verify(streamReceiver).literal("b", "Tach");
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldMapToExplicitEntityAndLookupInline() {
-        final Metafix metafix = fix(
-                "do entity('c')",
-                "  do map(a,b)",
-                "    lookup(Aloha: Alohaeha, 'Moin': 'Moin zäme', __default: Tach)",
-                "  end", // checkstyle-disable-line MultipleStringLiterals
-                "end"
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("a", LITERAL_ALOHA);
-        metafix.literal("a", LITERAL_MOIN);
-        metafix.literal("a", LITERAL_HAWAII);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).startEntity("c");
-        ordered.verify(streamReceiver).literal("b", "Alohaeha");
-        ordered.verify(streamReceiver).literal("b", "Moin zäme");
-        ordered.verify(streamReceiver).literal("b", "Tach");
-        ordered.verify(streamReceiver).endEntity();
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldMapToImplicitEntityAndLookupInline() {
-        final Metafix metafix = fix(
-                "do map(a,c.b)",
-                "  lookup(Aloha: Alohaeha, 'Moin': 'Moin zäme', __default: Tach)",
-                "end"
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("a", LITERAL_ALOHA);
-        metafix.literal("a", LITERAL_MOIN);
-        metafix.literal("a", LITERAL_HAWAII);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).startEntity("c");
-        ordered.verify(streamReceiver).literal("b", "Alohaeha");
-        ordered.verify(streamReceiver).literal("b", "Moin zäme");
-        ordered.verify(streamReceiver).literal("b", "Tach");
-        ordered.verify(streamReceiver).endEntity();
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldMapAndChangeAndLookupInline() {
-        final Metafix metafix = fix(
-                "do map(a,b)",
-                "  replace_all(pattern: 'lit-A', with: 'Aloha')",
-                "  replace_all(pattern: 'lit-B', with: 'Moin')",
-                "  lookup(Aloha: Alohaeha, 'Moin': 'Moin zäme', __default: Tach)",
-                "end"
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("a", LITERAL_A);
-        metafix.literal("a", LITERAL_B);
-        metafix.literal("a", LITERAL_HAWAII);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).literal("b", "Alohaeha");
-        ordered.verify(streamReceiver).literal("b", "Moin zäme");
-        ordered.verify(streamReceiver).literal("b", "Tach");
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldCombineLiterals() {
-        final Metafix metafix = fix(
-                "do combine(name: d, value: '${place}, ${greet}')",
-                "  map(a, greet)",
-                "  map(b, place)",
-                "end",
-                "map(c, e)"
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("a", LITERAL_ALOHA);
-        metafix.literal("b", LITERAL_HAWAII);
-        metafix.literal("c", LITERAL_MOIN);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).literal("d", LITERAL_HAWAII + ", " + LITERAL_ALOHA);
-        ordered.verify(streamReceiver).literal("e", LITERAL_MOIN);
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldDoEntityAndMap() {
-        final Metafix metafix = fix(
-                "do entity(b)",
-                " map(a, c)",
-                "end"
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("a", LITERAL_A);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).startEntity("b");
-        ordered.verify(streamReceiver).literal("c", LITERAL_A);
-        ordered.verify(streamReceiver).endEntity();
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldMapAndChangeNestedExplicit() {
-        final Metafix metafix = fix(
-                "do entity(b)",
-                " do map(a, c)",
-                "  replace_all(pattern: 'A', with: 'B')",
-                " end",
-                "end"
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("a", LITERAL_A);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).startEntity("b");
-        ordered.verify(streamReceiver).literal("c", LITERAL_B);
-        ordered.verify(streamReceiver).endEntity();
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldMapAndChangeNestedImplicit() {
-        final Metafix metafix = fix(
-                "do map(a, b.c)",
-                "  replace_all(pattern: 'A', with: 'B')",
-                "end",
-                "map(x, y)"
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("a", LITERAL_A);
-        metafix.literal("x", LITERAL_A);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).startEntity("b");
-        ordered.verify(streamReceiver).literal("c", LITERAL_B);
-        ordered.verify(streamReceiver).endEntity();
-        ordered.verify(streamReceiver).literal("y", LITERAL_A);
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldCombineToEntity() {
-        final Metafix metafix = fix(
-                "do entity(d)",
-                " do combine(name: a, value: '${place}, ${greet}')",
-                "  map(a, greet)",
-                "  map(b, place)",
-                " end",
-                "end",
-                "map(c, e)"
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("a", LITERAL_ALOHA);
-        metafix.literal("b", LITERAL_HAWAII);
-        metafix.literal("c", LITERAL_MOIN);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).startEntity("d");
-        ordered.verify(streamReceiver).literal("a", LITERAL_HAWAII + ", " + LITERAL_ALOHA);
-        ordered.verify(streamReceiver).endEntity();
-        ordered.verify(streamReceiver).literal("e", LITERAL_MOIN);
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void shouldChooseFirstMapFlushWith() {
-        final Metafix metafix = fix(
-                "do choose(flushWith: 'd|record')",
-                "  map(a, c)",
-                "  map(b, c)",
-                "end",
-                "map(d,e)" // checkstyle-disable-line MultipleStringLiterals
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("b", LITERAL_B);
-        metafix.literal("a", LITERAL_A);
-        metafix.literal("d", LITERAL_B);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).literal("c", LITERAL_A);
-        ordered.verify(streamReceiver).literal("e", LITERAL_B);
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    @Disabled("Fix choose flushing")
-    public void shouldChooseFirstMap() {
-        final Metafix metafix = fix(
-                "do choose()",
-                "  map(a, c)",
-                "  map(b, c)",
-                "end",
-                "map(d,e)"
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("b", LITERAL_B);
-        metafix.literal("a", LITERAL_A);
-        metafix.literal("d", LITERAL_B);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).literal("c", LITERAL_A);
-        ordered.verify(streamReceiver).literal("e", LITERAL_B);
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    @Disabled("Fix choose flushing")
-    public void shouldChooseFirstDoMap() {
-        final Metafix metafix = fix(
-                "do choose()",
-                "  do map(a, c)",
-                "    not_equals('')",
-                "  end",
-                "  do map(b, c)",
-                "    not_equals('')",
-                "  end",
-                "end",
-                "map(d,e)"
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("b", LITERAL_B);
-        metafix.literal("a", LITERAL_A);
-        metafix.literal("d", LITERAL_B);
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).literal("c", LITERAL_A);
-        ordered.verify(streamReceiver).literal("e", LITERAL_B);
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    @Test
-    @Disabled("Fix syntax")
-    public void shouldUseCustomEntityMarker() {
-        final Metafix metafix = fix(
-                "map(entity~literal,data)"
-        );
-
-        metafix.startRecord("1");
-        metafix.startEntity("entity");
-        metafix.literal("literal", LITERAL_ALOHA);
-        metafix.endEntity();
-        metafix.endRecord();
-
-        Mockito.verify(streamReceiver).literal("data", LITERAL_ALOHA);
-    }
-
-    @Test
-    public void shouldMatchCharacterWithQuestionMarkWildcard() {
-        final Metafix metafix = fix(
-                "map('lit-?')"
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("lit", LITERAL_MOIN);
-        metafix.literal(LITERAL_A, LITERAL_ALOHA);
-        metafix.literal(LITERAL_B, "Aloha 'oe");
-        metafix.endRecord();
-
-        Mockito.verify(streamReceiver).literal(LITERAL_A, LITERAL_ALOHA);
-        Mockito.verify(streamReceiver).literal(LITERAL_B, "Aloha 'oe");
-        Mockito.verify(streamReceiver, Mockito.times(2)).literal(ArgumentMatchers.any(), ArgumentMatchers.any());
-    }
-
-    @Test
-    public void shouldMatchCharactersInCharacterClass() {
-        final Metafix metafix = fix(
-                "map('lit-[AB]')"
-        );
-
-        metafix.startRecord("1");
-        metafix.literal(LITERAL_A, LITERAL_HAWAII);
-        metafix.literal(LITERAL_B, "Oahu");
-        metafix.literal("lit-C", "Fehmarn");
-        metafix.endRecord();
-
-        Mockito.verify(streamReceiver).literal(LITERAL_A, LITERAL_HAWAII);
-        Mockito.verify(streamReceiver).literal(LITERAL_B, "Oahu");
-        Mockito.verify(streamReceiver, Mockito.times(2)).literal(ArgumentMatchers.any(), ArgumentMatchers.any());
-    }
-
-    @Test
-    public void shouldNotFeedbackJsonLdKeywords() {
-        final Metafix metafix = fix(
-                "map(_else)"
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("@id", LITERAL_HAWAII);
-        metafix.endRecord();
-
-        Mockito.verify(streamReceiver).literal("@id", LITERAL_HAWAII);
-    }
-
-    @Test
-    public void shouldNotFeedbackJsonLdKeywordsNested() {
-        final Metafix metafix = fix(
-                "do entity('USA')",
-                "  map('USA.Sylt', 'Hawaii')",
-                "end",
-                "map(_elseNested)"
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("Shikotan", "Aekap");
-        metafix.startEntity("Germany");
-        metafix.literal(LITERAL_LANGEOOG, LITERAL_MOIN);
-        metafix.literal(LITERAL_BALTRUM, LITERAL_MOIN_MOIN);
-        metafix.endEntity();
-        metafix.startEntity("USA");
-        metafix.literal("Sylt", LITERAL_ALOHA);
-        metafix.endEntity();
-        metafix.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).literal("Shikotan", "Aekap");
-        ordered.verify(streamReceiver).startEntity("Germany");
-        ordered.verify(streamReceiver).literal(LITERAL_LANGEOOG, "Moin");
-        ordered.verify(streamReceiver).literal(LITERAL_BALTRUM, LITERAL_MOIN_MOIN);
-        ordered.verify(streamReceiver).endEntity();
-        ordered.verify(streamReceiver).startEntity("USA");
-        ordered.verify(streamReceiver).literal("Hawaii", "Aloha");
-        ordered.verify(streamReceiver).endEntity();
-        ordered.verify(streamReceiver).endRecord();
-    }
-
-    @Test
-    @Disabled("Fix syntax")
-    public void shouldReplaceVariables() {
-        final Metafix metafix = fix(
-                "vars(in: Honolulu, out: Hawaii)",
-                "map($[in],$[out])"
-        );
-
-        metafix.startRecord("1");
-        metafix.literal("Honolulu", LITERAL_ALOHA);
-        metafix.endRecord();
-
-        Mockito.verify(streamReceiver).literal(LITERAL_HAWAII, LITERAL_ALOHA);
-    }
-
-    private Metafix fix(final String... fix) {
-        return fix(Collections.emptyMap(), fix);
-    }
-
-    private Metafix fix(final Map<String, String> vars, final String... fix) {
-        final String fixString = String.join("\n", fix);
-        System.out.println("\nFix string: " + fixString);
-
-        Metafix metafix = null;
-        try {
-            metafix = new Metafix(fixString, vars);
-            metafix.setReceiver(streamReceiver);
-        }
-        catch (final FileNotFoundException e) {
-            e.printStackTrace();
-        }
-        return metafix;
-    }
-
-}
diff --git a/org.metafacture.fix/src/test/java/org/metafacture/metamorph/MetafixFilterTest.java b/org.metafacture.fix/src/test/java/org/metafacture/metamorph/MetafixFilterTest.java
deleted file mode 100644
index bb2c9291..00000000
--- a/org.metafacture.fix/src/test/java/org/metafacture/metamorph/MetafixFilterTest.java
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
- * Copyright 2013, 2021 Deutsche Nationalbibliothek and others
- *
- * 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.metamorph;
-
-import org.metafacture.framework.StreamReceiver;
-
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.junit.jupiter.api.extension.RegisterExtension;
-import org.mockito.InOrder;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.junit.MockitoJUnit;
-import org.mockito.junit.MockitoRule;
-import org.mockito.junit.jupiter.MockitoExtension;
-
-import java.io.FileNotFoundException;
-import java.util.Collections;
-import java.util.Map;
-
-/**
- * Tests for class {@link MetafixFilter}.
- *
- * @author Fabian Steeg
- *
- */
-@ExtendWith(MockitoExtension.class)
-public final class MetafixFilterTest {
-
-    private static final String VAL = "val";
-
-    @RegisterExtension
-    private MockitoRule mockitoRule = MockitoJUnit.rule();
-
-    @Mock
-    private StreamReceiver streamReceiver;
-
-    public MetafixFilterTest() { }
-
-    @Test
-    public void shouldFilterRecords() {
-        final MetafixFilter filter = filter("map(a)");
-
-        filter.startRecord("1");
-        filter.literal("a", VAL);
-        filter.endRecord();
-
-        filter.startRecord("2");
-        filter.literal("b", VAL);
-        filter.endRecord();
-
-        final InOrder ordered = Mockito.inOrder(streamReceiver);
-        ordered.verify(streamReceiver).startRecord("1");
-        ordered.verify(streamReceiver).literal("a", VAL);
-        ordered.verify(streamReceiver).endRecord();
-        ordered.verifyNoMoreInteractions();
-    }
-
-    private MetafixFilter filter(final String... filter) {
-        return filter(Collections.emptyMap(), filter);
-    }
-
-    private MetafixFilter filter(final Map<String, String> vars, final String... fix) {
-        final String fixString = String.join("\n", fix);
-        System.out.println("\nFix filter string: " + fixString);
-
-        MetafixFilter filter = null;
-        try {
-            filter = new MetafixFilter(fixString, vars);
-            filter.setReceiver(streamReceiver);
-        }
-        catch (final FileNotFoundException e) {
-            e.printStackTrace();
-        }
-        return filter;
-    }
-
-}
diff --git a/org.metafacture.fix/src/test/java/org/metafacture/metamorph/MetafixRecordTest.java b/org.metafacture.fix/src/test/java/org/metafacture/metamorph/MetafixRecordTest.java
deleted file mode 100644
index 6382ce41..00000000
--- a/org.metafacture.fix/src/test/java/org/metafacture/metamorph/MetafixRecordTest.java
+++ /dev/null
@@ -1,228 +0,0 @@
-/*
- * Copyright 2021 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.metamorph;
-
-import org.metafacture.framework.StreamReceiver;
-
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.junit.jupiter.api.extension.RegisterExtension;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnit;
-import org.mockito.junit.MockitoRule;
-import org.mockito.junit.jupiter.MockitoExtension;
-
-import java.util.Arrays;
-
-/**
- * Tests the non-field-streaming record functionality of Metafix via DSL.
- *
- * See https://github.com/metafacture/metafacture-fix/issues/35
- *
- * @author Fabian Steeg
- */
-@ExtendWith(MockitoExtension.class)
-@SuppressWarnings("checkstyle:MultipleStringLiterals")
-@Disabled // Temporarily disabled while working on adapting `if` from metamorph
-public class MetafixRecordTest {
-
-    @RegisterExtension
-    private MockitoRule mockitoRule = MockitoJUnit.rule();
-
-    @Mock
-    private StreamReceiver streamReceiver;
-
-    public MetafixRecordTest() {
-    }
-
-    @Test
-    public void ifAnyMatch() {
-        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(//
-                "if any_match('name', '.*University.*')", //
-                "  add_field('type', 'Organization')", //
-                "end"), //
-            i -> {
-                i.startRecord("1");
-                i.literal("name", "Max Musterman");
-                i.endRecord();
-                //
-                i.startRecord("2");
-                i.literal("name", "Some University");
-                i.literal("name", "Filibandrina");
-                i.endRecord();
-            }, o -> {
-                o.get().startRecord("1");
-                o.get().endRecord();
-                //
-                o.get().startRecord("2");
-                o.get().literal("type", "Organization");
-                o.get().endRecord();
-            });
-    }
-
-    @Test
-    public void ifAllMatch() {
-        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(//
-                "if all_match('name', '.*University.*')", //
-                "  add_field('type', 'Organization')", //
-                "end"), //
-            i -> {
-                i.startRecord("1");
-                i.literal("name", "Max Musterman");
-                i.literal("name", "A University");
-                i.endRecord();
-                //
-                i.startRecord("2");
-                i.literal("name", "Some University");
-                i.literal("name", "University Filibandrina");
-                i.endRecord();
-            }, o -> {
-                o.get().startRecord("1");
-                o.get().endRecord();
-                //
-                o.get().startRecord("2");
-                o.get().literal("type", "Organization");
-                o.get().endRecord();
-            });
-    }
-
-    @Test
-    public void ifAnyMatchNested() {
-        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(//
-                "if any_match('author.name.label', '.*University.*')", //
-                "  add_field('author.type', 'Organization')", //
-                "end"), //
-            i -> {
-                i.startRecord("1");
-                i.startEntity("author");
-                i.startEntity("name");
-                i.literal("label", "Max Musterman");
-                i.endEntity();
-                i.endEntity();
-                i.endRecord();
-                //
-                i.startRecord("2");
-                i.startEntity("author");
-                i.startEntity("name");
-                i.literal("label", "Some University");
-                i.endEntity();
-                i.endEntity();
-                i.endRecord();
-            }, o -> {
-                o.get().startRecord("1");
-                o.get().endRecord();
-                //
-                o.get().startRecord("2");
-                o.get().startEntity("author");
-                o.get().literal("type", "Organization");
-                o.get().endEntity();
-                o.get().endRecord();
-            });
-    }
-
-    @Test
-    @Disabled // TODO: fix events for this record order
-    public void ifAnyMatchFirst() {
-        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(//
-                "if any_match('name', '.*University.*')", //
-                "  add_field('type', 'Organization')", //
-                "end"), //
-            i -> {
-                i.startRecord("1");
-                i.literal("name", "Some University");
-                i.endRecord();
-                //
-                i.startRecord("2");
-                i.literal("name", "Max Musterman");
-                i.endRecord();
-            }, o -> {
-                o.get().startRecord("1");
-                o.get().literal("type", "Organization");
-                o.get().endRecord();
-                //
-                o.get().startRecord("2");
-                o.get().endRecord();
-            });
-    }
-
-    @Test
-    @Disabled // TODO: support else block
-    public void ifAnyMatchElse() {
-        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(//
-                "if any_match('name', '.*University.*')", //
-                "  add_field('type', 'Organization')", //
-                "else", //
-                "  add_field('type', 'Person')", //
-                "end"), //
-            i -> {
-                i.startRecord("1");
-                i.literal("name", "Max Musterman");
-                i.endRecord();
-                //
-                i.startRecord("2");
-                i.literal("name", "Some University");
-                i.endRecord();
-            }, o -> {
-                o.get().startRecord("1");
-                o.get().literal("type", "Person");
-                o.get().endRecord();
-                //
-                o.get().startRecord("2");
-                o.get().literal("type", "Organization");
-                o.get().endRecord();
-            });
-    }
-
-    @Test
-    @Disabled // TODO: support elsif block
-    public void ifAnyMatchElsif() {
-        MetafixTestHelpers.assertFix(streamReceiver, Arrays.asList(//
-                "if any_match('name', '.*University.*')", //
-                "  add_field('type', 'Organization')", //
-                "elsif any_match('name', '[^ ]* [^ ]*')", //
-                "  add_field('type', 'Person')", //
-                "else", //
-                "  add_field('type', 'Unknown')", //
-                "end"), //
-            i -> {
-                i.startRecord("1");
-                i.literal("name", "Max Musterman");
-                i.endRecord();
-                //
-                i.startRecord("2");
-                i.literal("name", "Some University");
-                i.endRecord();
-                //
-                i.startRecord("3");
-                i.literal("name", "Filibandrina");
-                i.endRecord();
-            }, o -> {
-                o.get().startRecord("1");
-                o.get().literal("type", "Person");
-                o.get().endRecord();
-                //
-                o.get().startRecord("2");
-                o.get().literal("type", "Organization");
-                o.get().endRecord();
-                //
-                o.get().startRecord("3");
-                o.get().literal("type", "Unknown");
-                o.get().endRecord();
-            });
-    }
-}
diff --git a/settings.gradle b/settings.gradle
index 8e27d0f0..cd77d6b0 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -3,4 +3,4 @@ include 'org.metafacture.fix.ide'
 include 'org.metafacture.fix.web'
 
 // change subproject name
-project(":org.metafacture.fix").name = "metafacture-fix"
+project(":org.metafacture.fix").name = "metafix"