Refactor Core Components to Improve Readability, Maintainability, and Reduce Code Duplication

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

@@ -73,20 +73,39 @@ public InferenceRulesEngine(RulesEngineParameters parameters) {
 
     @Override
     public void fire(Rules rules, Facts facts) {
-        Objects.requireNonNull(rules, "Rules must not be null");
-        Objects.requireNonNull(facts, "Facts must not be null");
-        Set<Rule> selectedRules;
+        validateInputs(rules, facts);   // replace
+        executeInference(rules, facts);
+
+    }
+    private void executeInference(Rules rules, Facts facts) {
+
+        Set<Rule> selectedRules;                  //add for extract method
+
         do {
+
             LOGGER.debug("Selecting candidate rules based on the following facts: {}", facts);
+
             selectedRules = selectCandidates(rules, facts);
-            if (!selectedRules.isEmpty()) {
-                delegate.fire(new Rules(selectedRules), facts);
-            } else {
-                LOGGER.debug("No candidate rules found for facts: {}", facts);
-            }
+
+            fireSelectedRules(selectedRules, facts);
+
         } while (!selectedRules.isEmpty());
+
     }
+    private void fireSelectedRules(Set<Rule> selectedRules, Facts facts) {
+
+        if (selectedRules.isEmpty()) {                          // add method
+            LOGGER.debug("No candidate rules found for facts: {}", facts);
+            return;
+        }
 
+        delegate.fire(new Rules(selectedRules), facts);
+
+    }
+    private void validateInputs(Rules rules, Facts facts) {
+        Objects.requireNonNull(rules, "Rules must not be null");       //add method for repeated null check and duplicate code
+        Objects.requireNonNull(facts, "Facts must not be null");
+    }
     private Set<Rule> selectCandidates(Rules rules, Facts facts) {
         Set<Rule> candidates = new TreeSet<>();
         for (Rule rule : rules) {
@@ -96,11 +115,10 @@ private Set<Rule> selectCandidates(Rules rules, Facts facts) {
         }
         return candidates;
     }
-
     @Override
     public Map<Rule, Boolean> check(Rules rules, Facts facts) {
-        Objects.requireNonNull(rules, "Rules must not be null");
-        Objects.requireNonNull(facts, "Facts must not be null");
+
+        validateInputs(rules, facts);
         return delegate.check(rules, facts);
     }
 

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

@@ -116,34 +116,49 @@ private boolean isConditionMethodWellDefined(final Method method) {
                 && method.getReturnType().equals(Boolean.TYPE)
                 && validParameters(method);
     }
+    private boolean hasOnlyFactAnnotations(Annotation[][] parameterAnnotations) {
+        for (Annotation[] annotations : parameterAnnotations) {
+            for (Annotation annotation : annotations) {
+                if (!annotation.annotationType().equals(Fact.class)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    private int countNonAnnotatedParameters(Annotation[][] parameterAnnotations) {
+        int count = 0;
 
-    private boolean validParameters(final Method method) {
-        int notAnnotatedParameterCount = 0;
-        Annotation[][] parameterAnnotations = method.getParameterAnnotations();
         for (Annotation[] annotations : parameterAnnotations) {
             if (annotations.length == 0) {
-                notAnnotatedParameterCount += 1;
-            } else {
-                //Annotation types has to be Fact
-                for (Annotation annotation : annotations) {
-                    if (!annotation.annotationType().equals(Fact.class)) {
-                        return false;
-                    }
-                }
+                count++;
             }
         }
-        if (notAnnotatedParameterCount > 1) {
+
+        return count;
+    }
+    private boolean isValidNonAnnotatedParameter(Method method) {
+        Parameter parameter = getNotAnnotatedParameter(method);
+
+        return parameter == null
+                || Facts.class.isAssignableFrom(parameter.getType());
+    }
+    private boolean validParameters(final Method method) {
+        Annotation[][] parameterAnnotations =
+                method.getParameterAnnotations();
+        if (!hasOnlyFactAnnotations(parameterAnnotations)) {
             return false;
         }
-        if (notAnnotatedParameterCount == 1) {
-            Parameter notAnnotatedParameter = getNotAnnotatedParameter(method);
-            if (notAnnotatedParameter != null) {
-                return Facts.class.isAssignableFrom(notAnnotatedParameter.getType());
-            }
+        int nonAnnotatedCount =
+                countNonAnnotatedParameters(parameterAnnotations);
+        if (nonAnnotatedCount > 1) {
+            return false;
+        }
+        if (nonAnnotatedCount == 1) {
+            return isValidNonAnnotatedParameter(method);
         }
         return true;
     }
-
     private Parameter getNotAnnotatedParameter(Method method) {
         Parameter[] parameters = method.getParameters();
         for (Parameter parameter : parameters) {