add DefaultRuleListener for logging

easy-rules-core/src/main/java/org/jeasy/rules/core/DefaultRuleListener.java

@@ -0,0 +1,66 @@
+/**
+ * The MIT License
+ *
+ *  Copyright (c) 2017, Mahmoud Ben Hassine (mahmoud.benhassine@icloud.com)
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *  THE SOFTWARE.
+ */
+package org.jeasy.rules.core;
+
+import org.jeasy.rules.api.Facts;
+import org.jeasy.rules.api.Rule;
+import org.jeasy.rules.api.RuleListener;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+class DefaultRuleListener implements RuleListener {
+
+    private static final Logger LOGGER = Logger.getLogger(DefaultRuleListener.class.getName());
+
+    @Override
+    public boolean beforeEvaluate(Rule rule, Facts facts) {
+        return true;
+    }
+
+    @Override
+    public void afterEvaluate(Rule rule, Facts facts, boolean evaluationResult) {
+        String ruleName = rule.getName();
+        if (evaluationResult) {
+            LOGGER.log(Level.INFO, "Rule ''{0}'' triggered", ruleName);
+        } else {
+            LOGGER.log(Level.INFO, "Rule ''{0}'' has been evaluated to false, it has not been executed", ruleName);
+        }
+    }
+
+    @Override
+    public void beforeExecute(Rule rule, Facts facts) {
+
+    }
+
+    @Override
+    public void onSuccess(Rule rule, Facts facts) {
+        LOGGER.log(Level.INFO, "Rule ''{0}'' performed successfully", rule.getName());
+    }
+
+    @Override
+    public void onFailure(Rule rule, Facts facts, Exception exception) {
+        LOGGER.log(Level.SEVERE, String.format("Rule '%s' performed with error", rule.getName()), exception);
+    }
+}

easy-rules-core/src/main/java/org/jeasy/rules/core/DefaultRulesEngine.java

@@ -57,11 +57,13 @@ public final class DefaultRulesEngine implements RulesEngine {
     public DefaultRulesEngine() {
         this.parameters = new RulesEngineParameters();
         this.ruleListeners = new ArrayList<>();
+        this.ruleListeners.add(new DefaultRuleListener());
     }
 
     DefaultRulesEngine(final RulesEngineParameters parameters, final List<RuleListener> ruleListeners) {
         this.parameters = parameters;
         this.ruleListeners = ruleListeners;
+        this.ruleListeners.add(new DefaultRuleListener());
         if (parameters.isSilentMode()) {
             Utils.muteLoggers();
         }
@@ -108,39 +110,31 @@ public final class DefaultRulesEngine implements RulesEngine {
     }
 
     private void apply(Rules rules, Facts facts) {
-
         LOGGER.info("Rules evaluation started");
         for (Rule rule : rules) {
-
             final String name = rule.getName();
             final int priority = rule.getPriority();
-
             if (priority > parameters.getPriorityThreshold()) {
                 LOGGER.log(Level.INFO,
                         "Rule priority threshold ({0}) exceeded at rule ''{1}'' with priority={2}, next rules will be skipped",
                         new Object[]{parameters.getPriorityThreshold(), name, priority});
                 break;
             }
-
             if (!shouldBeEvaluated(rule, facts)) {
                 LOGGER.log(Level.INFO, "Rule ''{0}'' has been skipped before being evaluated", name);
                 continue;
             }
             if (rule.evaluate(facts)) {
-                LOGGER.log(Level.INFO, "Rule ''{0}'' triggered", name);
                 triggerListenersAfterEvaluate(rule, facts, true);
                 try {
                     triggerListenersBeforeExecute(rule, facts);
                     rule.execute(facts);
-                    LOGGER.log(Level.INFO, "Rule ''{0}'' performed successfully", name);
                     triggerListenersOnSuccess(rule, facts);
-
                     if (parameters.isSkipOnFirstAppliedRule()) {
                         LOGGER.info("Next rules will be skipped since parameter skipOnFirstAppliedRule is set");
                         break;
                     }
                 } catch (Exception exception) {
-                    LOGGER.log(Level.SEVERE, String.format("Rule '%s' performed with error", name), exception);
                     triggerListenersOnFailure(rule, exception, facts);
                     if (parameters.isSkipOnFirstFailedRule()) {
                         LOGGER.info("Next rules will be skipped since parameter skipOnFirstFailedRule is set");
@@ -148,16 +142,13 @@ public final class DefaultRulesEngine implements RulesEngine {
                     }
                 }
             } else {
-                LOGGER.log(Level.INFO, "Rule ''{0}'' has been evaluated to false, it has not been executed", name);
                 triggerListenersAfterEvaluate(rule, facts, false);
                 if (parameters.isSkipOnFirstNonTriggeredRule()) {
                     LOGGER.info("Next rules will be skipped since parameter skipOnFirstNonTriggeredRule is set");
                     break;
                 }
             }
-
         }
-
     }
 
     private void triggerListenersOnFailure(final Rule rule, final Exception exception, Facts facts) {

easy-rules-core/src/test/java/org/jeasy/rules/core/DefaultRulesEngineTest.java

@@ -193,7 +193,7 @@ public class DefaultRulesEngineTest extends AbstractTest {
                 .build();
 
         assertThat(rulesEngine.getRuleListeners())
-                .containsExactly(ruleListener);
+                .contains(ruleListener);
     }
 
     @After