permissions/
permissions.rs

1use logify::{Expression, ExpressionBuilder, eval::BoolEval};
2
3fn main() -> Result<(), ()> {
4    // 1. Build the permission rules
5    let builder = ExpressionBuilder::new();
6
7    // Define Roles (Leaves)
8    let admin = builder.leaf("Admin");
9    let editor = builder.leaf("Editor");
10    let viewer = builder.leaf("Viewer");
11
12    // Define Flags (Leaves)
13    let banned = builder.leaf("Banned");
14    let readonly = builder.leaf("ReadOnly");
15
16    // Construct Logic
17    let can_view = (admin | editor | viewer) & !banned;
18    let can_edit = (admin | editor) & !readonly & !banned;
19    let can_delete = admin & !banned;
20
21    // Add roots in specific order (0=View, 1=Edit, 2=Delete)
22    builder.add_root(can_view);
23    builder.add_root(can_edit);
24    builder.add_root(can_delete);
25
26    let rules: Expression<&str> = builder.build();
27
28    // 2. Define users
29
30    // User A: A Banned Editor (Should have NO access)
31    let mut user_a = BoolEval::new();
32    user_a.add("Editor");
33    user_a.add("Banned");
34
35    // User B: A Read-Only Editor (Can View, Cannot Edit)
36    let mut user_b = BoolEval::new();
37    user_b.add("Editor");
38    user_b.add("ReadOnly");
39
40    // User C: An Admin (Can do everything)
41    let mut user_c = BoolEval::new();
42    user_c.add("Admin");
43
44    // 3. Evaluate
45    print_access("User A (Banned Editor)", &rules, &mut user_a);
46    print_access("User B (ReadOnly Editor)", &rules, &mut user_b);
47    print_access("User C (Admin)", &rules, &mut user_c);
48
49    Ok(())
50}
51
52fn print_access<'a>(name: &str, rules: &Expression<&'a str>, user: &mut BoolEval<&'a str>) {
53    // Get the roots (Each representing a permission)
54    let perms = rules.evaluate(user).unwrap();
55
56    println!("Permissions for {}:", name);
57    println!("  [View]:   {}", perms[0]);
58    println!("  [Edit]:   {}", perms[1]);
59    println!("  [Delete]: {}", perms[2]);
60    println!("-----------------------------");
61}