Remove OperatorWrapper. Add more assertion. Better error message

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

@@ -0,0 +1,27 @@
+package org.drools.ansible.rulebook.integration.api;
+
+import java.util.Map;
+
+public class LogUtil {
+
+    private LogUtil() {
+        // utility class
+    }
+
+    // convert java class to python class
+    private static Map<Class<?>, String> convertMap = Map.of(
+            java.lang.Integer.class, "int",
+            java.lang.Boolean.class, "bool",
+            java.lang.String.class, "str",
+            java.lang.Double.class, "float",
+            java.util.List.class, "list",
+            java.util.ArrayList.class, "list",
+            java.util.Map.class, "dict",
+            java.util.LinkedHashMap.class, "dict",
+            java.util.HashMap.class, "dict"
+    );
+
+    public static String convertJavaClassToPythonClass(Class<?> javaClass) {
+        return convertMap.getOrDefault(javaClass, javaClass.getSimpleName());
+    }
+}

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

@@ -4,15 +4,15 @@
 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.ansible.rulebook.integration.api.LogUtil.convertJavaClassToPythonClass;
 import static org.drools.model.util.OperatorUtils.areEqual;
 import static org.drools.model.util.OperatorUtils.compare;
 
-public class RulebookConstraintOperator implements ConstraintOperator {
+public class RulebookConstraintOperator implements RulebookOperator {
 
     private static final Logger LOG = LoggerFactory.getLogger(RulebookConstraintOperator.class);
 
@@ -29,17 +29,18 @@ public void setConditionContext(RuleGenerationContext ruleContext, Map<?, ?> exp
     }
 
     @Override
-    public boolean containsConstraintType() {
+    public boolean hasIndex() {
         return true;
     }
 
     @Override
-    public Index.ConstraintType getConstraintType() {
+    public Index.ConstraintType getIndexType() {
         return type;
     }
 
     public RulebookConstraintOperator negate() {
         switch (this.type) {
+            case FORALL_SELF_JOIN:
             case EQUAL:
                 this.type = Index.ConstraintType.NOT_EQUAL;
                 return this;
@@ -113,9 +114,10 @@ private <T, V> boolean predicateWithTypeCheck(T t, V v, BiPredicate<T, V> predic
             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());
+                          convertJavaClassToPythonClass(t.getClass()),
+                          convertJavaClassToPythonClass(v.getClass()),
+                          conditionContext.getRuleSet(), conditionContext.getRuleName(), conditionContext.getConditionExpression());
                 typeCheckLogged = true; // Log only once per constraint
             }
             return false; // Different types are never equal

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

@@ -22,67 +22,34 @@ default ConstraintOperator asConstraintOperator() {
     }
 
     static RulebookOperator newEqual() {
-        return new OperatorWrapper(new RulebookConstraintOperator(Index.ConstraintType.EQUAL));
+        return new RulebookConstraintOperator(Index.ConstraintType.EQUAL);
     }
 
     static RulebookOperator newNotEqual() {
-        return new OperatorWrapper(new RulebookConstraintOperator(Index.ConstraintType.NOT_EQUAL));
+        return new RulebookConstraintOperator(Index.ConstraintType.NOT_EQUAL);
     }
 
     static RulebookOperator newGreaterThan() {
-        return new OperatorWrapper(new RulebookConstraintOperator(Index.ConstraintType.GREATER_THAN));
+        return new RulebookConstraintOperator(Index.ConstraintType.GREATER_THAN);
     }
 
     static RulebookOperator newGreaterOrEqual() {
-        return new OperatorWrapper(new RulebookConstraintOperator(Index.ConstraintType.GREATER_OR_EQUAL));
+        return new RulebookConstraintOperator(Index.ConstraintType.GREATER_OR_EQUAL);
     }
 
     static RulebookOperator newLessThan() {
-        return new OperatorWrapper(new RulebookConstraintOperator(Index.ConstraintType.LESS_THAN));
+        return new RulebookConstraintOperator(Index.ConstraintType.LESS_THAN);
     }
 
     static RulebookOperator newLessOrEqual() {
-        return new OperatorWrapper(new RulebookConstraintOperator(Index.ConstraintType.LESS_OR_EQUAL));
+        return new RulebookConstraintOperator(Index.ConstraintType.LESS_OR_EQUAL);
     }
 
     default void setConditionContext(RuleGenerationContext ruleContext, Map<?, ?> expression) {
-        if (this instanceof OperatorWrapper operatorWrapper) {
-            operatorWrapper.setConditionContext(ruleContext, expression);
+        if (this instanceof RulebookConstraintOperator rulebookConstraintOperator) {
+            rulebookConstraintOperator.setConditionContext(ruleContext, expression);
         } else {
             // do nothing
         }
     }
-
-    class OperatorWrapper implements RulebookOperator {
-        private final RulebookConstraintOperator delegate;
-
-        public OperatorWrapper(RulebookConstraintOperator delegate) {
-            this.delegate = delegate;
-        }
-
-        @Override
-        public <T, V> BiPredicate<T, V> asPredicate() {
-            return delegate.asPredicate();
-        }
-
-        @Override
-        public boolean canInverse() {
-            return delegate.canInverse();
-        }
-
-        @Override
-        public RulebookOperator inverse() {
-            return new OperatorWrapper(delegate.inverse());
-        }
-
-        @Override
-        public ConstraintOperator asConstraintOperator() {
-            return delegate;
-        }
-
-        @Override
-        public void setConditionContext(RuleGenerationContext ruleContext, Map<?, ?> expression) {
-            delegate.setConditionContext(ruleContext, expression);
-        }
-    }
 }

drools-ansible-rulebook-integration-api/src/test/java/org/drools/ansible/rulebook/integration/api/StringPrintStream.java

@@ -0,0 +1,36 @@
+package org.drools.ansible.rulebook.integration.api;
+
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.List;
+
+public class StringPrintStream extends PrintStream {
+
+    public static final String LINE_SEP = System.getProperty("line.separator");
+    PrintStream other;
+    List<String> stringList = new ArrayList<>();
+
+    public StringPrintStream(PrintStream ps) {
+        super(ps);
+        other = ps;
+    }
+
+    public void print(String s) {
+        other.print(s);
+        stringList.add(s);
+    }
+
+    public void println(String s) {
+        other.println(s);
+        stringList.add(s);
+    }
+
+    public void println(Object o) {
+        other.println(o);
+        stringList.add(o.toString());
+    }
+
+    public List<String> getStringList() {
+        return stringList;
+    }
+}