philiprehberger-rule_engine 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b150f5bc67b381f5f5a1c88032c5241c4bc83f952c565ceaf5d66baa852d4f65
-  data.tar.gz: 0fc2ae7a0e84089dcfddee3b80d917201924522c249c320bc80dd6bbc317e9f2
+  metadata.gz: 6632ea70fd2a2bd623fdbd89fdd2f1a399254742af0fc9dd737ac3fae82c9e04
+  data.tar.gz: 67207e22ad77f60478e22343957f298bd1c431cb5c8410688087b54bb65b1004
 SHA512:
-  metadata.gz: 99ab211d1ba3beefd989c2c32444fcc40386d72fdaa90963cbb2ae845021db06ebe4b882843ff8eea76f9773879610f47f71fec26044065b165530ae8d387767
-  data.tar.gz: 0b3ab9ec81247acaab0f07b7c44add184aa0437cf650f66c760d99666f3797d3049d4730c788e9a280ef4352a7333546878a0105289fa64933d5b76787c83af1
+  metadata.gz: 4b32d00eedfedbf1e00d49ec7728594d86b222f047135dfd3acbd3d485ff72900b1271e91ac4c358ee40e54f76ffad646e39a3cf939155c9487ac31a4e321087
+  data.tar.gz: 7b9d1b7ef2d0173e1c7385f05b3c3af4db9b7af7c0d1afbc7e6cde4aaa042d47b09fa973509613419bbcf2960ab0749138a2f2318bf842c7321b8bfa6fe45dce

data/CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.0] - 2026-04-10
+
+### Added
+- Rule tagging via `tags:` option on `rule` and `add_rule`
+- `Engine#evaluate(facts, tags:)` and `Engine#dry_run(facts, tags:)` filter by tags (OR logic)
+- `Engine#rules_by_tag(tag)` returns rules with a specific tag
+- Tags included in `Rule#to_h` and restored by `RuleEngine.from_h`
+
 ## [0.3.0] - 2026-04-01
 
 ### Added
@@ -48,3 +56,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - First-match mode to stop after first match
 - Rule evaluation against arbitrary facts
 - Results with rule name and action output
+
+[0.4.0]: https://github.com/philiprehberger/rb-rule-engine/releases/tag/v0.4.0
+[0.3.0]: https://github.com/philiprehberger/rb-rule-engine/releases/tag/v0.3.0
+[0.2.1]: https://github.com/philiprehberger/rb-rule-engine/releases/tag/v0.2.1
+[0.2.0]: https://github.com/philiprehberger/rb-rule-engine/releases/tag/v0.2.0
+[0.1.2]: https://github.com/philiprehberger/rb-rule-engine/releases/tag/v0.1.2
+[0.1.1]: https://github.com/philiprehberger/rb-rule-engine/releases/tag/v0.1.1
+[0.1.0]: https://github.com/philiprehberger/rb-rule-engine/releases/tag/v0.1.0

data/README.md

@@ -100,6 +100,30 @@ engine = Philiprehberger::RuleEngine.new do
 end
 ```
 
+### Rule Tags
+
+Organize rules into categories and selectively evaluate subsets:
+
+```ruby
+engine = Philiprehberger::RuleEngine.new do
+  rule "validate_age", tags: [:validation] do
+    condition { |f| f[:age] >= 18 }
+    action { |_| "valid" }
+  end
+
+  rule "apply_discount", tags: [:pricing] do
+    condition { |f| f[:premium] }
+    action { |_| "discount applied" }
+  end
+end
+
+engine.evaluate(facts, tags: [:validation])   # only validation rules
+engine.dry_run(facts, tags: [:pricing])        # dry run only pricing
+engine.rules_by_tag(:validation)               # list rules with tag
+```
+
+Multiple tags use OR logic — a rule matches if it has any of the specified tags.
+
 ### Dynamic Rule Management
 
 ```ruby
@@ -210,7 +234,7 @@ end
 | `.new(mode:) { }` | Create engine with rule definitions |
 | `.from_h(data, &resolver)` | Reconstruct engine from serialized hash |
 | `#rule(name) { }` | Define a rule with condition and action |
-| `#evaluate(facts)` | Evaluate rules against facts |
+| `#evaluate(facts, tags: nil)` | Evaluate rules against facts; filter by tags if given |
 | `#rules` | Array of registered rules |
 | `#mode` | Current evaluation mode |
 | `#to_h` | Serialize engine configuration to hash |
@@ -221,7 +245,8 @@ end
 | `#chain(*rule_names)` | Execute rules sequentially as a pipeline |
 | `#stats` | Per-rule execution statistics |
 | `#reset_stats!` | Clear all execution statistics |
-| `#dry_run(facts)` | Evaluate rules without executing actions |
+| `#rules_by_tag(tag)` | Return rules with the given tag |
+| `#dry_run(facts, tags: nil)` | Evaluate rules without executing actions |
 | `#detect_conflicts` | Find rule pairs that could both match |
 | `#validate_rules` | Check all rules have conditions and actions |
 

data/lib/philiprehberger/rule_engine/engine.rb

@@ -30,8 +30,8 @@ module Philiprehberger
       # @param name [String] the rule name
       # @yield [rule] block for configuring the rule
       # @return [Rule] the created rule
-      def rule(name, &block)
-        r = Rule.new(name)
+      def rule(name, tags: [], &block)
+        r = Rule.new(name, tags: tags)
         r.instance_eval(&block) if block
         @rules << r
         @stats[name] = new_stat_entry
@@ -41,10 +41,11 @@ module Philiprehberger
       # Add a rule after engine creation.
       #
       # @param name [String] the rule name
+      # @param tags [Array<Symbol>] optional tags
       # @yield [rule] block for configuring the rule
       # @return [Rule] the created rule
-      def add_rule(name, &)
-        rule(name, &)
+      def add_rule(name, tags: [], &block)
+        rule(name, tags: tags, &block)
       end
 
       # Remove a rule by name.
@@ -82,12 +83,21 @@ module Philiprehberger
         found.enabled = true
       end
 
+      # Return rules matching a specific tag.
+      #
+      # @param tag [Symbol] the tag to filter by
+      # @return [Array<Rule>]
+      def rules_by_tag(tag)
+        @rules.select { |r| r.tags.include?(tag.to_sym) }
+      end
+
       # Evaluate all rules against the given facts.
       #
       # @param facts [Object] the facts to evaluate
+      # @param tags [Array<Symbol>, nil] only evaluate rules with at least one matching tag
       # @return [Array<Hash>] results with :rule and :result for each matched rule
-      def evaluate(facts)
-        sorted = @rules.select(&:enabled).sort_by(&:priority)
+      def evaluate(facts, tags: nil)
+        sorted = filter_by_tags(@rules.select(&:enabled), tags).sort_by(&:priority)
         results = []
 
         sorted.each do |r|
@@ -139,8 +149,8 @@ module Philiprehberger
       #
       # @param facts [Hash] the facts to evaluate
       # @return [Array<Hash>] matched rules with name and priority
-      def dry_run(facts)
-        matched = enabled_rules_sorted.select { |rule| rule.matches?(facts) }
+      def dry_run(facts, tags: nil)
+        matched = filter_by_tags(enabled_rules_sorted, tags).select { |rule| rule.matches?(facts) }
         matched = [matched.first].compact if @mode == :first
         matched.map { |rule| { name: rule.name, priority: rule.priority } }
       end
@@ -203,6 +213,13 @@ module Philiprehberger
 
       private
 
+      def filter_by_tags(rules, tags)
+        return rules unless tags
+
+        tag_syms = tags.map(&:to_sym)
+        rules.select { |r| r.tags.intersect?(tag_syms) }
+      end
+
       def enabled_rules_sorted
         @rules.select(&:enabled).sort_by(&:priority)
       end

data/lib/philiprehberger/rule_engine/rule.rb

@@ -9,12 +9,17 @@ module Philiprehberger
       # @return [String] the rule name
       attr_reader :name
 
+      # @return [Array<Symbol>] the rule tags
+      attr_reader :tags
+
       # @return [Boolean] whether the rule is enabled
       attr_accessor :enabled
 
       # @param name [String] the rule name
-      def initialize(name)
+      # @param tags [Array<Symbol>] optional tags for grouping
+      def initialize(name, tags: [])
         @name = name
+        @tags = tags.map(&:to_sym)
         @priority = 0
         @condition = nil
         @action = nil
@@ -76,7 +81,8 @@ module Philiprehberger
         {
           name: @name,
           priority: @priority,
-          enabled: @enabled
+          enabled: @enabled,
+          tags: @tags
         }
       end
     end

data/lib/philiprehberger/rule_engine/version.rb

@@ -2,6 +2,6 @@
 
 module Philiprehberger
   module RuleEngine
-    VERSION = '0.3.0'
+    VERSION = '0.4.0'
   end
 end

data/lib/philiprehberger/rule_engine.rb

@@ -35,8 +35,9 @@ module Philiprehberger
         name = rule_data[:name] || rule_data['name']
         priority_val = rule_data[:priority] || rule_data['priority'] || 0
         enabled_val = rule_data.key?(:enabled) ? rule_data[:enabled] : rule_data.fetch('enabled', true)
+        tags_val = (rule_data[:tags] || rule_data['tags'] || []).map(&:to_sym)
 
-        r = engine.add_rule(name) do
+        r = engine.add_rule(name, tags: tags_val) do
           priority priority_val
         end
         r.enabled = enabled_val

metadata

@@ -1,18 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: philiprehberger-rule_engine
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Philip Rehberger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-02 00:00:00.000000000 Z
+date: 2026-04-10 00:00:00.000000000 Z
 dependencies: []
 description: A lightweight rule engine with a declarative DSL for defining conditions
-  and actions. Supports priority-based ordering, first-match and all-match evaluation
-  modes, and composable rule definitions.
+  and actions. Supports priority-based ordering, rule tagging with selective evaluation,
+  first-match and all-match modes, dry run, conflict detection, serialization, chaining,
+  and per-rule execution statistics.
 email:
 - me@philiprehberger.com
 executables: []