update shape of RuleMatch and Evaluation

codex-rs/execpolicy2/src/policy.rs

@@ -1,6 +1,5 @@
 use crate::decision::Decision;
 use crate::rule::Rule;
-use crate::rule::RuleMatch;
 use serde::Deserialize;
 use serde::Serialize;
 
@@ -11,21 +10,8 @@ pub struct Policy {
 
 #[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
 pub struct Evaluation {
-    pub rule_id: String,
     pub decision: Decision,
-    pub matched_prefix: Vec<String>,
-    pub remainder: Vec<String>,
-}
-
-impl From<RuleMatch> for Evaluation {
-    fn from(value: RuleMatch) -> Self {
-        Self {
-            rule_id: value.rule_id,
-            decision: value.decision,
-            matched_prefix: value.matched_prefix,
-            remainder: value.remainder,
-        }
-    }
+    pub matched_rules: Vec<crate::rule::RuleMatch>,
 }
 
 impl Policy {
@@ -38,22 +24,27 @@ impl Policy {
     }
 
     pub fn evaluate(&self, cmd: &[String]) -> Option<Evaluation> {
-        let mut best: Option<Evaluation> = None;
+        let mut matched_rules: Vec<crate::rule::RuleMatch> = Vec::new();
+        let mut best_decision: Option<Decision> = None;
         for rule in &self.rules {
             if let Some(matched) = rule.matches(cmd) {
-                let eval = Evaluation::from(matched);
-                best = match best {
-                    None => Some(eval),
+                let decision = match best_decision {
+                    None => matched.decision,
                     Some(current) => {
-                        if eval.decision.is_stricter_than(current.decision) {
-                            Some(eval)
+                        if matched.decision.is_stricter_than(current) {
+                            matched.decision
                         } else {
-                            Some(current)
+                            current
                         }
                     }
                 };
+                best_decision = Some(decision);
+                matched_rules.push(matched);
             }
         }
-        best
+        best_decision.map(|decision| Evaluation {
+            decision,
+            matched_rules,
+        })
     }
 }

codex-rs/execpolicy2/src/rule.rs

@@ -1,6 +1,8 @@
 use crate::decision::Decision;
 use crate::error::Error;
 use crate::error::Result;
+use serde::Deserialize;
+use serde::Serialize;
 
 #[derive(Clone, Debug)]
 pub struct Rule {
@@ -9,11 +11,10 @@ pub struct Rule {
     pub decision: Decision,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
 pub struct RuleMatch {
     pub rule_id: String,
     pub matched_prefix: Vec<String>,
-    pub remainder: Vec<String>,
     pub decision: Decision,
 }
 
@@ -28,11 +29,9 @@ impl Rule {
                 .zip(prefix)
                 .all(|(cmd_tok, prefix_tok)| cmd_tok == prefix_tok)
             {
-                let remainder = cmd[prefix.len()..].to_vec();
                 return Some(RuleMatch {
                     rule_id: self.id.clone(),
                     matched_prefix: prefix.clone(),
-                    remainder,
                     decision: self.decision,
                 });
             }