Struct Engine 

pub struct Engine(/* private fields */);

A Lua wrapper for the rusty_rules::Engine.

The Engine is the main entry point for working with rules. It allows you to:

• Register custom fetchers that extract data from context
• Compile rule definitions
• Validate rule syntax (when validation feature is enabled)
• Generate JSON schema for rule structure

Examples

local engine = Engine.new()

-- Register a simple fetcher
engine:register_fetcher("user_attr", function(ctx, attr)
    return ctx.user[attr]
end)

-- Compile and evaluate a rule
local rule = engine:compile({["user_attr(role)"] = "admin"})
local is_admin = rule:evaluate({user = {role = "admin"}})

Implementations

impl Engine

pub fn new() -> Self

Creates a new rules engine instance for Lua.

Methods from Deref<Target = Engine<LuaValue>>

pub fn register_fetcher<F>(&mut self, name: &str, func: F) -> &mut Fetcher<Ctx>

where F: for<'a> Fn(&'a Ctx, &[String]) -> Result<Value<'a>, Box<dyn Error>> + MaybeSend + MaybeSync + 'static,

Registers a synchronous fetcher with its name and function, using the default matcher.

A fetcher is a function that extracts values from the context type. The fetcher name is used in rule definitions to reference this fetcher. By default, the DefaultMatcher is used, which supports basic equality and comparison operations.

Returns

A mutable reference to the created Fetcher, allowing you to customize it (e.g., change the matcher)

pub fn register_async_fetcher<F>( &mut self, name: &str, func: F, ) -> &mut Fetcher<Ctx>

where F: for<'a> Fn(&'a Ctx, Arc<[String]>) -> Pin<Box<dyn Future<Output = Result<Value<'a>, Box<dyn Error>>> + 'a>> + MaybeSend + MaybeSync + 'static,

Registers an async fetcher with its name and function, using the default matcher.

See Self::register_fetcher for more details.

pub fn register_operator<O>(&mut self, name: &str, op: O)

where O: ToOperator<Ctx> + 'static,

Registers a custom operator

pub fn compile_rule(&self, value: &Value) -> Result<Rule<Ctx>, Error>

Compiles a JSON value into a Rule::All using the registered fetchers and operators.

pub fn validate_rule<'a>( &self, value: &'a Value, ) -> Result<(), ValidationError<'a>>

Validates a JSON rule against dynamically generated JSON Schema of this engine.

pub fn json_schema(&self) -> Value

Builds a JSON Schema for rules, including dynamic properties.

Trait Implementations

impl Deref for Engine

type Target = Engine<Value>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Engine

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl UserData for Engine

fn register(registry: &mut LuaUserDataRegistry<Self>)

Registers this type for use in Lua.

fn add_fields<F>(fields: &mut F)

where F: UserDataFields<Self>,

Adds custom fields specific to this userdata.

fn add_methods<M>(methods: &mut M)

where M: UserDataMethods<Self>,

Adds custom methods and operators specific to this userdata.