Merge pull request #51 from metafacture/35-record

Basic if statements and record mode draft

Author: fsteeg

build.gradle

@@ -32,7 +32,8 @@ subprojects {
       'mockito':        '2.27.0',
       'requirejs':      '2.3.6',
       'slf4j':          '1.7.21',
-      'xtext':          '2.17.0'
+      'xtext':          '2.17.0',
+      'guava':          '29.0-jre'
     ]
   }
 

config/checkstyle/checkstyle.xml

@@ -7,6 +7,7 @@
         <property name="checks" value=".*"/>
         <property name="files" value="xtext-gen"/>
     </module>
+    <module name="SuppressWarningsFilter" />
     <module name="TreeWalker">
         <module name="AbstractClassName"/>
         <module name="AnnotationUseStyle"/>
@@ -145,6 +146,7 @@
             <property name="checkFormat" value="$1"/>
             <property name="commentFormat" value="checkstyle-disable-line (\w+(?:\|\w+)?)"/>
         </module>
+        <module name="SuppressWarningsHolder" />
         <module name="ThrowsCount">
             <property name="max" value="2"/>
         </module>

org.metafacture.fix/build.gradle

@@ -6,6 +6,7 @@ plugins {
 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}"
 
   testCompile "org.junit.jupiter:junit-jupiter-api:${versions.junit_jupiter}"
   testCompile "org.junit.platform:junit-platform-launcher:${versions.junit_platform}"

org.metafacture.fix/src/main/java/org/metafacture/metamorph/FixBuilder.java

@@ -20,9 +20,11 @@
 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;
@@ -31,6 +33,7 @@
 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;
 
@@ -54,6 +57,7 @@ public class FixBuilder { // checkstyle-disable-line ClassDataAbstractionCouplin
     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;
@@ -177,10 +181,12 @@ protected void exitCollectorAndFlushWith(final String flushWith) {
         if (parent.isInEntity()) {
             ((Entity) parent.getPipe()).setNameSource(delegate);
         }
-        // TODO: condition handling, see MorphBuilder
-
-        parent.getPipe().addNamedValueSource(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);
@@ -218,19 +224,72 @@ private void processSubexpressions(final List<Expression> expressions, final Str
             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 {
-            runMetamorphFunction(expression, params);
+            final Options options = ((MethodCall) expression).getOptions();
+            final Map<String, String> attributes = resolvedAttributeMap(params, options);
+            runMetamorphFunction(expression.getName(), attributes);
         }
     }
 
@@ -243,15 +302,15 @@ private FixFunction findFixFunction(final Expression expression) {
         return null;
     }
 
-    private void runMetamorphFunction(final Expression expression, final List<String> params) {
-        final Map<String, String> attributes = resolvedAttributeMap(params, ((MethodCall) expression).getOptions());
-        if (functionFactory.containsKey(expression.getName())) {
+    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(expression.getName(), attributes);
+            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;
@@ -266,7 +325,7 @@ private void runMetamorphFunction(final Expression expression, final List<String
             head.setPipe(function);
         }
         else {
-            throw new IllegalArgumentException(expression.getName() + " not found");
+            throw new IllegalArgumentException(name + " not found");
         }
     }
 
@@ -288,10 +347,12 @@ void exitData() {
         if (parent.isInEntity()) {
             ((Entity) parent.getPipe()).setNameSource(delegate);
         }
-
-        // TODO: condition handling, see MorphBuilder
-
-        parent.getPipe().addNamedValueSource(delegate);
+        else if (parent.isInCondition()) {
+            ((ConditionAware) parent.getPipe()).setConditionSource(delegate);
+        }
+        else {
+            parent.getPipe().addNamedValueSource(delegate);
+        }
     }
 
     NamedValuePipe enterDataMap(final List<String> params, final boolean standalone) {
@@ -356,6 +417,17 @@ void enterDataFunction(final String fieldName, final NamedValuePipe function, fi
         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);
@@ -418,10 +490,20 @@ private static class StackFrame {
 
         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;
         }