new version for missing rules

dmn-verifier-app/src/main/java/de/unikoblenz/fgbks/dmn/core/verifier/MissingRules.java

@@ -8,9 +8,11 @@ import de.unikoblenz.fgbks.dmn.core.verifier.helper.DataType;
 import de.unikoblenz.fgbks.dmn.core.verifier.helper.Type;
 import de.unikoblenz.fgbks.dmn.core.verifier.helper.Value;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Comparator;
 import java.util.List;
 import java.util.Optional;
+import java.util.stream.Collectors;
 import org.camunda.bpm.dmn.engine.DmnDecision;
 
 public class MissingRules extends AbstractVerifier {
@@ -20,13 +22,33 @@ public class MissingRules extends AbstractVerifier {
   }
 
   @Override
-  protected void beforeVerifyDecision() {}
+  protected void beforeVerifyDecision() {
+  }
 
   @Override
   protected void verifyDecision(DmnDecision d) {
     if (d.isDecisionTable()) {
       List<Type> inputs = new ArrayList<>(ruleMap.getAllInputTypesFromDecisionKey(d.getKey()));
-      checkForMissingRules(d, inputs, 0, null, new ArrayList<>());
+      List<Value[]> missingIntervals = new ArrayList<>();
+      checkForMissingRules(d, inputs, 0, new Value[inputs.size()], missingIntervals);
+      // add errors for missing intervals
+      // TODO: add duplicate rows
+      for (Value[] missingInt : missingIntervals) {
+        StringBuilder sb = new StringBuilder("In table ");
+        sb.append(d.getName()); // TODO: add real name
+        sb.append(" following rule is missing: ");
+        sb.append(Arrays.stream(missingInt)
+            .map(Value::getOrgExpression)
+            .collect(Collectors.joining(" / ")));
+        addVerification(
+            VerificationResult.getBuilder()
+                .addRules(
+                    Arrays.stream(missingInt)
+                        .map(Value::getRuleIdentifier)
+                        .collect(Collectors.toList()))
+                .withMessage(sb.toString())
+                .build());
+      }
     }
   }
 
@@ -34,54 +56,83 @@ public class MissingRules extends AbstractVerifier {
       DmnDecision d,
       List<Type> inputs,
       int i,
-      List<RuleIdentifier> currentRuleIdentifiers,
-      List<Boundary> missingIntervals) {
-    if (inputs.get(i).getDataType() == DataType.NUMBER) {
-
+      Value[] missingValues,
+      List<Value[]> missingIntervals) {
+    if (i == inputs.size()) {
+      missingIntervals.add(missingValues.clone());
+    } else {
       List<Value> sortedBounds =
-          new ArrayList<>(ruleMap.getValuesFromInputType(inputs.get(i), currentRuleIdentifiers));
+          new ArrayList<>(ruleMap.getValuesFromInputType(inputs.get(i)));
       sortedBounds.sort(Comparator.comparing(Value::getBoundary));
 
       Value lastBound = null;
+      int z = 0;
       for (Value currentBound : sortedBounds) {
-        if (lastBound == null) {
-          if (currentBound.getBoundary().getLowerBound() != Double.MIN_VALUE) {
-            missingIntervals.add(currentBound.getBoundary().getNewBoundaryLower().get());
+        z++;
+        Optional<Boundary> newBoundary = Optional.empty();
+        String orgExpr = "";
+        if (inputs.get(i).getDataType() == DataType.NUMBER) {
+          if (lastBound == null) { // check current elements
+            if (currentBound.getBoundary().getLowerBound() != Double.MIN_VALUE) {
+              newBoundary = currentBound.getBoundary().getNewBoundaryLower();
+            }
+          } else {
+            newBoundary =
+                lastBound.getBoundary().getNewBoundaryBetween(currentBound.getBoundary());
+          }
+          if (newBoundary.isPresent()) {
+            orgExpr = newBoundary.get().toString();
           }
         } else {
-          Optional<Boundary> newBound =
-              lastBound.getBoundary().getNewBoundaryBetween(currentBound.getBoundary());
-          newBound.ifPresent(missingIntervals::add);
+          newBoundary = Optional.of(currentBound.getBoundary());
+          orgExpr = currentBound.getOrgExpression();
+        }
+        if (newBoundary.isPresent()) {
+          missingValues[i] = new Value(newBoundary.get(), orgExpr,
+              RuleIdentifier.getBuilder()
+                  .withRowNumber(999)
+                  .withDecision(d)
+                  .withRuleId("newRule")
+                  .build(),
+              inputs.get(i));
+          checkForMissingRules(d, inputs, i + 1, missingValues, missingIntervals);
+          missingValues[i] = null;
+        }
+
+        // TODO: check last element
+        if (z == sortedBounds.size()) {
+          if (inputs.get(i).getDataType() == DataType.NUMBER) {
+            if (currentBound.getBoundary().getUpperBound() != Double.MAX_VALUE) {
+              newBoundary = currentBound.getBoundary().getNewBoundaryUpper();
+              orgExpr = newBoundary.get().toString();
+              missingValues[i] = new Value(newBoundary.get(), orgExpr,
+                  RuleIdentifier.getBuilder()
+                      .withRowNumber(999)
+                      .withDecision(d)
+                      .withRuleId("newRule")
+                      .build(),
+                  inputs.get(i));
+              checkForMissingRules(d, inputs, i + 1, missingValues, missingIntervals);
+              missingValues[i] = null;
+            }
+          } else {
+            // not number TODO
+          }
         }
+        // set next last bound
         if (lastBound == null
             || !lastBound
-                .getBoundary()
-                .isNumberInRange(
-                    currentBound.getBoundary().getUpperBound(),
-                    currentBound.getBoundary().getUpperBoundType())) {
+            .getBoundary()
+            .isNumberInRange(
+                currentBound.getBoundary().getUpperBound(),
+                currentBound.getBoundary().getUpperBoundType())) {
           lastBound = currentBound;
         }
       }
-      if (lastBound != null) {
-        if (lastBound.getBoundary().getUpperBound() != Double.MAX_VALUE) {
-          missingIntervals.add(lastBound.getBoundary().getNewBoundaryUpper().get());
-        }
-      }
-      for (Boundary b : missingIntervals) {
-        addVerification(
-            VerificationResult.getBuilder()
-                .addRule(
-                    RuleIdentifier.getBuilder()
-                        .withRowNumber(999)
-                        .withDecision(d)
-                        .withRuleId("a")
-                        .build())
-                .withMessage("Missing interval: %s", b.toString())
-                .build());
-      }
     }
   }
 
   @Override
-  protected void afterVerifyDecision() {}
+  protected void afterVerifyDecision() {
+  }
 }

dmn-verifier-app/src/main/java/de/unikoblenz/fgbks/dmn/core/verifier/helper/Type.java

@@ -47,7 +47,7 @@ public abstract class Type {
             .withRuleId(ruleId)
             .withConditionId(value.getId())
             .withConditionName(value.getName())
-            .build());
+            .build(), this);
   }
 
   private Boundary getBoundaryValue(DmnExpressionImpl value) {

dmn-verifier-app/src/main/java/de/unikoblenz/fgbks/dmn/core/verifier/helper/Value.java

@@ -8,11 +8,13 @@ public class Value {
   private final Boundary boundary;
   private final String orgExpression;
   private final RuleIdentifier ruleIdentifier;
+  private final Type type;
 
-  Value(Boundary boundary, String orgExpression, RuleIdentifier ruleIdentifier) {
+  public Value(Boundary boundary, String orgExpression, RuleIdentifier ruleIdentifier, Type type) {
     this.boundary = boundary;
     this.orgExpression = orgExpression;
     this.ruleIdentifier = ruleIdentifier;
+    this.type = type;
   }
 
   public Boundary getBoundary() {
@@ -27,6 +29,10 @@ public class Value {
     return ruleIdentifier;
   }
 
+  public Type getType() {
+    return type;
+  }
+
   @Override
   public boolean equals(Object o) {
     if (this == o) {
@@ -48,4 +54,6 @@ public class Value {
   public String toString() {
     return orgExpression;
   }
+
+
 }