Add affected.

Author: milesj

Cargo.lock

@@ -19,6 +19,7 @@ clap = { workspace = true }
 miette = { workspace = true }
 rustc-hash = { workspace = true }
 serde = { workspace = true }
+starbase_utils = { workspace = true }
 tracing = { workspace = true }
 
 [dev-dependencies]

crates/affected/Cargo.toml

@@ -6,6 +6,7 @@ use moon_project::Project;
 use moon_task::{Target, Task, TaskOptionRunInCI};
 use moon_workspace_graph::{GraphConnections, WorkspaceGraph};
 use rustc_hash::{FxHashMap, FxHashSet};
+use starbase_utils::fs;
 use std::fmt;
 use std::sync::Arc;
 use tracing::{debug, trace};
@@ -361,7 +362,25 @@ impl AffectedTracker {
         let globset = task.create_globset()?;
 
         for file in self.touched_files.iter() {
-            if task.input_files.contains_key(file) || globset.matches(file.as_str()) {
+            let mut affected = false;
+
+            if let Some(params) = task.input_files.get(file) {
+                affected = match &params.content {
+                    Some(matcher) => {
+                        let content =
+                            fs::read_file(file.to_logical_path(&self.workspace_graph.root))?;
+
+                        matcher.is_match(&content)
+                    }
+                    None => true,
+                };
+            }
+
+            if !affected {
+                affected = globset.matches(file.as_str());
+            }
+
+            if affected {
                 return Ok(Some(AffectedBy::TouchedFile(file.to_owned())));
             }
         }

crates/affected/src/affected_tracker.rs

@@ -9,6 +9,10 @@ tasks:
   by-file:
     inputs:
       - 'file.txt'
+  by-file-match:
+    inputs:
+      - file: 'file.txt'
+        content: 'ba(r|z)'
   by-glob:
     inputs:
       - '*.txt'

crates/affected/tests/__fixtures__/tasks/base/moon.yml

@@ -4,17 +4,24 @@ use moon_env_var::GlobalEnvBag;
 use moon_task::Target;
 use moon_test_utils2::{WorkspaceGraph, WorkspaceMocker};
 use rustc_hash::{FxHashMap, FxHashSet};
-use starbase_sandbox::create_sandbox;
+use starbase_sandbox::{Sandbox, create_sandbox};
 
-async fn build_graph(fixture: &str) -> WorkspaceGraph {
+async fn build_graph_with_sandbox(fixture: &str) -> (WorkspaceGraph, Sandbox) {
     let sandbox = create_sandbox(fixture);
 
-    WorkspaceMocker::new(sandbox.path())
-        .with_default_projects()
-        .with_global_envs()
-        .with_inherited_tasks()
-        .mock_workspace_graph()
-        .await
+    (
+        WorkspaceMocker::new(sandbox.path())
+            .with_default_projects()
+            .with_global_envs()
+            .with_inherited_tasks()
+            .mock_workspace_graph()
+            .await,
+        sandbox,
+    )
+}
+
+async fn build_graph(fixture: &str) -> WorkspaceGraph {
+    build_graph_with_sandbox(fixture).await.0
 }
 
 mod affected_projects {
@@ -454,6 +461,44 @@ mod affected_tasks {
         );
     }
 
+    #[tokio::test]
+    async fn affected_by_file_if_content_matches() {
+        let (workspace_graph, sandbox) = build_graph_with_sandbox("tasks").await;
+        sandbox.create_file("base/file.txt", "bar");
+
+        let touched_files = FxHashSet::from_iter(["base/file.txt".into()]);
+
+        let mut tracker = AffectedTracker::new(workspace_graph.into(), touched_files);
+        tracker
+            .track_tasks_by_target(&[Target::parse("base:by-file-match").unwrap()])
+            .unwrap();
+        let affected = tracker.build();
+
+        assert_eq!(
+            affected.tasks,
+            FxHashMap::from_iter([(
+                Target::parse("base:by-file-match").unwrap(),
+                create_state_from_file("base/file.txt")
+            )])
+        );
+    }
+
+    #[tokio::test]
+    async fn not_affected_by_file_if_content_doesnt_match() {
+        let (workspace_graph, sandbox) = build_graph_with_sandbox("tasks").await;
+        sandbox.create_file("base/file.txt", "foo");
+
+        let touched_files = FxHashSet::from_iter(["base/file.txt".into()]);
+
+        let mut tracker = AffectedTracker::new(workspace_graph.into(), touched_files);
+        tracker
+            .track_tasks_by_target(&[Target::parse("base:by-file-match").unwrap()])
+            .unwrap();
+        let affected = tracker.build();
+
+        assert!(affected.tasks.is_empty());
+    }
+
     #[tokio::test]
     async fn affected_by_glob() {
         let workspace_graph = build_graph("tasks").await;

crates/affected/tests/affected_tracker_test.rs

@@ -5,6 +5,7 @@ use moon_common::Id;
 use moon_project_graph::{Project, ProjectGraph};
 use moon_task_graph::{Target, Task, TaskGraph};
 use scc::HashMap;
+use std::path::PathBuf;
 use std::{path::Path, sync::Arc};
 
 pub use moon_graph_utils::*;
@@ -15,6 +16,7 @@ pub use moon_task_graph as tasks;
 pub struct WorkspaceGraph {
     pub projects: Arc<ProjectGraph>,
     pub tasks: Arc<TaskGraph>,
+    pub root: PathBuf,
 
     /// Cache of query results, mapped by query input to project IDs.
     project_query_cache: HashMap<String, Arc<Vec<Id>>>,
@@ -24,10 +26,11 @@ pub struct WorkspaceGraph {
 }
 
 impl WorkspaceGraph {
-    pub fn new(projects: Arc<ProjectGraph>, tasks: Arc<TaskGraph>) -> Self {
+    pub fn new(projects: Arc<ProjectGraph>, tasks: Arc<TaskGraph>, root: PathBuf) -> Self {
         Self {
             projects,
             tasks,
+            root,
             project_query_cache: HashMap::default(),
             task_query_cache: HashMap::default(),
         }

crates/workspace-graph/src/lib.rs

@@ -273,7 +273,11 @@ impl<'app> WorkspaceBuilder<'app> {
             Arc::clone(&project_graph),
         ));
 
-        Ok(WorkspaceGraph::new(project_graph, task_graph))
+        Ok(WorkspaceGraph::new(
+            project_graph,
+            task_graph,
+            context.workspace_root.to_path_buf(),
+        ))
     }
 
     /// Load a single project by ID or alias into the graph.