Add equivalent Verifier

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/BoundaryUtils.java

 package de.unikoblenz.fgbks.base.utils.boundary;
 
 import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnValue;
+import java.util.Optional;
 
 public class BoundaryUtils {
 
-  public static Boundary parseBoundary(VDmnValue dmnValue) {
-    return null;
+  public static Optional<Boundary> parseBoundary(VDmnValue dmnValue) {
+    return Optional.empty();
   }
 
-  public static Boundary combineBoundaries(Boundary b1, Boundary b2) {
-    return null;
+  public static Optional<Boundary> combineBoundaries(Boundary b1, Boundary b2) {
+    return Optional.empty();
   }
 
-  public static Boundary appendBoundaries(Boundary b1, Boundary b2) {
-    return null;
+  public static Optional<Boundary> appendBoundaries(Boundary b1, Boundary b2) {
+    return Optional.empty();
   }
 
-  public static Boundary createBoundariesBetween(Boundary b1, Boundary b2) {
-    return null;
+  public static Optional<Boundary> createBoundariesBetween(Boundary b1, Boundary b2) {
+    return Optional.empty();
   }
 
-  public static Boundary createBoundaryLower(Boundary b1, Boundary b2) {
-    return null;
+  public static Optional<Boundary> createBoundaryLower(Boundary b1, Boundary b2) {
+    return Optional.empty();
   }
 }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/domain/vdmn/VDmnValue.java

@@ -40,6 +40,6 @@ public interface VDmnValue extends VDmnElement {
   }
 
   default boolean isOutputValue() {
-    return getDmnColumn() instanceof VDmnInputColumn;
+    return getDmnColumn() instanceof VDmnOutputColumn;
   }
 }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/utils/DmnObjectContainer.java

@@ -4,7 +4,6 @@ import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnDefinition;
 import java.util.List;
 import org.camunda.bpm.dmn.engine.DmnDecision;
 import org.camunda.bpm.model.dmn.DmnModelInstance;
-import org.camunda.bpm.model.dmn.instance.Decision;
 
 public class DmnObjectContainer {
 
@@ -20,7 +19,7 @@ public class DmnObjectContainer {
     return dmnModel;
   }
 
-  public VDmnDefinition getvDmnDefinition() {
+  public VDmnDefinition getVDmnDefinition() {
     return vDmnDefinition;
   }
 
@@ -30,11 +29,4 @@ public class DmnObjectContainer {
     this.dmnModel = dmnModel;
     this.vDmnDefinition = vDmnDefinition;
   }
-
-  // TODO: delete!
-  public void x() {
-    dmnModel.getModelElementsByType(Decision.class).stream()
-        .map(a -> a.getId())
-        .forEach(System.out::println);
-  }
 }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/verification/verifier/impl/DateVerifier.java

@@ -24,7 +24,7 @@ public class DateVerifier extends AbstractVerifier {
   @Override
   protected void doVerification() {
     List<VDmnColumn> dateColumns =
-        VDmnFunctions.getColumnsByTypeRef(dmnObjectContainer.getvDmnDefinition(), VTypeRef.DATE);
+        VDmnFunctions.getColumnsByTypeRef(dmnObjectContainer.getVDmnDefinition(), VTypeRef.DATE);
     for (VDmnColumn dateColumn : dateColumns) {
       checkDateColumn(dateColumn);
     }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/verification/verifier/impl/EmptyOutputVerifier.java

@@ -18,7 +18,7 @@ public class EmptyOutputVerifier extends AbstractVerifier {
   @Override
   protected void doVerification() {
     for (VDmnOutputColumn outputColumn :
-        VDmnFunctions.getOutputColumns(dmnObjectContainer.getvDmnDefinition())) {
+        VDmnFunctions.getOutputColumns(dmnObjectContainer.getVDmnDefinition())) {
       checkOutputColumn(outputColumn);
     }
   }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/verification/verifier/impl/EquivalentVerifier.java

+package de.unikoblenz.fgbks.core.dmn.verification.verifier.impl;
+
+
+import de.unikoblenz.fgbks.base.utils.boundary.impl.StringBoundary;
+import de.unikoblenz.fgbks.base.wordnet.WordnetService;
+import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnColumn;
+import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnInputValue;
+import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnValue;
+import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VTypeRef;
+import de.unikoblenz.fgbks.core.dmn.domain.vdmn.utils.VDmnFunctions;
+import de.unikoblenz.fgbks.core.dmn.verification.result.VerificationResultEntry.VerificationClassification;
+import de.unikoblenz.fgbks.core.dmn.verification.result.VerificationResultEntryElement;
+import de.unikoblenz.fgbks.core.dmn.verification.verifier.AbstractVerifier;
+import de.unikoblenz.fgbks.core.dmn.verification.verifier.DmnVerifier;
+import de.unikoblenz.fgbks.core.dmn.verification.verifier.config.DefaultConfiguration;
+import de.unikoblenz.fgbks.core.dmn.verification.verifier.types.EquivalentStringVerification;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@DmnVerifier(
+    verifierType = EquivalentStringVerification.class,
+    verifierConfig = DefaultConfiguration.class)
+public class EquivalentVerifier extends AbstractVerifier {
+
+  WordnetService wordnetService;
+
+  @Override
+  protected void doVerification() {
+    wordnetService = WordnetService.getInstance();
+    VDmnFunctions.getColumnsByTypeRef(dmnObjectContainer.getVDmnDefinition(), VTypeRef.STRING)
+        .forEach(this::checkStringColumnForSynonyms);
+  }
+
+  private void checkStringColumnForSynonyms(VDmnColumn c) {
+    List<String> stringVals = new ArrayList<>();
+    List<String> stringValsInner = new ArrayList<>();
+    List<VDmnValue> values = c.getValues();
+    for (int i = 0; i < values.size(); i++) {
+      VDmnValue v1 = values.get(i);
+      if (!v1.getText().isEmpty()) {
+        stringVals.clear();
+        if (v1.isOutputValue()) {
+          stringVals.add(v1.getText().replace('"', '\0').trim());
+        } else {
+          stringVals.addAll(
+              Arrays.asList(((StringBoundary) ((VDmnInputValue) v1).getBoundary()).getValues()));
+        }
+        for (int u = i + 1; u < values.size(); u++) {
+          VDmnValue v2 = values.get(u);
+          if (!v2.getText().isEmpty()) {
+            stringValsInner.clear();
+            if (v2.isOutputValue()) {
+              stringValsInner.add(v2.getText().replace('"', '\0').trim());
+            } else {
+              stringValsInner.addAll(
+                  Arrays.asList(
+                      ((StringBoundary) ((VDmnInputValue) v2).getBoundary()).getValues()));
+            }
+            compareStrings(v1, v2, stringVals, stringValsInner);
+          }
+        }
+      }
+    }
+  }
+
+  private void compareStrings(
+      VDmnValue v1, VDmnValue v2, List<String> stringVals, List<String> stringValsInner) {
+    for (int i = 0; i < stringVals.size(); i++) {
+      for (int u = 0; u < stringValsInner.size(); u++) {
+        if (wordnetService.areNounsSynonyms(stringVals.get(i), stringValsInner.get(u))) {
+          vref.addElement(VerificationResultEntryElement.create(v1));
+          vref.addElement(VerificationResultEntryElement.create(v2));
+          vref.addToEntry(
+              VerificationClassification.WARNING,
+              "String values %s and %s might be equivalent.",
+              stringVals.get(i),
+              stringValsInner.get(u));
+        }
+      }
+    }
+  }
+}

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/verification/verifier/impl/IdenticalVerifier.java

@@ -28,7 +28,7 @@ public class IdenticalVerifier extends AbstractVerifier {
 
   @Override
   protected void doVerification() {
-    for (VDmnDecision decision : dmnObjectContainer.getvDmnDefinition().getDmnDecisions()) {
+    for (VDmnDecision decision : dmnObjectContainer.getVDmnDefinition().getDmnDecisions()) {
       checkDecisionTable(decision.getDmnDecisionTable());
     }
   }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/verification/verifier/impl/InputValueSyntaxVerifier.java

@@ -17,7 +17,7 @@ public class InputValueSyntaxVerifier extends AbstractVerifier {
 
   @Override
   protected void doVerification() {
-    dmnObjectContainer.getvDmnDefinition().getDmnDecisions().stream()
+    dmnObjectContainer.getVDmnDefinition().getDmnDecisions().stream()
         .flatMap(
             d ->
                 d.getDmnDecisionTable().getRules().stream()

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/verification/verifier/types/EquivalentStringVerification.java

+package de.unikoblenz.fgbks.core.dmn.verification.verifier.types;
+
+import static de.unikoblenz.fgbks.core.dmn.verification.verifier.types.VerificationTypeClassification.DECISION_LOGIC_LEVEL_VERIFICATION;
+
+import de.unikoblenz.fgbks.base.domain.Description;
+import de.unikoblenz.fgbks.base.domain.Name;
+import javax.validation.constraints.NotNull;
+
+public class EquivalentStringVerification extends AbstractVerificationType {
+
+  @Override
+  public @NotNull VerificationTypeClassification getClassification() {
+    return DECISION_LOGIC_LEVEL_VERIFICATION;
+  }
+
+  @Override
+  public @NotNull Name getName() {
+    return new Name(this.getClass().getSimpleName());
+  }
+
+  @Override
+  public @NotNull Description getDescription() {
+    return new Description("test");
+  }
+}