Merge branch 'develop'

Author: schlick

.gitignore

@@ -1 +1,2 @@
-/coverage
+Gemfile.lock
+coverage

CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+All notable changes to this gem will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [1.6.0] - 2022-12-13
+### Added
+- Multiple outcomes: the ability to continue walking a tree, returning all outcomes instead of stopping at the first outcome

Gemfile

@@ -1,3 +1,5 @@
 source "https://rubygems.org"
-gem 'boolean_dsl', github: 'jobready/boolean_dsl', branch: 'develop'
 gemspec
+
+gem 'boolean_dsl', github: 'jobready/boolean_dsl', branch: 'develop'
+gem 'simplecov', group: :test, require: nil

Gemfile.lock

@@ -24,20 +24,39 @@ Or install it yourself as:
 
 ## Usage
 
-Require everything
+Single outcome:
 
 ```ruby
-require 'rules_engine'
-    @name = options.fetch(:name)
-    @reference = options.fetch(:reference)
-    @parameter = options.fetch(:parameter)
-
-true_outcome = RulesEngine::Outcome.new(reference:'some category', name:'true outcome',parameter:'some parameter')
-false_outcome = RulesEngine::Outcome.new(reference:'some category', 'name:false outcome', parameter:'another parameter')
-root_rule = RulesEngine::Condition.new(name:'condition name', condition:'2 > 1', when_true:true_outcome, when_false:false_outcome)
-set = RulesEngine::Set.new(root:root_rule, name:'rule set name')
-walker = RulesEngine::Walker.new(set:set, object:some_object)
+true_outcome = RulesEngine::Outcome.new(name: "Outcome 1", values: "Outcome 1 Values")
+false_outcome = RulesEngine::Outcome.new(name: "Outcome 2", values: "Outcome 2 Values")
+root = RulesEngine::Condition.new(name: "Root", condition: "2 > 1", when_true: true_outcome, when_false: false_outcome)
+set = RulesEngine::Set.new(name: "Single Outcome", root: root)
+walker = RulesEngine::Walker.new(set: set, event_logger: nil)
 walker.walk
+
+# Executing Rule Set Single Outcome
+# Evaluated condition 2 > 1, result is true (overridden: false)
+# => #<RulesEngine::Outcome:... @name="Outcome 1", @values="Outcome 1 Values">
+```
+
+Multiple outcomes:
+
+```ruby
+outcome_1 = RulesEngine::Outcome.new(name: "Outcome 1", values: "Outcome 1 Values")
+outcome_2 = RulesEngine::Outcome.new(name: "Outcome 2", values: "Outcome 2 Values")
+outcome_3 = RulesEngine::Outcome.new(name: "Outcome 3", values: "Outcome 3 Values")
+outcome_4 = RulesEngine::Outcome.new(name: "Outcome 4", values: "Outcome 4 Values")
+condition_1 = RulesEngine::Condition.new(name: "Condition 1", condition: "2 < 1", when_true_outcome: outcome_3, when_false_outcome: outcome_4)
+root = RulesEngine::Condition.new(name: "Root", condition: "2 > 1", when_true_outcome: outcome_1, when_true_condition: condition_1, when_false_outcome: outcome_2, when_false_condition: condition_1)
+set = RulesEngine::Set.new(name: "Multiple Outcomes", root: root, multiple_outcomes: true)
+walker = RulesEngine::Walker.new(set: set, event_logger: nil)
+walker.walk
+
+# Executing Rule Set Multiple Outcomes
+# Evaluated condition 2 > 1, result is true (overridden: false)
+# Evaluated condition 2 < 1, result is false (overridden: false)
+# => [#<RulesEngine::Outcome:... @name="Outcome 1", @values="Outcome 1 Values">,
+      #<RulesEngine::Outcome:... @name="Outcome 4", @values="Outcome 4 Values">]
 ```
 
 ## Contributing

README.md

@@ -1,5 +1,14 @@
 class RulesEngine::Condition
-  attr_accessor :name, :condition, :when_true, :when_false, :original, :override
+  attr_accessor :name,
+                :condition,
+                :when_true,
+                :when_false,
+                :original,
+                :override,
+                :when_true_outcome,
+                :when_false_outcome,
+                :when_true_condition,
+                :when_false_condition
 
   def initialize(options = {})
     @name = options.fetch(:name)
@@ -8,6 +17,10 @@ def initialize(options = {})
     @when_false = options.fetch(:when_false, nil)
     @original = options.fetch(:original, nil)
     @override = options.fetch(:override, nil)
+    @when_true_outcome = options.fetch(:when_true_outcome, nil)
+    @when_false_outcome = options.fetch(:when_false_outcome, nil)
+    @when_true_condition = options.fetch(:when_true_condition, nil)
+    @when_false_condition = options.fetch(:when_false_condition, nil)
   end
 
   def override?
@@ -25,5 +38,14 @@ def execute(context)
   def outcome(which)
     which ? when_true : when_false
   end
+
+  # For sets with multiple outcomes
+  def outcomes(which)
+    if which
+      [when_true_outcome, when_true_condition]
+    else
+      [when_false_outcome, when_false_condition]
+    end
+  end
 end
 

lib/rules_engine/condition.rb

@@ -1,9 +1,13 @@
 class RulesEngine::Outcome
-  attr_accessor :name, :values, :reference
+  attr_accessor :name,
+                :values,
+                :reference,
+                :original
 
   def initialize(options = {})
     @name = options.fetch(:name)
     @values = options.fetch(:values)
     @reference = options.fetch(:reference, nil)
+    @original = options.fetch(:original, nil)
   end
 end

lib/rules_engine/outcome.rb

@@ -1,8 +1,17 @@
 class RulesEngine::Set
-  attr_reader :root, :name
+  attr_reader :name,
+              :root,
+              :original,
+              :multiple_outcomes
 
   def initialize(options = {})
     @root = options.fetch(:root)
     @name = options.fetch(:name)
+    @original = options.fetch(:original, nil)
+    @multiple_outcomes = options.fetch(:multiple_outcomes, false)
+  end
+
+  def multiple_outcomes?
+    multiple_outcomes
   end
 end

lib/rules_engine/set.rb

@@ -1,3 +1,3 @@
 module RulesEngine
-  VERSION = '1.3.0'
+  VERSION = '1.6.0'
 end

lib/rules_engine/version.rb

@@ -20,16 +20,33 @@ def walk_set(set)
     logger.info("Executing Rule Set #{set.name}")
 
     node = set.root
+    outcome = nil
+    condition = nil
+    outcomes = []
+
     loop do
-      unless node.is_a?(RulesEngine::Condition)
-        add_event(set, node, nil) if node
-        return node
+      if set.multiple_outcomes?
+        if outcome
+          add_event(set, outcome, nil)
+          outcomes << outcome
+        end
+        return outcomes unless node
+      else
+        unless node.is_a?(RulesEngine::Condition)
+          add_event(set, node, nil) if node
+          return node
+        end
       end
 
       which = node.execute(context)
       logger.info("Evaluated condition #{node.condition}, result is #{which} (overridden: #{node.override?})")
       add_event(set, node, which)
-      node = node.outcome(which)
+
+      if set.multiple_outcomes?
+        outcome, node = node.outcomes(which)
+      else
+        node = node.outcome(which)
+      end
     end
   end