Initial pass at watch filtering

crates/aiken-project/src/watch.rs

@@ -162,6 +162,7 @@ where
 /// ```
 pub fn watch_project<F, A>(
     directory: Option<&Path>,
+    rebuild: Option<std::sync::mpsc::Receiver<()>>,
     filter: F,
     debounce: u32,
     mut action: A,
@@ -225,8 +226,14 @@ where
         // release the lock here, in case other events come in
         drop(queue);
 
+        let force_rebuild = if let Some(ref r) = rebuild {
+            r.try_recv().is_ok()
+        } else {
+            false
+        };
+
         // If we have an event that survived the filter, then we can construct the project and invoke the action
-        if latest.is_some() {
+        if latest.is_some() || force_rebuild {
             print!("{esc}c", esc = 27 as char);
             eprint!("{esc}c", esc = 27 as char);
             eprintln!(

crates/aiken/Cargo.toml

@@ -30,6 +30,8 @@ regex = "1.7.1"
 serde_json = "1.0.94"
 thiserror = "1.0.39"
 
+termion = "3.0.0"
+
 aiken-lang = { path = "../aiken-lang", version = "1.0.24-alpha" }
 aiken-lsp = { path = "../aiken-lsp", version = "1.0.24-alpha" }
 aiken-project = { path = '../aiken-project', version = "1.0.24-alpha" }

crates/aiken/src/cmd/build.rs

@@ -51,15 +51,21 @@ pub fn exec(
     }: Args,
 ) -> miette::Result<()> {
     let result = if watch {
-        watch_project(directory.as_deref(), watch::default_filter, 500, |p| {
-            p.build(
-                uplc,
-                match filter_traces {
-                    Some(filter_traces) => filter_traces(trace_level),
-                    None => Tracing::All(trace_level),
-                },
-            )
-        })
+        watch_project(
+            directory.as_deref(),
+            None,
+            watch::default_filter,
+            500,
+            |p| {
+                p.build(
+                    uplc,
+                    match filter_traces {
+                        Some(filter_traces) => filter_traces(trace_level),
+                        None => Tracing::All(trace_level),
+                    },
+                )
+            },
+        )
     } else {
         with_project(directory.as_deref(), deny, |p| {
             p.build(

crates/aiken/src/cmd/check.rs

@@ -4,8 +4,15 @@ use aiken_project::{
     test_framework::PropertyTest,
     watch::{self, watch_project, with_project},
 };
+use owo_colors::{OwoColorize, Stream::Stderr};
 use rand::prelude::*;
-use std::{path::PathBuf, process};
+use std::{
+    path::PathBuf,
+    process,
+    sync::{Arc, Mutex},
+    thread,
+};
+use termion::input::TermRead;
 
 #[derive(clap::Args)]
 /// Type-check an Aiken project
@@ -87,20 +94,79 @@ pub fn exec(
     let seed = seed.unwrap_or_else(|| rng.gen());
 
     let result = if watch {
-        watch_project(directory.as_deref(), watch::default_filter, 500, |p| {
-            p.check(
-                skip_tests,
-                match_tests.clone(),
-                debug,
-                exact_match,
-                seed,
-                max_success,
-                match filter_traces {
-                    Some(filter_traces) => filter_traces(trace_level),
-                    None => Tracing::All(trace_level),
-                },
-            )
-        })
+        let mut stdin = termion::async_stdin().keys();
+
+        let (sender, receiver) = std::sync::mpsc::channel();
+        let filter = Arc::new(Mutex::new("".to_string()));
+        {
+            let filter = filter.clone();
+            thread::spawn(move || {
+                let mut working = "".to_string();
+                loop {
+                    if let Some(c) = stdin.next() {
+                        match c {
+                            Ok(termion::event::Key::Backspace) => {
+                                if !working.is_empty() {
+                                    working = working[..working.len() - 1].to_string();
+                                }
+                            }
+                            Ok(termion::event::Key::Char('\n')) => {
+                                let mut filt = filter.lock().unwrap();
+                                *filt = working;
+                                working = "".to_string();
+                                sender.send(()).unwrap();
+                            }
+                            Ok(termion::event::Key::Char(c)) => {
+                                working.push(c);
+                            }
+                            _ => {}
+                        }
+                    }
+                }
+            });
+        }
+
+        watch_project(
+            directory.as_deref(),
+            Some(receiver),
+            watch::default_filter,
+            500,
+            |p| {
+                let filt = filter.lock().unwrap();
+                let final_match_tests = match match_tests.clone() {
+                    Some(existing) if filt.is_empty() => Some(existing),
+                    Some(existing) => {
+                        let mut e = existing.clone();
+                        e.push(filt.clone());
+                        Some(e)
+                    }
+                    None if !filt.is_empty() => Some(vec![filt.clone()]),
+                    None => None,
+                };
+                let result = p.check(
+                    skip_tests,
+                    final_match_tests.clone(),
+                    debug,
+                    exact_match,
+                    seed,
+                    max_success,
+                    match filter_traces {
+                        Some(filter_traces) => filter_traces(trace_level),
+                        None => Tracing::All(trace_level),
+                    },
+                );
+                if let Some(fmt) = final_match_tests {
+                    println!(
+                        "      {} {}",
+                        "Filtered by:"
+                            .if_supports_color(Stderr, |s| s.bold())
+                            .if_supports_color(Stderr, |s| s.purple()),
+                        fmt.join(", ")
+                    );
+                }
+                result
+            },
+        )
     } else {
         with_project(directory.as_deref(), deny, |p| {
             p.check(

crates/aiken/src/cmd/docs.rs

@@ -34,9 +34,13 @@ pub fn exec(
     }: Args,
 ) -> miette::Result<()> {
     let result = if watch {
-        watch_project(directory.as_deref(), watch::default_filter, 500, |p| {
-            p.docs(destination.clone(), include_dependencies)
-        })
+        watch_project(
+            directory.as_deref(),
+            None,
+            watch::default_filter,
+            500,
+            |p| p.docs(destination.clone(), include_dependencies),
+        )
     } else {
         with_project(directory.as_deref(), deny, |p| {
             p.docs(destination.clone(), include_dependencies)