rust_rule_engine/
lib.rs

1//! # Rust Rule Engine - GRL Edition
2//!
3//! A high-performance rule engine for Rust with **GRL (Grule Rule Language)** support,
4//! featuring method calls, object interactions, and complex condition evaluation.
5//!
6//! ## Features
7//!
8//! - **🔥 GRL Support**: Full Grule-compatible syntax
9//! - **🎯 Method Calls**: `$Object.method(args)` and property access
10//! - **📊 Knowledge Base**: Centralized rule management with salience
11//! - **💾 Working Memory**: Facts system for complex object interactions
12//! - **⚡ High Performance**: Optimized execution with cycle detection
13//! - **🔄 Arithmetic**: Complex calculations in conditions and actions
14//! - **🛡️ Type Safety**: Rust's type system ensures runtime safety
15//!
16//! ## Quick Start
17//!
18//! ```rust
19//! use rust_rule_engine::*;
20//!
21//! fn main() -> Result<()> {
22//!     // Create Knowledge Base
23//!     let kb = KnowledgeBase::new("Demo");
24//!     
25//!     // Define GRL rule
26//!     let rule = r#"
27//!     rule "AgeCheck" salience 10 {
28//!         when
29//!             User.Age >= 18 && User.Country == "US"
30//!         then
31//!             User.IsAdult = true;
32//!             User.DiscountRate = 0.10;
33//!     }
34//!     "#;
35//!     
36//!     // Parse and add rule
37//!     let rules = GRLParser::parse_rules(rule)?;
38//!     let parsed_rule = rules.into_iter().next().unwrap();
39//!     kb.add_rule(parsed_rule)?;
40//!     
41//!     // Create engine
42//!     let mut engine = RustRuleEngine::new(kb);
43//!     
44//!     // Create facts
45//!     let facts = Facts::new();
46//!     let user = FactHelper::create_user("john", 25, "john@email.com", "US", false);
47//!     facts.add_value("User", user)?;
48//!     
49//!     // Execute rules
50//!     let result = engine.execute(&facts)?;
51//!     println!("Rules fired: {}", result.rules_fired);
52//!     
53//!     Ok(())
54//! }
55//! ```
56//!
57//! ## Advanced Features
58//!
59//! ### Method Calls and Object Interactions
60//!
61//! ```rust
62//! # use rust_rule_engine::*;
63//! let speedup_rule = r#"
64//! rule "SpeedUp" salience 10 {
65//!     when
66//!         $TestCar : TestCarClass( speedUp == true && speed < maxSpeed )
67//!     then
68//!         $TestCar.setSpeed($TestCar.Speed + $TestCar.SpeedIncrement);
69//!         update($TestCar);
70//! }
71//! "#;
72//! ```
73//!
74//! ### E-commerce Rules
75//!
76//! ```rust
77//! # use rust_rule_engine::*;
78//! let discount_rule = r#"
79//! rule "PremiumDiscount" salience 20 {
80//!     when
81//!         Customer.Membership == "premium" && Order.Total > 100
82//!     then
83//!         Order.DiscountRate = 0.15;
84//!         Order.FreeShipping = true;
85//! }
86//! "#;
87//! ```
88//!
89//! ## Core Components
90//!
91//! - [`KnowledgeBase`]: Manages collections of rules with metadata
92//! - [`Facts`]: Working memory for data objects and rule evaluation  
93//! - [`RustRuleEngine`]: Executes rules with configurable options
94//! - [`GRLParser`]: Parses Grule Rule Language syntax
95//! - [`FactHelper`]: Utility functions for creating data objects
96//! - [`Value`]: Flexible data type system supporting objects, arrays, primitives
97
98#![warn(missing_docs)]
99#![warn(clippy::all)]
100
101/// Rule execution engine and related components
102pub mod engine;
103/// Error types and result handling
104pub mod errors;
105/// Rule parsing and language support  
106pub mod parser;
107/// Streaming rule engine for real-time event processing
108#[cfg(feature = "streaming")]
109pub mod streaming;
110/// Core type definitions for values, operators, and actions
111pub mod types;
112
113// Re-export core types for easy access
114pub use errors::{Result, RuleEngineError};
115pub use types::{ActionType, LogicalOperator, Operator, Value};
116
117// Re-export Grule-style components
118pub use engine::engine::{EngineConfig, GruleExecutionResult, RustRuleEngine};
119pub use engine::facts::{FactHelper, Facts};
120pub use engine::knowledge_base::KnowledgeBase;
121pub use engine::rule::{Condition, ConditionGroup, Rule};
122
123// Re-export parsers
124pub use parser::grl::GRLParser;
125
126/// Builder pattern for creating a RustRuleEngine with various configurations
127pub struct RuleEngineBuilder {
128    kb: KnowledgeBase,
129    config: EngineConfig,
130}
131
132impl RuleEngineBuilder {
133    /// Create a new RuleEngineBuilder
134    pub fn new() -> Self {
135        Self {
136            kb: KnowledgeBase::new("DefaultKB"),
137            config: EngineConfig::default(),
138        }
139    }
140
141    /// Add rules from a .grl file
142    pub fn with_rule_file<P: AsRef<std::path::Path>>(self, path: P) -> Result<Self> {
143        let content = std::fs::read_to_string(path)?;
144        let rules = GRLParser::parse_rules(&content)?;
145
146        for rule in rules {
147            self.kb.add_rule(rule)?;
148        }
149
150        Ok(self)
151    }
152
153    /// Add rules from inline GRL string
154    pub fn with_inline_grl(self, grl_content: &str) -> Result<Self> {
155        let rules = GRLParser::parse_rules(grl_content)?;
156
157        for rule in rules {
158            self.kb.add_rule(rule)?;
159        }
160
161        Ok(self)
162    }
163
164    /// Set engine configuration
165    pub fn with_config(mut self, config: EngineConfig) -> Self {
166        self.config = config;
167        self
168    }
169
170    /// Build the RustRuleEngine
171    pub fn build(self) -> RustRuleEngine {
172        RustRuleEngine::with_config(self.kb, self.config)
173    }
174}
175
176impl Default for RuleEngineBuilder {
177    fn default() -> Self {
178        Self::new()
179    }
180}
rust_rule_engine/lib.rs

rust_rule_engine/
lib.rs
