pass Tcontext to execute action

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pflow-metamodel"
-version = "0.4.1"
+version = "0.5.0"
 edition = "2021"
 description = "Declarative Petri-nets using a rust DSL"
 license = "MIT"

src/lib.rs

@@ -96,6 +96,7 @@ pub mod zblob;
 /// The `model` encapsulates the `PetriNet` and `Vasm` objects into a single `Model` object.
 pub mod model;
 
+/// The `display` module contains the `ImageBuilder` and `ImageOutput` traits for rendering Petri-nets as SVG.
 mod display;
 
 pub use crate::model::*;
@@ -283,7 +284,7 @@ pub trait Process<TContext> {
     /// Runs the main loop of the state machine
     fn run_impl(&self, action: Option<&str>, seq: Option<u64>, event_log: Vec<Event<TContext>>) -> Vec<Event<TContext>>;
     /// Process an action and return the resulting event
-    fn process_action(&self, action: &str, seq: u64) -> Option<Event<TContext>>;
+    fn process_action(&self, action: &str, seq: u64, ctx: TContext) -> Option<Event<TContext>>;
     /// Get the next action to be executed
     fn next_action(&self) -> Vec<String>;
     /// Execute an action and return the resulting event
@@ -401,7 +402,7 @@ mod tests {
         }
     }
 
-    #[derive(Debug)]
+    #[derive(Debug, Clone)]
     struct Context {
         #[allow(unused)]
         pub msg: String,
@@ -433,7 +434,8 @@ mod tests {
             let mut current_seq = seq.unwrap_or(0) + 1;
 
             while let Some(ref action) = current_action {
-                if let Some(transaction) = self.process_action(action, current_seq) {
+                let context = event_log.last().expect("last event").data.clone();
+                if let Some(transaction) = self.process_action(action, current_seq, context) {
                     event_log.push(transaction);
                 } else {
                     break;
@@ -458,17 +460,19 @@ mod tests {
         /// # Panics
         ///
         /// Panics if the lock fails
-        fn process_action(&self, action: &str, seq: u64) -> Option<Event<Context>> {
+        fn process_action(&self, action: &str, seq: u64, ctx: Context) -> Option<Event<Context>> {
             let mut state = self.state.lock().expect("lock failed");
             let res = self.model.vm.transform(&state, action, 1);
+            let mut data = ctx.clone();
+            data.msg = format!("completed! #{seq}: {action}");
 
             if res.is_ok() {
                 *state = res.output;
                 let evt = Event {
                     action: action.to_string(),
                     seq,
                     state: state.clone(),
-                    data: Context { msg: format!("completed! #{seq}: {action}") },
+                    data,
                 };
                 let transaction = self.execute_action(evt);