Ruleur

🧩

Composable Conditions

Build complex business logic with all/any/not operators and predicates. Chain conditions naturally with readable DSL syntax.

📝

YAML Authoring

Define rules in YAML files for easy storage in databases and version control. Load rules dynamically at runtime.

✅

Validation Framework

Pre-execution validation with structural, semantic, and test execution checks. Catch errors before deployment.

🔄

Version Tracking & Audit

Full audit trail with version history, rollback support, and change tracking. Know who changed what and when.

🎯

Forward-Chaining Engine

Salience-based conflict resolution and no-loop support. Rules fire in priority order with fact propagation.

💾

Database Persistence

Memory and ActiveRecord repositories with version management. Store rules in your database safely.

🔍

Inspectable & Testable

Trace rule execution, serialize rules to JSON, and test rules independently. Debug with confidence. The engine records per-rule and per-predicate execution timings which are returned in `ctx.debug` for each run and aggregated in `engine.stats`.

🚀

Production Ready

Used in production. Zero dependencies. Minimal overhead. Comprehensive test coverage.

Quick Example

ruby

require 'ruleur'

engine = Ruleur.define do
  rule 'admin_create', no_loop: true do
    conditions do
      any?(
        user(:admin?),
        all?(record(:updatable?), record(:draft?))
      )
    end
    actions do
      set :create, true
    end
  end

  rule 'draft_update', no_loop: true do
    conditions do
      all?(
        record(:draft?),
        flag(:create)
      )
    end
    actions do
      set :update, true
    end
  end
end

ctx = engine.run(record: record, user: user)
ctx[:create] # => true (if rule fired) or nil
ctx[:update] # => true (if rule fired) or nil

With Ruleur, values are only set when rules fire. If no rule matches, the value remains unset.

Why Ruleur?

Separate Logic from Code - Extract changing business rules from your codebase. Update rules without deploying code.

Testable & Inspectable - Rules are data structures that can be serialized, tested, and debugged independently.

Version Control - Track every change with full audit trails. Roll back bad rules instantly.

Replace Complex Conditionals - Turn nested if/else and Pundit policies into declarative, composable rules.

Database-First - Store rules in your database with YAML authoring. Load and reload at runtime.

What's New in v1.0

✅ YAML Import/Export - Author rules in YAML for easy database storage

✅ Validation Framework - Structural, semantic, and test execution validation

✅ Version Tracking - Full audit trail with VersionedActiveRecordRepository

✅ Rollback Support - Safe rollback that preserves history

✅ Migration Generator - Easy database setup with provided generators

RuleurBusiness Rules Engine for Ruby