Add PathArgs to Context

Also refactor Context public methods

src/path.rs

@@ -39,7 +39,13 @@ impl AsRef<Pointer> for Path {
 pub(crate) struct PathArgs(pub Vec<(Arc<str>, String)>);
 
 impl PathArgs {
-    pub fn new(params: matchit::Params) -> Self {
+    pub fn new() -> Self {
+        PathArgs(Vec::new())
+    }
+}
+
+impl<'k, 'v> From<matchit::Params<'k, 'v>> for PathArgs {
+    fn from(params: matchit::Params) -> PathArgs {
         let params: Vec<(Arc<str>, String)> = params
             .iter()
             .map(|(k, v)| (Arc::from(k), String::from(v)))

src/task/context.rs

@@ -1,40 +1,65 @@
-use crate::path::Path;
+use std::sync::Arc;
+
+use crate::path::{Path, PathArgs};
 
 pub struct Context<S> {
-    pub target: Option<S>,
-    pub path: Path,
+    pub(crate) target: Option<S>,
+    pub(crate) path: Path,
+    pub(crate) args: PathArgs,
 }
 
 impl<S> Default for Context<S> {
     fn default() -> Self {
         Context {
             target: None,
             path: Path::default(),
+            args: PathArgs::new(),
         }
     }
 }
 
 impl<S> Context<S> {
-    pub fn from_target(target: S) -> Self {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn with_target(self, target: S) -> Self {
         Self {
             target: Some(target),
-            path: Path::default(),
+            path: self.path,
+            args: self.args,
         }
     }
 
-    pub fn with_path(self, path: &'static str) -> Self {
+    // This will be used by the planner
+    #[allow(dead_code)]
+    pub(crate) fn with_path(self, path: &'static str) -> Self {
         Self {
             target: self.target,
             path: Path::from_static(path),
+            args: PathArgs::new(),
         }
     }
+
+    pub fn with_arg(self, key: impl Into<String>, value: impl Into<String>) -> Self {
+        let Self {
+            target,
+            path,
+            mut args,
+        } = self;
+
+        args.0.push((Arc::from(key.into()), value.into()));
+
+        Self { target, path, args }
+    }
 }
 
 impl<S: Clone> Clone for Context<S> {
     fn clone(&self) -> Self {
         Context {
             target: self.target.clone(),
             path: self.path.clone(),
+            args: self.args.clone(),
         }
     }
 }

src/task/domain.rs

@@ -120,7 +120,7 @@ impl<S> Domain<S> {
             .at(path)
             .map(|matched| {
                 (
-                    PathArgs::new(matched.params),
+                    PathArgs::from(matched.params),
                     matched
                         .value
                         .iter()
@@ -156,8 +156,8 @@ mod tests {
         }
 
         vec![
-            plus_one.into_task(Context::from_target(*tgt)),
-            plus_one.into_task(Context::from_target(*tgt)),
+            plus_one.into_task(Context::new().with_target(*tgt)),
+            plus_one.into_task(Context::new().with_target(*tgt)),
         ]
     }
 

src/task/mod.rs

@@ -181,8 +181,8 @@ mod tests {
         }
 
         vec![
-            plus_one.into_task(Context::from_target(*tgt)),
-            plus_one.into_task(Context::from_target(*tgt)),
+            plus_one.into_task(Context::new().with_target(*tgt)),
+            plus_one.into_task(Context::new().with_target(*tgt)),
         ]
     }
 
@@ -209,7 +209,7 @@ mod tests {
     fn it_allows_to_dry_run_tasks() {
         let system = System::from(0);
         let job = plus_one.into_job();
-        let task = job.into_task(Context::from_target(1));
+        let task = job.into_task(Context::new().with_target(1));
 
         // Get the list of changes that the action performs
         let changes = task.dry_run(&system).unwrap();
@@ -226,7 +226,7 @@ mod tests {
     fn it_allows_to_dry_run_composite_tasks() {
         let system = System::from(0);
         let job = plus_two.into_job();
-        let task = job.into_task(Context::from_target(2));
+        let task = job.into_task(Context::new().with_target(2));
 
         // Get the list of changes that the method performs
         let changes = task.dry_run(&system).unwrap();
@@ -243,7 +243,7 @@ mod tests {
     #[tokio::test]
     async fn it_allows_to_run_composite_tasks() {
         let mut system = System::from(0);
-        let task = plus_two.into_task(Context::from_target(2));
+        let task = plus_two.into_task(Context::new().with_target(2));
 
         // Run the action
         task.run(&mut system).await.unwrap();
@@ -257,7 +257,7 @@ mod tests {
     #[tokio::test]
     async fn it_runs_async_actions() {
         let mut system = System::from(0);
-        let task = plus_one.into_task(Context::from_target(1));
+        let task = plus_one.into_task(Context::new().with_target(1));
 
         // Run the action
         task.run(&mut system).await.unwrap();
@@ -272,7 +272,7 @@ mod tests {
     async fn it_allows_extending_actions_with_effect() {
         let mut system = System::from(0);
         let job = plus_one_async.into_job();
-        let task = job.into_task(Context::from_target(1));
+        let task = job.into_task(Context::new().with_target(1));
 
         // Run the action
         task.run(&mut system).await.unwrap();
@@ -285,7 +285,7 @@ mod tests {
     #[tokio::test]
     async fn it_allows_actions_returning_errors() {
         let mut system = System::from(1);
-        let task = plus_one_async.into_task(Context::from_target(1));
+        let task = plus_one_async.into_task(Context::new().with_target(1));
 
         let res = task.run(&mut system).await;
         assert!(res.is_err());
@@ -319,10 +319,11 @@ mod tests {
         let mut system = System::from(state);
         let task = update_counter.into_job();
         let action = task.into_task(
-            Context::from_target(State {
-                counters: [("a".to_string(), 2), ("b".to_string(), 1)].into(),
-            })
-            .with_path("/counters/a"),
+            Context::new()
+                .with_target(State {
+                    counters: [("a".to_string(), 2), ("b".to_string(), 1)].into(),
+                })
+                .with_path("/counters/a"),
         );
 
         // Run the action

tests/library_test.rs

@@ -20,7 +20,7 @@ fn my_task_effect(mut counter: Update<i32>, tgt: Target<i32>) -> Effect<Update<i
 fn it_allows_to_dry_run_tasks() {
     let system = System::from(0);
     let job = my_task_effect.into_job();
-    let action = job.into_task(Context::from_target(1));
+    let action = job.into_task(Context::new().with_target(1));
 
     // Get the list of changes that the action performs
     let changes = action.dry_run(&system).unwrap();