[DROOLS-7635] ansible-rulebook : Raise an error when a condition compares incompatible types

drools-ansible-rulebook-integration-api/src/main/java/org/drools/ansible/rulebook/integration/api/domain/RuleGenerationContext.java

@@ -39,6 +39,8 @@ public class RuleGenerationContext {
 
     private final StackedContext<String, PrototypeDSL.PrototypePatternDef> patterns = new StackedContext<>();
 
+    private String ruleSetName;
+
     private String ruleName;
 
     private int bindingsCounter = 0;
@@ -209,11 +211,20 @@ public void setRuleName(String ruleName) {
         this.ruleName = ruleName;
     }
 
+    public String getRuleSetName() {
+        return ruleSetName;
+    }
+
+    public void setRuleSetName(String ruleSetName) {
+        this.ruleSetName = ruleSetName;
+    }
+
     List<Rule> toExecModelRules(RulesSet rulesSet, org.drools.ansible.rulebook.integration.api.domain.Rule ansibleRule, RulesExecutionController rulesExecutionController, AtomicInteger ruleCounter) {
     	updateContextFromRule(ansibleRule);
 	    if (getRuleName() == null) {
 	        setRuleName("r_" + ruleCounter.getAndIncrement());
 	    }
+        setRuleSetName(rulesSet.getName());
 
 	    List<org.drools.model.Rule> rules = createRules(rulesExecutionController);
 	    if (hasTemporalConstraint(ansibleRule)) {

drools-ansible-rulebook-integration-api/src/main/java/org/drools/ansible/rulebook/integration/api/domain/conditions/MapCondition.java

@@ -218,6 +218,7 @@ private ParsedCondition parseSingle(RuleGenerationContext ruleContext, Map.Entry
 
     private ParsedCondition parseExpression(RuleGenerationContext ruleContext, String expressionName, Map<?, ?> expression) {
         RulebookOperator operator = decodeOperation(ruleContext, expressionName);
+        operator.setConditionContext(ruleContext, expression);
 
         if (operator instanceof ConditionFactory) {
             if (expression.get("lhs") != null) {
@@ -261,17 +262,17 @@ private static void throwExceptionIfCannotInverse(RulebookOperator operator, Rul
     private static RulebookOperator decodeOperation(RuleGenerationContext ruleContext, String expressionName) {
         switch (expressionName) {
             case "EqualsExpression":
-                return RulebookOperator.EQUAL;
+                return RulebookOperator.newEqual();
             case "NotEqualsExpression":
-                return RulebookOperator.NOT_EQUAL;
+                return RulebookOperator.newNotEqual();
             case "GreaterThanExpression":
-                return RulebookOperator.GREATER_THAN;
+                return RulebookOperator.newGreaterThan();
             case "GreaterThanOrEqualToExpression":
-                return RulebookOperator.GREATER_OR_EQUAL;
+                return RulebookOperator.newGreaterOrEqual();
             case "LessThanExpression":
-                return RulebookOperator.LESS_THAN;
+                return RulebookOperator.newLessThan();
             case "LessThanOrEqualToExpression":
-                return RulebookOperator.LESS_OR_EQUAL;
+                return RulebookOperator.newLessOrEqual();
             case ExistsField.EXPRESSION_NAME:
                 return ExistsField.INSTANCE;
             case ExistsField.NEGATED_EXPRESSION_NAME:

drools-ansible-rulebook-integration-api/src/main/java/org/drools/ansible/rulebook/integration/api/domain/constraints/RulebookConstraintOperator.java

@@ -0,0 +1,186 @@
+package org.drools.ansible.rulebook.integration.api.domain.constraints;
+
+import java.util.Map;
+import java.util.function.BiPredicate;
+
+import org.drools.ansible.rulebook.integration.api.domain.RuleGenerationContext;
+import org.drools.model.ConstraintOperator;
+import org.drools.model.Index;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.drools.model.util.OperatorUtils.areEqual;
+import static org.drools.model.util.OperatorUtils.compare;
+
+public class RulebookConstraintOperator implements ConstraintOperator {
+
+    private static final Logger LOG = LoggerFactory.getLogger(RulebookConstraintOperator.class);
+
+    private Index.ConstraintType type;
+    private ConditionContext conditionContext;
+    private boolean typeCheckLogged = false;
+
+    public RulebookConstraintOperator(Index.ConstraintType type) {
+        this.type = type;
+    }
+
+    public void setConditionContext(RuleGenerationContext ruleContext, Map<?, ?> expression) {
+        this.conditionContext = new ConditionContext(ruleContext.getRuleSetName(), ruleContext.getRuleName(), expression.toString());
+    }
+
+    @Override
+    public boolean containsConstraintType() {
+        return true;
+    }
+
+    @Override
+    public Index.ConstraintType getConstraintType() {
+        return type;
+    }
+
+    public RulebookConstraintOperator negate() {
+        switch (this.type) {
+            case EQUAL:
+                this.type = Index.ConstraintType.NOT_EQUAL;
+                return this;
+            case NOT_EQUAL:
+                this.type = Index.ConstraintType.EQUAL;
+                return this;
+            case GREATER_THAN:
+                this.type = Index.ConstraintType.LESS_OR_EQUAL;
+                return this;
+            case GREATER_OR_EQUAL:
+                this.type = Index.ConstraintType.LESS_THAN;
+                return this;
+            case LESS_OR_EQUAL:
+                this.type = Index.ConstraintType.GREATER_THAN;
+                return this;
+            case LESS_THAN:
+                this.type = Index.ConstraintType.GREATER_OR_EQUAL;
+                return this;
+        }
+        this.type = Index.ConstraintType.UNKNOWN;
+        return this;
+    }
+
+    public boolean canInverse() {
+        switch (this.type) {
+            case EQUAL:
+            case NOT_EQUAL:
+            case GREATER_THAN:
+            case GREATER_OR_EQUAL:
+            case LESS_THAN:
+            case LESS_OR_EQUAL:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    @Override
+    public <T, V> BiPredicate<T, V> asPredicate() {
+        final BiPredicate<T, V> predicate;
+        switch (this.type) {
+            case EQUAL:
+                predicate = (t, v) -> areEqual(t, v);
+                break;
+            case NOT_EQUAL:
+                predicate = (t, v) -> !areEqual(t, v);
+                break;
+            case GREATER_THAN:
+                predicate = (t,v) -> t != null && compare(t, v) > 0;
+                break;
+            case GREATER_OR_EQUAL:
+                predicate = (t,v) -> t != null && compare(t, v) >= 0;
+                break;
+            case LESS_THAN:
+                predicate = (t,v) -> t != null && compare(t, v) < 0;
+                break;
+            case LESS_OR_EQUAL:
+                predicate = (t,v) -> t != null && compare(t, v) <= 0;
+                break;
+            default:
+                throw new UnsupportedOperationException("Cannot convert " + this + " into a predicate");
+        }
+        return (t, v) -> predicateWithTypeCheck(t, v, predicate);
+    }
+
+    private <T, V> boolean predicateWithTypeCheck(T t, V v, BiPredicate<T, V> predicate) {
+        if (t == null
+                || v == null
+                || t instanceof Number && v instanceof Number
+                || t.getClass() == v.getClass()) {
+            return predicate.test(t, v);
+        } else {
+            if (!typeCheckLogged) {
+                // TODO: rewrite the message to be python friendly
+                LOG.error("Cannot compare values of different types: {} and {}. RuleSet: {}. RuleName: {}. Condition: {}",
+                          t.getClass(), v.getClass(), conditionContext.getRuleSet(), conditionContext.getRuleName(), conditionContext.getConditionExpression());
+                typeCheckLogged = true; // Log only once per constraint
+            }
+            return false; // Different types are never equal
+        }
+    }
+
+    public RulebookConstraintOperator inverse() {
+        switch (this.type) {
+            case GREATER_THAN:
+                this.type = Index.ConstraintType.LESS_THAN;
+                return this;
+            case GREATER_OR_EQUAL:
+                this.type =  Index.ConstraintType.LESS_OR_EQUAL;
+                return this;
+            case LESS_THAN:
+                this.type = Index.ConstraintType.GREATER_THAN;
+                return this;
+            case LESS_OR_EQUAL:
+                this.type = Index.ConstraintType.GREATER_OR_EQUAL;
+                return this;
+            default:
+                return this;
+        }
+    }
+
+    public boolean isComparison() {
+        return isAscending() || isDescending();
+    }
+
+    public boolean isAscending() {
+        return this.type == Index.ConstraintType.GREATER_THAN || this.type == Index.ConstraintType.GREATER_OR_EQUAL;
+    }
+
+    public boolean isDescending() {
+        return this.type == Index.ConstraintType.LESS_THAN || this.type == Index.ConstraintType.LESS_OR_EQUAL;
+    }
+
+    private class ConditionContext {
+
+        private String ruleSet;
+        private String ruleName;
+        private String conditionExpression;
+
+        public ConditionContext(String ruleSet, String ruleName, String conditionExpression) {
+            this.ruleSet = ruleSet;
+            this.ruleName = ruleName;
+            this.conditionExpression = conditionExpression;
+        }
+
+        public String getRuleSet() {
+            return ruleSet;
+        }
+
+        public String getRuleName() {
+            return ruleName;
+        }
+
+        public String getConditionExpression() {
+            return conditionExpression;
+        }
+    }
+
+    @Override
+    public String toString() {
+        // works for node sharing
+        return type.toString();
+    }
+}

drools-ansible-rulebook-integration-api/src/main/java/org/drools/ansible/rulebook/integration/api/domain/constraints/RulebookOperator.java

@@ -1,10 +1,12 @@
 package org.drools.ansible.rulebook.integration.api.domain.constraints;
 
+import java.util.Map;
+import java.util.function.BiPredicate;
+
+import org.drools.ansible.rulebook.integration.api.domain.RuleGenerationContext;
 import org.drools.model.ConstraintOperator;
 import org.drools.model.Index;
 
-import java.util.function.BiPredicate;
-
 public interface RulebookOperator extends ConstraintOperator {
 
     default boolean canInverse() {
@@ -19,17 +21,42 @@ default ConstraintOperator asConstraintOperator() {
         return this;
     }
 
-    RulebookOperator EQUAL = new OperatorWrapper(Index.ConstraintType.EQUAL);
-    RulebookOperator NOT_EQUAL = new OperatorWrapper(Index.ConstraintType.NOT_EQUAL);
-    RulebookOperator GREATER_THAN = new OperatorWrapper(Index.ConstraintType.GREATER_THAN);
-    RulebookOperator GREATER_OR_EQUAL = new OperatorWrapper(Index.ConstraintType.GREATER_OR_EQUAL);
-    RulebookOperator LESS_THAN = new OperatorWrapper(Index.ConstraintType.LESS_THAN);
-    RulebookOperator LESS_OR_EQUAL = new OperatorWrapper(Index.ConstraintType.LESS_OR_EQUAL);
+    static RulebookOperator newEqual() {
+        return new OperatorWrapper(new RulebookConstraintOperator(Index.ConstraintType.EQUAL));
+    }
+
+    static RulebookOperator newNotEqual() {
+        return new OperatorWrapper(new RulebookConstraintOperator(Index.ConstraintType.NOT_EQUAL));
+    }
+
+    static RulebookOperator newGreaterThan() {
+        return new OperatorWrapper(new RulebookConstraintOperator(Index.ConstraintType.GREATER_THAN));
+    }
+
+    static RulebookOperator newGreaterOrEqual() {
+        return new OperatorWrapper(new RulebookConstraintOperator(Index.ConstraintType.GREATER_OR_EQUAL));
+    }
+
+    static RulebookOperator newLessThan() {
+        return new OperatorWrapper(new RulebookConstraintOperator(Index.ConstraintType.LESS_THAN));
+    }
+
+    static RulebookOperator newLessOrEqual() {
+        return new OperatorWrapper(new RulebookConstraintOperator(Index.ConstraintType.LESS_OR_EQUAL));
+    }
+
+    default void setConditionContext(RuleGenerationContext ruleContext, Map<?, ?> expression) {
+        if (this instanceof OperatorWrapper operatorWrapper) {
+            operatorWrapper.setConditionContext(ruleContext, expression);
+        } else {
+            // do nothing
+        }
+    }
 
     class OperatorWrapper implements RulebookOperator {
-        private final Index.ConstraintType delegate;
+        private final RulebookConstraintOperator delegate;
 
-        public OperatorWrapper(Index.ConstraintType delegate) {
+        public OperatorWrapper(RulebookConstraintOperator delegate) {
             this.delegate = delegate;
         }
 
@@ -52,5 +79,10 @@ public RulebookOperator inverse() {
         public ConstraintOperator asConstraintOperator() {
             return delegate;
         }
+
+        @Override
+        public void setConditionContext(RuleGenerationContext ruleContext, Map<?, ?> expression) {
+            delegate.setConditionContext(ruleContext, expression);
+        }
     }
 }