🥮 mooncakes.io

moonrule

An explainable expression rules engine for JSON data, implemented in MoonBit.

rules
validation
json
expression
policy
moon add YeeHh2004/moonrule@0.4.1
Download zip
Author
Version
0.4.1
License
Apache-2.0
Repository
Last updated
6 days ago
Downloads
12

Dependencies

README

#MoonRule

MoonRule 是一个使用 MoonBit 实现的轻量、可解释动态规则引擎。它将规则表达式编译为可复用的程序，并在 JSON 数据上执行，适用于 API 准入、表单校验、配置检查和 CI 质量门禁。

项目当前面向 MoonBit 0.10.4，核心库支持 MoonBit 的多后端；命令行工具提供基于文件的批量校验和 JSON 报告。

#主要能力

  • 词法分析、优先级解析和不可变 AST
  • JSON 对象字段、数组索引、嵌套路径和 ?. / ?[...] 可选访问
  • 算术、比较、布尔短路和集合成员运算
  • 字符串、数组、对象和正则表达式内置函数
  • 一次编译、多次执行
  • 多规则批量校验
  • 稳定的诊断代码、源码范围和修复提示
  • 确定性的逐步执行轨迹
  • 面向不可信规则文本的源码长度、AST 节点数和嵌套深度限制
  • 面向运行阶段的最大执行步数限制
  • 静态分析：依赖路径、函数调用、复杂度与不可达分支
  • 严重级别策略、快速失败与多数据批量校验
  • 日期时间、IPv4、邮箱、UUID 和 SemVer 等确定性业务校验
  • 25 个内置函数及可供编辑器读取的函数目录
  • 可配置的静态分析准入策略和 CI 门禁
  • JSON 驱动的规则回归测试套件及精确失败规则断言
  • 适合 CI 的 JSON 报告和退出码
  • 黑盒测试、白盒测试、基准测试和 GitHub Actions

#快速开始

单条规则：

///|
test "README quick start" {
  let input : Json = {
    "user": { "age": 24, "country": "CN", "roles": ["editor"], "active": true },
  }
  let result = check(
    "user.age >= 18 && user.country in [\"CN\", \"SG\"] && user.active", input,
  )
  assert_eq(result, Ok(true))
}

规则只编译一次，然后可以处理多份数据：

///|
test "README compile once" {
  let program = compile("order.total > 0 && order.currency == \"CNY\"").unwrap()
  assert_eq(
    evaluate(program, { "order": { "total": 99, "currency": "CNY" } }),
    Ok(Json::boolean(true)),
  )
}

编译外部规则时可显式收紧资源限制：

///|
test "README defensive compile limits" {
  let limits : CompileLimits = {
    max_source_length: 4096,
    max_ast_nodes: 1024,
    max_ast_depth: 64,
  }
  let program = compile_with_limits("user.active", limits).unwrap()
  assert_true(program.node_count() > 0)
  assert_true(program.ast_depth() > 0)
}

多规则报告：

///|
test "README ruleset" {
  let rules = RuleSet::compile([
    RuleDefinition::new("adult", "user.age >= 18", "The user must be an adult."),
    RuleDefinition::new("active", "user.active", "The account must be active."),
  ]).unwrap()
  let report = rules.evaluate({ "user": { "age": 20, "active": true } })
  assert_true(report.passed)
  assert_eq(report.passed_count, 2)
}

缺失字段较常见时，可选访问返回 null，再由 coalesce 提供默认值：

///|
test "README optional validation" {
  let rule = "is_email(coalesce(request?.user?.email, \"\"))"
  assert_eq(check(rule, Json::empty_object()), Ok(false))
  assert_eq(
    check(rule, { "request": { "user": { "email": "dev@example.com" } } }),
    Ok(true),
  )
}

#命令行

验证示例数据：

moon run cmd/main -- check examples/access-rules.json examples/user-valid.json

失败报告会返回退出码 1，配置、解析或运行错误返回 2：

moon run cmd/main -- check examples/access-rules.json examples/user-invalid.json

完整的 API 请求校验示例：

moon run cmd/main -- lint-rules examples/api-validation-rules.json
moon run cmd/main -- check examples/api-validation-rules.json examples/api-request-valid.json
moon run cmd/main -- check examples/api-validation-rules.json examples/api-request-invalid.json
moon run cmd/main -- test-rules examples/api-validation-rules.json examples/api-validation-cases.json

解释一条规则的每个求值步骤：

moon run cmd/main -- explain-file \
  "user.age >= 18 && user.active" \
  examples/user-valid.json

完整命令：

moonrule eval <expression> <json>
moonrule eval-file <expression> <data.json>
moonrule explain <expression> <json>
moonrule explain-file <expression> <data.json>
moonrule analyze <expression>
moonrule analyze-rules <rules.json>
moonrule lint <expression>
moonrule lint-rules <rules.json>
moonrule test-rules <rules.json> <cases.json>
moonrule check <rules.json> <data.json>
moonrule check-batch <rules.json> <data-array.json>
moonrule functions

#表达式语言

类别语法
字面量true、false、null、数字、字符串、数组
路径user.name、orders[0].total、meta["key"]
可选访问user?.profile?.email、items?[0]
算术+、-、*、/、%
比较==、!=、<、<=、>、>=
布尔!、&&、||
成员value in array、key in object、part in string

运算符从高到低依次为：一元运算、乘除余数、加减、顺序比较、相等比较、&&、||。

内置函数：

函数说明
len(value)返回字符串字符数、数组长度或对象字段数
contains(container, value)检查字符串、数组或对象
starts_with(text, prefix)检查字符串前缀
ends_with(text, suffix)检查字符串后缀
lower(text) / upper(text)ASCII/Unicode大小写转换
abs(number)数值绝对值
matches(text, pattern)正则表达式匹配
exists(value)判断值不是 null
has(object, key)判断对象是否包含字段
get(object, key, default)安全读取字段，缺失时返回默认值
min / max / clamp / sum常用数值与数组聚合
type_of(value) / coalesce(...)类型识别与空值回退
all(booleans) / any(booleans)布尔数组聚合
is_date(text) / is_datetime(text)ISO 日期与 RFC 3339 时间戳校验
is_ipv4(text) / is_email(text)IPv4 地址与常用邮箱地址校验
is_uuid(text) / is_semver(text)标准 UUID 与语义化版本校验

MoonRule 使用严格类型语义：布尔运算不会隐式转换数字或字符串；普通字段访问缺失、类型不匹配、越界和除零均返回结构化诊断。可选访问只把缺失字段、空值和越界转换为 null，不会掩盖类型错误。

#规则配置

check 命令接收一个 JSON 规则数组：

[
  {
    "name": "adult-user",
    "expression": "user.age >= 18",
    "message": "The user must be at least 18 years old.",
    "severity": "Error"
  }
]

severity 可取 Info、Warning 或 Error。当前版本会执行全部规则并完整报告结果，不会因第一条失败而停止。

#规则回归测试

回归套件是一个 JSON 数组。每个案例包含稳定名称、完整输入、预期是否通过，以及可选的精确失败规则集合：

[
  {
    "name": "minor user",
    "input": { "user": { "age": 15 } },
    "expected_passed": false,
    "expected_failed_rules": ["adult-user"]
  }
]

test-rules 会复用已编译规则运行全部案例。全部预期匹配时返回 0，存在不匹配时返回 1，规则或套件配置错误返回 2。报告同时保留逐规则结果和运行诊断，适合直接存档为 CI 构件。

#开发与验证

moon check --deny-warn
moon test --package YeeHh2004/moonrule --deny-warn
moon bench
moon coverage analyze
moon coverage report
moon info
moon package --list

项目设计、语法边界和验收记录见：

#当前边界

  • 标识符暂限定为 ASCII 字母、数字和下划线
  • 不提供循环、赋值、文件访问或任意函数调用
  • matches 遵循 MoonBit 正则表达式语法，并限制模式及输入长度
  • 普通字段访问缺失仍是错误；需要空值语义时必须显式使用 ?. 或 ?[...]
  • 日期时间与网络格式函数只校验传入文本，不读取时钟、网络或外部状态

#许可证

Apache License 2.0。详见 LICENSE。

#
AnalysisFinding

source
pub(all) struct AnalysisFinding {
  level : AnalysisLevel
  code : String
  message : String
  span : Span
  hint : String?
} derive(Eq, ToJson, 
Debug, 
FromJson)

One actionable observation produced without evaluating input data.

#
AnalysisGateReport

source
pub(all) struct AnalysisGateReport {
  passed : Bool
  analysis : ProgramAnalysis
  violations : Array[AnalysisFinding]
} derive(Eq, ToJson, 
Debug, 
FromJson)

Static analysis plus the policy violations that determine CI acceptance.

#
AnalysisGateReport::to_json_string

source
fn AnalysisGateReport::to_json_string(self : AnalysisGateReport, indent? : Int) -> String

#
AnalysisLevel

source
pub(all) enum AnalysisLevel {
  Note
  Warning
} derive(Eq, ToJson, 
Debug, 
FromJson)

Importance of a static-analysis finding.

#
AnalysisPolicy

source
pub(all) struct AnalysisPolicy {
  max_ast_nodes : Int
  max_ast_depth : Int
  max_estimated_cost : Int
  reject_warnings : Bool
  allow_dynamic_regex : Bool
} derive(Eq, ToJson, 
Debug, 
FromJson)

CI-oriented limits applied to the result of static program analysis.

#
AnalysisPolicy::default

source

#
BatchItemReport

source
pub(all) struct BatchItemReport {
  index : Int
  passed : Bool
  report : PolicyReport
} derive(Eq, ToJson, 
Debug, 
FromJson)

Result for one zero-based input record.

#
BatchOptions

source
pub(all) struct BatchOptions {
  rule_options : RuleEvaluationOptions
  stop_on_first_rejected_record : Bool
} derive(Eq, ToJson, 
Debug, 
FromJson)

Options for applying the same compiled rules to several JSON records.

#
BatchOptions::default

source
fn BatchOptions::default() -> BatchOptions

#
BatchReport

source
pub(all) struct BatchReport {
  passed : Bool
  requested_count : Int
  evaluated_count : Int
  accepted_count : Int
  rejected_count : Int
  stopped_early : Bool
  items : Array[BatchItemReport]
} derive(Eq, ToJson, 
Debug, 
FromJson)

Aggregate result for a batch validation operation.

#
BatchReport::to_json_string

source
fn BatchReport::to_json_string(self : BatchReport, indent? : Int) -> String

#
BinaryOp

source
pub enum BinaryOp {
  Or
  And
  Equal
  NotEqual
  Less
  LessEqual
  Greater
  GreaterEqual
  In
  Add
  Subtract
  Multiply
  Divide
  Remainder
} derive(
Debug)

#
CompileLimits

source
pub(all) struct CompileLimits {
  max_source_length : Int
  max_ast_nodes : Int
  max_ast_depth : Int
} derive(Eq, ToJson, 
Debug, 
FromJson)

Defensive limits applied while compiling untrusted rule text.

#
CompileLimits::default

source
fn CompileLimits::default() -> CompileLimits

Conservative defaults suitable for API and CI use.

#
CompiledRule

source
pub struct CompiledRule {
  definition : RuleDefinition
  program : Program
}

#
Diagnostic

source
pub(all) struct Diagnostic {
  stage : DiagnosticStage
  code : String
  message : String
  span : Span
  hint : String?
} derive(Eq, ToJson, 
Debug, 
FromJson)

A stable, structured error intended for editors, CLIs, and CI reports.

#
Diagnostic::new

source
fn Diagnostic::new(stage : DiagnosticStage, code : String, message : String, span : Span, hint? : String) -> Diagnostic

#
Diagnostic::render

source
fn Diagnostic::render(self : Diagnostic, source : String) -> String

#
DiagnosticStage

source
pub(all) enum DiagnosticStage {
  Lex
  Parse
  Evaluate
  Configure
} derive(Eq, ToJson, 
Debug, 
FromJson)

The stage that produced a diagnostic.

#
EvaluationLimits

source
pub(all) struct EvaluationLimits {
  max_steps : Int
} derive(Eq, ToJson, 
Debug, 
FromJson)

Limits applied while executing a compiled rule.

The step budget makes evaluation time predictable for rules accepted from external users. A step is consumed whenever an AST node is visited.

#
EvaluationLimits::default

source

A conservative budget that is far above ordinary API validation rules.

#
EvaluationTrace

source
pub(all) struct EvaluationTrace {
  value : Json
  steps : Array[TraceStep]
} derive(Eq, ToJson, 
Debug, 
FromJson)

The result and ordered steps from an explained evaluation.

#
EvaluationTrace::to_json_string

source
fn EvaluationTrace::to_json_string(self : EvaluationTrace, indent? : Int) -> String

#
Expr

source
pub enum Expr {
  Literal(Json, Span)
  Variable(String, Span)
  ArrayLiteral(Array[Expr], Span)
  Member(Expr, String, Span)
  Index(Expr, Expr, Span)
  OptionalMember(Expr, String, Span)
  OptionalIndex(Expr, Expr, Span)
  Call(String, Array[Expr], Span)
  Unary(UnaryOp, Expr, Span)
  Binary(Expr, BinaryOp, Expr, Span)
} derive(
Debug)

#
ExpressionStatistics

source
pub(all) struct ExpressionStatistics {
  literals : Int
  variables : Int
  arrays : Int
  members : Int
  indexes : Int
  optional_members : Int
  optional_indexes : Int
  calls : Int
  unary_operations : Int
  binary_operations : Int
} derive(Eq, ToJson, 
Debug, 
FromJson)

Counts for the expression forms contained in a compiled program.

#
FailureThreshold

source
pub(all) enum FailureThreshold {
  AnyFailure
  WarningOrHigher
  ErrorOnly
} derive(Eq, ToJson, 
Debug, 
FromJson)

Minimum severity that makes a failed rule reject an input.

#
FunctionCategory

source
pub(all) enum FunctionCategory {
  Collection
  String
  Number
  Conversion
  Predicate
} derive(Eq, ToJson, 
Debug, 
FromJson)

Broad grouping used by generated documentation and editor integrations.

#
FunctionSpec

source
pub(all) struct FunctionSpec {
  name : String
  category : FunctionCategory
  min_arguments : Int
  max_arguments : Int
  signature : String
  summary : String
} derive(Eq, ToJson, 
Debug, 
FromJson)

Machine-readable description of a function built into MoonRule.

Keeping this metadata in the library lets command-line tools and web editors provide completion without maintaining a second function list.

#
FunctionSpec::accepts_arity

source
fn FunctionSpec::accepts_arity(self : FunctionSpec, arguments : Int) -> Bool

Return true when an argument count is accepted by a function specification.

#
FunctionSpec::arity_description

source
fn FunctionSpec::arity_description(self : FunctionSpec) -> String

Render a concise argument-count description for diagnostics.

#
OutcomeStatus

source
pub(all) enum OutcomeStatus {
  Passed
  Failed
  EvaluationError
} derive(Eq, ToJson, 
Debug, 
FromJson)

#
PolicyReport

source
pub(all) struct PolicyReport {
  passed : Bool
  evaluated_count : Int
  passed_count : Int
  failed_count : Int
  blocking_count : Int
  advisory_count : Int
  error_count : Int
  stopped_early : Bool
  outcomes : Array[RuleOutcome]
} derive(Eq, ToJson, 
Debug, 
FromJson)

Result of evaluating a rule set with an explicit acceptance policy.

#
PolicyReport::to_json_string

source
fn PolicyReport::to_json_string(self : PolicyReport, indent? : Int) -> String

#
Program

source
pub struct Program {
  root : Expr
  source : String
  node_count : Int
  ast_depth : Int
}

A compiled expression. Its representation is intentionally opaque so the parser can evolve without breaking consumers.

#
Program::ast_depth

source
fn Program::ast_depth(self : Program) -> Int

Maximum nesting depth of the compiled abstract syntax tree.

#
Program::node_count

source
fn Program::node_count(self : Program) -> Int

Number of nodes in the compiled abstract syntax tree.

#
Program::source

source
fn Program::source(self : Program) -> String

#
Program::span

source
fn Program::span(self : Program) -> Span

#
ProgramAnalysis

source
pub(all) struct ProgramAnalysis {
  source_length : Int
  node_count : Int
  ast_depth : Int
  estimated_cost : Int
  statistics : ExpressionStatistics
  referenced_paths : Array[String]
  called_functions : Array[String]
  findings : Array[AnalysisFinding]
} derive(Eq, ToJson, 
Debug, 
FromJson)

Static description of a compiled MoonRule program.

#
ProgramAnalysis::findings_at

source

Select findings of one importance level while preserving source order.

#
ProgramAnalysis::has_warnings

source
fn ProgramAnalysis::has_warnings(self : ProgramAnalysis) -> Bool

Return true when static analysis found at least one warning.

#
ProgramAnalysis::is_clean

source
fn ProgramAnalysis::is_clean(self : ProgramAnalysis) -> Bool

Return true when analysis produced no notes or warnings.

#
ProgramAnalysis::note_count

source
fn ProgramAnalysis::note_count(self : ProgramAnalysis) -> Int

#
ProgramAnalysis::references_path

source
fn ProgramAnalysis::references_path(self : ProgramAnalysis, path : String) -> Bool

Test whether the exact normalized JSON path is referenced.

#
ProgramAnalysis::to_json_string

source
fn ProgramAnalysis::to_json_string(self : ProgramAnalysis, indent? : Int) -> String

#
ProgramAnalysis::uses_function

source
fn ProgramAnalysis::uses_function(self : ProgramAnalysis, name : String) -> Bool

Test whether the program calls a named built-in or unresolved function.

#
ProgramAnalysis::warning_count

source
fn ProgramAnalysis::warning_count(self : ProgramAnalysis) -> Int

#
RuleAnalysisGate

source
pub(all) struct RuleAnalysisGate {
  name : String
  severity : Severity
  report : AnalysisGateReport
} derive(Eq, ToJson, 
Debug, 
FromJson)

Gate result associated with one named rule.

#
RuleDefinition

source
pub(all) struct RuleDefinition {
  name : String
  expression : String
  message : String
  severity : Severity
} derive(Eq, ToJson, 
Debug, 
FromJson)

Serializable source configuration for one rule.

#
RuleDefinition::new

source
fn RuleDefinition::new(name : String, expression : String, message : String, severity? : Severity) -> RuleDefinition

#
RuleEvaluationOptions

source
pub(all) struct RuleEvaluationOptions {
  failure_threshold : FailureThreshold
  stop_on_blocking_failure : Bool
  stop_on_evaluation_error : Bool
} derive(Eq, ToJson, 
Debug, 
FromJson)

Controls severity handling and early termination for a rule-set evaluation.

#
RuleEvaluationOptions::default

source

#
RuleOutcome

source
pub(all) struct RuleOutcome {
  name : String
  status : OutcomeStatus
  message : String
  severity : Severity
  diagnostic : Diagnostic?
} derive(Eq, ToJson, 
Debug, 
FromJson)

#
RuleProgramAnalysis

source
pub(all) struct RuleProgramAnalysis {
  name : String
  severity : Severity
  expression : String
  analysis : ProgramAnalysis
} derive(Eq, ToJson, 
Debug, 
FromJson)

Static-analysis result associated with one named rule definition.

#
RuleReport

source
pub(all) struct RuleReport {
  passed : Bool
  passed_count : Int
  failed_count : Int
  error_count : Int
  outcomes : Array[RuleOutcome]
} derive(Eq, ToJson, 
Debug, 
FromJson)

#
RuleReport::to_json_string

source
fn RuleReport::to_json_string(self : RuleReport, indent? : Int) -> String

#
RuleSet

source
pub struct RuleSet {
  rules : Array[CompiledRule]
}

A collection of rules compiled once and reusable across many JSON values.

#
RuleSet::analyze

source
fn RuleSet::analyze(self : RuleSet) -> RuleSetAnalysis

Analyze every compiled rule and combine its data dependencies and calls.

#
RuleSet::analyze_with_policy

source
fn RuleSet::analyze_with_policy(self : RuleSet, policy : AnalysisPolicy) -> Result[RuleSetAnalysisGateReport, Diagnostic]

Apply one static-analysis policy to every rule in a compiled rule set.

#
RuleSet::compile

source
fn RuleSet::compile(definitions : Array[RuleDefinition]) -> Result[RuleSet, Array[Diagnostic]]

#
RuleSet::compile_with_limits

source
fn RuleSet::compile_with_limits(definitions : Array[RuleDefinition], limits : RuleSetLimits) -> Result[RuleSet, Array[Diagnostic]]

Compile a rule set with size, naming, and per-expression safety limits.

#
RuleSet::evaluate

source
fn RuleSet::evaluate(self : RuleSet, context : Json) -> RuleReport

Evaluate every rule. Runtime errors are recorded per rule so one malformed input path does not hide the rest of the report.

#
RuleSet::evaluate_batch

source
fn RuleSet::evaluate_batch(self : RuleSet, contexts : Array[Json], options? : BatchOptions) -> BatchReport

Apply one compiled rule set to a batch of independent JSON values.

#
RuleSet::evaluate_with_options

source
fn RuleSet::evaluate_with_options(self : RuleSet, context : Json, options : RuleEvaluationOptions) -> PolicyReport

Evaluate rules using a configurable failure threshold.

Informational or warning outcomes remain visible even when the selected policy treats them as advisory. Runtime errors always reject the input.

#
RuleSet::from_json

source
fn RuleSet::from_json(config : Json) -> Result[RuleSet, Array[Diagnostic]]

Decode and compile a JSON array of rule definitions.

#
RuleSet::from_json_with_limits

source
fn RuleSet::from_json_with_limits(config : Json, limits : RuleSetLimits) -> Result[RuleSet, Array[Diagnostic]]

Decode and compile rule definitions using explicit configuration limits.

#
RuleSet::length

source
fn RuleSet::length(self : RuleSet) -> Int

#
RuleSet::run_test_suite

source
fn RuleSet::run_test_suite(self : RuleSet, suite : RuleTestSuite) -> RuleTestSuiteReport

Run a validated regression suite while reusing the already compiled rules.

#
RuleSetAnalysis

source
pub(all) struct RuleSetAnalysis {
  rule_count : Int
  total_nodes : Int
  maximum_ast_depth : Int
  estimated_cost : Int
  warning_count : Int
  note_count : Int
  called_functions : Array[String]
  referenced_paths : Array[String]
  rules : Array[RuleProgramAnalysis]
} derive(Eq, ToJson, 
Debug, 
FromJson)

Aggregate static information for a compiled rule set.

#
RuleSetAnalysis::find_rule

source
fn RuleSetAnalysis::find_rule(self : RuleSetAnalysis, name : String) -> RuleProgramAnalysis?

Look up a named rule's analysis. Rule names are compared exactly.

#
RuleSetAnalysis::has_warnings

source
fn RuleSetAnalysis::has_warnings(self : RuleSetAnalysis) -> Bool

Return true when at least one rule has a warning-level finding.

#
RuleSetAnalysis::references_path

source
fn RuleSetAnalysis::references_path(self : RuleSetAnalysis, path : String) -> Bool

Test whether any rule in the set references an exact normalized path.

#
RuleSetAnalysis::to_json_string

source
fn RuleSetAnalysis::to_json_string(self : RuleSetAnalysis, indent? : Int) -> String

#
RuleSetAnalysis::uses_function

source
fn RuleSetAnalysis::uses_function(self : RuleSetAnalysis, name : String) -> Bool

Test whether any rule in the set calls the named function.

#
RuleSetAnalysisGateReport

source
pub(all) struct RuleSetAnalysisGateReport {
  passed : Bool
  rule_count : Int
  failed_rule_count : Int
  rules : Array[RuleAnalysisGate]
} derive(Eq, ToJson, 
Debug, 
FromJson)

Aggregate CI gate result for a compiled rule set.

#
RuleSetAnalysisGateReport::to_json_string

source
fn RuleSetAnalysisGateReport::to_json_string(self : RuleSetAnalysisGateReport, indent? : Int) -> String

#
RuleSetLimits

source
pub(all) struct RuleSetLimits {
  max_rules : Int
  max_name_length : Int
  max_message_length : Int
  max_total_source_length : Int
  require_unique_names : Bool
  compile_limits : CompileLimits
} derive(Eq, ToJson, 
Debug, 
FromJson)

Defensive configuration limits for rule sets loaded from external JSON.

#
RuleSetLimits::default

source
fn RuleSetLimits::default() -> RuleSetLimits

#
RuleTestCase

source
pub(all) struct RuleTestCase {
  name : String
  input : Json
  expected_passed : Bool
  expected_failed_rules : Array[String]?
} derive(Eq, ToJson, 
Debug, 
FromJson)

One named regression case for a compiled rule set.

#
RuleTestCase::new

source
fn RuleTestCase::new(name : String, input : Json, expected_passed : Bool, expected_failed_rules? : Array[String]) -> RuleTestCase

#
RuleTestCaseReport

source
pub(all) struct RuleTestCaseReport {
  name : String
  matched : Bool
  expected_passed : Bool
  actual_passed : Bool
  expected_failed_rules : Array[String]?
  actual_failed_rules : Array[String]
  actual_error_rules : Array[String]
  rule_report : RuleReport
} derive(Eq, ToJson, 
Debug, 
FromJson)

Result of one rule regression case.

#
RuleTestSuite

source
pub struct RuleTestSuite {
  cases : Array[RuleTestCase]
}

Validated collection of rule regression cases.

#
RuleTestSuite::from_json

source
fn RuleTestSuite::from_json(config : Json, limits? : RuleTestSuiteLimits) -> Result[RuleTestSuite, Array[Diagnostic]]

Decode and validate a JSON array of regression cases.

#
RuleTestSuite::length

source
fn RuleTestSuite::length(self : RuleTestSuite) -> Int

#
RuleTestSuite::new

source

#
RuleTestSuiteLimits

source
pub(all) struct RuleTestSuiteLimits {
  max_cases : Int
  max_name_length : Int
} derive(Eq, ToJson, 
Debug, 
FromJson)

Defensive limits for externally supplied regression suites.

#
RuleTestSuiteLimits::default

source

#
RuleTestSuiteReport

source
pub(all) struct RuleTestSuiteReport {
  passed : Bool
  case_count : Int
  matched_count : Int
  mismatched_count : Int
  cases : Array[RuleTestCaseReport]
} derive(Eq, ToJson, 
Debug, 
FromJson)

Aggregate result for a complete rule regression suite.

#
RuleTestSuiteReport::to_json_string

source
fn RuleTestSuiteReport::to_json_string(self : RuleTestSuiteReport, indent? : Int) -> String

#
Severity

source
pub(all) enum Severity {
  Info
  Warning
  Error
} derive(Eq, ToJson, 
Debug, 
FromJson)

The importance assigned to a rule.

#
Span

source
pub(all) struct Span {
  start : Int
  end : Int
} derive(Eq, ToJson, 
Debug, 
FromJson)

A half-open source range in a rule expression.

#
Span::length

source
fn Span::length(self : Span) -> Int

#
Span::merge

source
fn Span::merge(self : Span, other : Span) -> Span

#
Span::new

source
fn Span::new(start : Int, end : Int) -> Span

#
Token

source

#
TokenKind

source
type TokenKind derive(Eq, 
Debug)

#
TraceStep

source
pub(all) struct TraceStep {
  span : Span
  expression : String
  value : Json
} derive(Eq, ToJson, 
Debug, 
FromJson)

One observable step in expression evaluation.

#
UnaryOp

source
pub enum UnaryOp {
  Not
  Negate
} derive(
Debug)

#
analyze

source
fn analyze(program : Program) -> ProgramAnalysis

Analyze a compiled program without executing it against user data.

Findings are advisory: compile-time analysis never changes evaluation semantics and can therefore be introduced safely in CI and editors.

#
analyze_with_policy

source
fn analyze_with_policy(program : Program, policy : AnalysisPolicy) -> Result[AnalysisGateReport, Diagnostic]

Analyze one program and decide whether it satisfies a configured CI gate.

#
builtin_functions

source
fn builtin_functions() -> Array[FunctionSpec]

Return the stable catalog of functions supported by the evaluator.

#
builtin_functions_json

source
fn builtin_functions_json(indent? : Int) -> String

Serialize the function catalog for documentation generators and IDEs.

#
check

source
fn check(source : String, context : Json) -> Result[Bool, Diagnostic]

Compile and evaluate a rule that must produce a boolean decision.

#
compile

source
fn compile(source : String) -> Result[Program, Diagnostic]

Compile a MoonRule expression into an immutable program.

#
compile_with_limits

source
fn compile_with_limits(source : String, limits : CompileLimits) -> Result[Program, Diagnostic]

Compile an expression while enforcing limits suitable for untrusted input.

#
evaluate

source
fn evaluate(program : Program, context : Json) -> Result[Json, Diagnostic]

Evaluate a compiled program against a JSON context.

#
evaluate_with_limits

source
fn evaluate_with_limits(program : Program, context : Json, limits : EvaluationLimits) -> Result[Json, Diagnostic]

Evaluate a compiled program with an explicit execution-step budget.

#
explain

source
fn explain(program : Program, context : Json) -> Result[EvaluationTrace, Diagnostic]

Evaluate a program and retain a deterministic, machine-readable trace.

#
find_builtin_function

source
fn find_builtin_function(name : String) -> FunctionSpec?

Look up one built-in function by its exact rule-language name.

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io