command-stream 0.9.1 → 0.9.2

package/rust/src/utils.rs

@@ -1,55 +1,25 @@
 //! Utility functions and types for command-stream
 //!
-//! This module provides helper functions for tracing, error handling,
-//! and common file system operations used by virtual commands.
+//! This module provides helper functions for command results, virtual command
+//! utilities, and re-exports from specialized utility modules.
+//!
+//! ## Module Organization
+//!
+//! The utilities are organized into focused modules following the same
+//! modular pattern as the JavaScript implementation:
+//!
+//! - `trace` - Logging and tracing utilities
+//! - `ansi` - ANSI escape code handling
+//! - `quote` - Shell quoting utilities
+//! - `utils` (this module) - Command results and virtual command helpers
 
 use std::env;
 use std::path::{Path, PathBuf};
 
-/// Check if tracing is enabled via environment variables
-///
-/// Tracing can be controlled via:
-/// - COMMAND_STREAM_TRACE=true/false (explicit control)
-/// - COMMAND_STREAM_VERBOSE=true (enables tracing unless TRACE=false)
-pub fn is_trace_enabled() -> bool {
-    let trace_env = env::var("COMMAND_STREAM_TRACE").ok();
-    let verbose_env = env::var("COMMAND_STREAM_VERBOSE")
-        .map(|v| v == "true")
-        .unwrap_or(false);
-
-    match trace_env.as_deref() {
-        Some("false") => false,
-        Some("true") => true,
-        _ => verbose_env,
-    }
-}
-
-/// Trace function for verbose logging
-///
-/// Outputs trace messages to stderr when tracing is enabled.
-/// Messages are prefixed with timestamp and category.
-pub fn trace(category: &str, message: &str) {
-    if !is_trace_enabled() {
-        return;
-    }
-
-    let timestamp = chrono::Utc::now().to_rfc3339();
-    eprintln!("[TRACE {}] [{}] {}", timestamp, category, message);
-}
-
-/// Trace function with lazy message evaluation
-///
-/// Only evaluates the message function if tracing is enabled.
-pub fn trace_lazy<F>(category: &str, message_fn: F)
-where
-    F: FnOnce() -> String,
-{
-    if !is_trace_enabled() {
-        return;
-    }
-
-    trace(category, &message_fn());
-}
+// Re-export from specialized modules for backwards compatibility
+pub use crate::trace::{is_trace_enabled, trace, trace_lazy};
+pub use crate::ansi::{AnsiConfig, AnsiUtils};
+pub use crate::quote::quote;
 
 /// Result type for virtual command operations
 #[derive(Debug, Clone)]
@@ -167,101 +137,6 @@ impl VirtualUtils {
     }
 }
 
-/// ANSI control character utilities
-pub struct AnsiUtils;
-
-impl AnsiUtils {
-    /// Strip ANSI escape sequences from text
-    pub fn strip_ansi(text: &str) -> String {
-        let re = regex::Regex::new(r"\x1b\[[0-9;]*[mGKHFJ]").unwrap();
-        re.replace_all(text, "").to_string()
-    }
-
-    /// Strip control characters from text, preserving newlines, carriage returns, and tabs
-    pub fn strip_control_chars(text: &str) -> String {
-        text.chars()
-            .filter(|c| {
-                // Preserve newlines (\n = \x0A), carriage returns (\r = \x0D), and tabs (\t = \x09)
-                !matches!(*c as u32,
-                    0x00..=0x08 | 0x0B | 0x0C | 0x0E..=0x1F | 0x7F
-                )
-            })
-            .collect()
-    }
-
-    /// Strip both ANSI sequences and control characters
-    pub fn strip_all(text: &str) -> String {
-        Self::strip_control_chars(&Self::strip_ansi(text))
-    }
-
-    /// Clean data for processing (strips ANSI and control chars)
-    pub fn clean_for_processing(data: &str) -> String {
-        Self::strip_all(data)
-    }
-}
-
-/// Configuration for ANSI handling
-#[derive(Debug, Clone)]
-pub struct AnsiConfig {
-    pub preserve_ansi: bool,
-    pub preserve_control_chars: bool,
-}
-
-impl Default for AnsiConfig {
-    fn default() -> Self {
-        AnsiConfig {
-            preserve_ansi: true,
-            preserve_control_chars: true,
-        }
-    }
-}
-
-impl AnsiConfig {
-    /// Process output according to config settings
-    pub fn process_output(&self, data: &str) -> String {
-        if !self.preserve_ansi && !self.preserve_control_chars {
-            AnsiUtils::clean_for_processing(data)
-        } else if !self.preserve_ansi {
-            AnsiUtils::strip_ansi(data)
-        } else if !self.preserve_control_chars {
-            AnsiUtils::strip_control_chars(data)
-        } else {
-            data.to_string()
-        }
-    }
-}
-
-/// Quote a value for safe shell usage
-pub fn quote(value: &str) -> String {
-    if value.is_empty() {
-        return "''".to_string();
-    }
-
-    // If already properly quoted, check if we can use as-is
-    if value.starts_with('\'') && value.ends_with('\'') && value.len() >= 2 {
-        let inner = &value[1..value.len() - 1];
-        if !inner.contains('\'') {
-            return value.to_string();
-        }
-    }
-
-    if value.starts_with('"') && value.ends_with('"') && value.len() > 2 {
-        // If already double-quoted, wrap in single quotes
-        return format!("'{}'", value);
-    }
-
-    // Check if the string needs quoting at all
-    // Safe characters: alphanumeric, dash, underscore, dot, slash, colon, equals, comma, plus
-    let safe_pattern = regex::Regex::new(r"^[a-zA-Z0-9_\-./=,+@:]+$").unwrap();
-
-    if safe_pattern.is_match(value) {
-        return value.to_string();
-    }
-
-    // Default behavior: wrap in single quotes and escape any internal single quotes
-    format!("'{}'", value.replace('\'', "'\\''"))
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -284,6 +159,13 @@ mod tests {
         assert_eq!(result.code, 1);
     }
 
+    #[test]
+    fn test_command_result_error_with_code() {
+        let result = CommandResult::error_with_code("permission denied", 126);
+        assert!(!result.is_success());
+        assert_eq!(result.code, 126);
+    }
+
     #[test]
     fn test_resolve_path_absolute() {
         let path = VirtualUtils::resolve_path("/absolute/path", None);
@@ -298,38 +180,51 @@ mod tests {
     }
 
     #[test]
-    fn test_strip_ansi() {
-        let text = "\x1b[31mRed text\x1b[0m";
-        assert_eq!(AnsiUtils::strip_ansi(text), "Red text");
+    fn test_validate_args_success() {
+        let args = vec!["arg1".to_string()];
+        assert!(VirtualUtils::validate_args(&args, 1, "cmd").is_none());
     }
 
     #[test]
-    fn test_strip_control_chars() {
-        let text = "Hello\x00World\nNew line\tTab";
-        assert_eq!(AnsiUtils::strip_control_chars(text), "HelloWorld\nNew line\tTab");
+    fn test_validate_args_missing() {
+        let args = vec!["arg1".to_string()];
+        let result = VirtualUtils::validate_args(&args, 2, "cmd");
+        assert!(result.is_some());
     }
 
     #[test]
-    fn test_quote_empty() {
-        assert_eq!(quote(""), "''");
+    fn test_missing_operand_error() {
+        let result = VirtualUtils::missing_operand_error("cat");
+        assert!(!result.is_success());
+        assert!(result.stderr.contains("missing operand"));
     }
 
     #[test]
-    fn test_quote_safe_chars() {
-        assert_eq!(quote("hello"), "hello");
-        assert_eq!(quote("/path/to/file"), "/path/to/file");
+    fn test_invalid_argument_error() {
+        let result = VirtualUtils::invalid_argument_error("ls", "invalid option");
+        assert!(!result.is_success());
+        assert!(result.stderr.contains("invalid option"));
     }
 
+    // Re-exported module tests are in their respective modules
+    // These tests verify the re-exports work correctly
+
     #[test]
-    fn test_quote_special_chars() {
+    fn test_reexported_quote() {
+        assert_eq!(quote("hello"), "hello");
         assert_eq!(quote("hello world"), "'hello world'");
-        assert_eq!(quote("it's"), "'it'\\''s'");
     }
 
     #[test]
-    fn test_validate_args() {
-        let args = vec!["arg1".to_string()];
-        assert!(VirtualUtils::validate_args(&args, 1, "cmd").is_none());
-        assert!(VirtualUtils::validate_args(&args, 2, "cmd").is_some());
+    fn test_reexported_ansi_utils() {
+        let text = "\x1b[31mRed text\x1b[0m";
+        assert_eq!(AnsiUtils::strip_ansi(text), "Red text");
+    }
+
+    #[test]
+    fn test_reexported_ansi_config() {
+        let config = AnsiConfig::default();
+        assert!(config.preserve_ansi);
+        assert!(config.preserve_control_chars);
     }
 }

package/rust/tests/events.rs

@@ -0,0 +1,207 @@
+//! Integration tests for the events module
+
+use command_stream::{EventData, EventType, StreamEmitter};
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
+
+#[tokio::test]
+async fn test_stream_emitter_creation() {
+    let emitter = StreamEmitter::new();
+    assert_eq!(emitter.listener_count(&EventType::Stdout).await, 0);
+}
+
+#[tokio::test]
+async fn test_stream_emitter_on_emit() {
+    let emitter = StreamEmitter::new();
+    let counter = Arc::new(AtomicUsize::new(0));
+    let counter_clone = counter.clone();
+
+    emitter
+        .on(EventType::Stdout, move |data| {
+            if let EventData::String(s) = data {
+                assert_eq!(s, "hello");
+                counter_clone.fetch_add(1, Ordering::SeqCst);
+            }
+        })
+        .await;
+
+    emitter
+        .emit(EventType::Stdout, EventData::String("hello".to_string()))
+        .await;
+
+    assert_eq!(counter.load(Ordering::SeqCst), 1);
+}
+
+#[tokio::test]
+async fn test_stream_emitter_multiple_listeners() {
+    let emitter = StreamEmitter::new();
+    let counter1 = Arc::new(AtomicUsize::new(0));
+    let counter2 = Arc::new(AtomicUsize::new(0));
+    let c1 = counter1.clone();
+    let c2 = counter2.clone();
+
+    emitter
+        .on(EventType::Stdout, move |_| {
+            c1.fetch_add(1, Ordering::SeqCst);
+        })
+        .await;
+
+    emitter
+        .on(EventType::Stdout, move |_| {
+            c2.fetch_add(1, Ordering::SeqCst);
+        })
+        .await;
+
+    emitter
+        .emit(EventType::Stdout, EventData::String("test".to_string()))
+        .await;
+
+    assert_eq!(counter1.load(Ordering::SeqCst), 1);
+    assert_eq!(counter2.load(Ordering::SeqCst), 1);
+}
+
+#[tokio::test]
+async fn test_stream_emitter_once() {
+    let emitter = StreamEmitter::new();
+    let counter = Arc::new(AtomicUsize::new(0));
+    let counter_clone = counter.clone();
+
+    emitter
+        .once(EventType::Exit, move |_| {
+            counter_clone.fetch_add(1, Ordering::SeqCst);
+        })
+        .await;
+
+    // Emit multiple times
+    emitter.emit(EventType::Exit, EventData::ExitCode(0)).await;
+    emitter.emit(EventType::Exit, EventData::ExitCode(0)).await;
+    emitter.emit(EventType::Exit, EventData::ExitCode(0)).await;
+
+    // Should only count once
+    assert_eq!(counter.load(Ordering::SeqCst), 1);
+}
+
+#[tokio::test]
+async fn test_stream_emitter_off() {
+    let emitter = StreamEmitter::new();
+    let counter = Arc::new(AtomicUsize::new(0));
+    let counter_clone = counter.clone();
+
+    emitter
+        .on(EventType::Stderr, move |_| {
+            counter_clone.fetch_add(1, Ordering::SeqCst);
+        })
+        .await;
+
+    assert_eq!(emitter.listener_count(&EventType::Stderr).await, 1);
+
+    emitter.off(EventType::Stderr).await;
+
+    assert_eq!(emitter.listener_count(&EventType::Stderr).await, 0);
+
+    // Emit after off - should not trigger listener
+    emitter
+        .emit(EventType::Stderr, EventData::String("error".to_string()))
+        .await;
+
+    assert_eq!(counter.load(Ordering::SeqCst), 0);
+}
+
+#[tokio::test]
+async fn test_stream_emitter_different_events() {
+    let emitter = StreamEmitter::new();
+    let stdout_counter = Arc::new(AtomicUsize::new(0));
+    let stderr_counter = Arc::new(AtomicUsize::new(0));
+    let exit_counter = Arc::new(AtomicUsize::new(0));
+
+    let out = stdout_counter.clone();
+    let err = stderr_counter.clone();
+    let exit = exit_counter.clone();
+
+    emitter
+        .on(EventType::Stdout, move |_| {
+            out.fetch_add(1, Ordering::SeqCst);
+        })
+        .await;
+
+    emitter
+        .on(EventType::Stderr, move |_| {
+            err.fetch_add(1, Ordering::SeqCst);
+        })
+        .await;
+
+    emitter
+        .on(EventType::Exit, move |_| {
+            exit.fetch_add(1, Ordering::SeqCst);
+        })
+        .await;
+
+    emitter
+        .emit(EventType::Stdout, EventData::String("out1".to_string()))
+        .await;
+    emitter
+        .emit(EventType::Stdout, EventData::String("out2".to_string()))
+        .await;
+    emitter
+        .emit(EventType::Stderr, EventData::String("err".to_string()))
+        .await;
+    emitter.emit(EventType::Exit, EventData::ExitCode(0)).await;
+
+    assert_eq!(stdout_counter.load(Ordering::SeqCst), 2);
+    assert_eq!(stderr_counter.load(Ordering::SeqCst), 1);
+    assert_eq!(exit_counter.load(Ordering::SeqCst), 1);
+}
+
+#[tokio::test]
+async fn test_stream_emitter_remove_all_listeners() {
+    let emitter = StreamEmitter::new();
+
+    emitter.on(EventType::Stdout, |_| {}).await;
+    emitter.on(EventType::Stderr, |_| {}).await;
+    emitter.on(EventType::Exit, |_| {}).await;
+
+    assert!(emitter.listener_count(&EventType::Stdout).await > 0);
+    assert!(emitter.listener_count(&EventType::Stderr).await > 0);
+    assert!(emitter.listener_count(&EventType::Exit).await > 0);
+
+    emitter.remove_all_listeners().await;
+
+    assert_eq!(emitter.listener_count(&EventType::Stdout).await, 0);
+    assert_eq!(emitter.listener_count(&EventType::Stderr).await, 0);
+    assert_eq!(emitter.listener_count(&EventType::Exit).await, 0);
+}
+
+#[tokio::test]
+async fn test_event_data_variants() {
+    let emitter = StreamEmitter::new();
+
+    let string_received = Arc::new(std::sync::Mutex::new(None));
+    let code_received = Arc::new(std::sync::Mutex::new(None));
+
+    let str_clone = string_received.clone();
+    let code_clone = code_received.clone();
+
+    emitter
+        .on(EventType::Stdout, move |data| {
+            if let EventData::String(s) = data {
+                *str_clone.lock().unwrap() = Some(s);
+            }
+        })
+        .await;
+
+    emitter
+        .on(EventType::Exit, move |data| {
+            if let EventData::ExitCode(code) = data {
+                *code_clone.lock().unwrap() = Some(code);
+            }
+        })
+        .await;
+
+    emitter
+        .emit(EventType::Stdout, EventData::String("test data".to_string()))
+        .await;
+    emitter.emit(EventType::Exit, EventData::ExitCode(42)).await;
+
+    assert_eq!(*string_received.lock().unwrap(), Some("test data".to_string()));
+    assert_eq!(*code_received.lock().unwrap(), Some(42));
+}

package/rust/tests/macros.rs

@@ -0,0 +1,77 @@
+//! Tests for the cmd! macro and its aliases (s!, sh!, cs!)
+
+use command_stream::{cmd, sh, s, cs};
+
+#[tokio::test]
+async fn test_cmd_macro_simple() {
+    let result = cmd!("echo hello").await.unwrap();
+    assert!(result.is_success());
+    assert!(result.stdout.contains("hello"));
+}
+
+#[tokio::test]
+async fn test_cmd_macro_with_interpolation() {
+    let name = "world";
+    let result = cmd!("echo hello {}", name).await.unwrap();
+    assert!(result.is_success());
+    assert!(result.stdout.contains("hello"));
+    assert!(result.stdout.contains("world"));
+}
+
+#[tokio::test]
+async fn test_cmd_macro_with_multiple_interpolations() {
+    let greeting = "Hello";
+    let name = "World";
+    let result = cmd!("echo {} {}", greeting, name).await.unwrap();
+    assert!(result.is_success());
+    assert!(result.stdout.contains("Hello"));
+    assert!(result.stdout.contains("World"));
+}
+
+#[tokio::test]
+async fn test_cmd_macro_with_special_chars() {
+    // Test that special characters are properly quoted
+    let filename = "test file with spaces.txt";
+    let result = cmd!("echo {}", filename).await.unwrap();
+    assert!(result.is_success());
+    // The output should contain the filename (quoted in the command)
+    assert!(result.stdout.contains("test file with spaces.txt"));
+}
+
+#[tokio::test]
+async fn test_sh_macro_alias() {
+    let result = sh!("echo hello from sh").await.unwrap();
+    assert!(result.is_success());
+    assert!(result.stdout.contains("hello from sh"));
+}
+
+#[tokio::test]
+async fn test_s_macro_alias() {
+    let result = s!("echo hello from s").await.unwrap();
+    assert!(result.is_success());
+    assert!(result.stdout.contains("hello from s"));
+}
+
+#[tokio::test]
+async fn test_cs_macro_alias() {
+    let result = cs!("echo hello from cs").await.unwrap();
+    assert!(result.is_success());
+    assert!(result.stdout.contains("hello from cs"));
+}
+
+#[tokio::test]
+async fn test_s_macro_with_interpolation() {
+    let name = "world";
+    let result = s!("echo hello {}", name).await.unwrap();
+    assert!(result.is_success());
+    assert!(result.stdout.contains("hello"));
+    assert!(result.stdout.contains("world"));
+}
+
+#[tokio::test]
+async fn test_cmd_macro_with_numbers() {
+    let count = 42;
+    let result = cmd!("echo The answer is {}", count).await.unwrap();
+    assert!(result.is_success());
+    assert!(result.stdout.contains("42"));
+}

package/rust/tests/pipeline.rs

@@ -0,0 +1,93 @@
+//! Tests for the Pipeline module
+
+use command_stream::{Pipeline, PipelineExt, ProcessRunner, RunOptions};
+
+#[tokio::test]
+async fn test_pipeline_simple() {
+    let result = Pipeline::new()
+        .add("echo hello world")
+        .run()
+        .await
+        .unwrap();
+
+    assert!(result.is_success());
+    assert!(result.stdout.contains("hello world"));
+}
+
+#[tokio::test]
+async fn test_pipeline_two_commands() {
+    let result = Pipeline::new()
+        .add("echo 'hello\nworld\nhello again'")
+        .add("grep hello")
+        .run()
+        .await
+        .unwrap();
+
+    assert!(result.is_success());
+    // The grep should filter to only lines containing "hello"
+    assert!(result.stdout.contains("hello"));
+}
+
+#[tokio::test]
+async fn test_pipeline_with_stdin() {
+    let result = Pipeline::new()
+        .stdin("line1\nline2\nline3")
+        .add("cat")
+        .run()
+        .await
+        .unwrap();
+
+    assert!(result.is_success());
+    assert!(result.stdout.contains("line1"));
+    assert!(result.stdout.contains("line2"));
+    assert!(result.stdout.contains("line3"));
+}
+
+#[tokio::test]
+async fn test_pipeline_three_commands() {
+    let result = Pipeline::new()
+        .add("echo 'apple\nbanana\napricot\nblueberry'")
+        .add("grep a")
+        .add("wc -l")
+        .run()
+        .await
+        .unwrap();
+
+    assert!(result.is_success());
+    // Should count lines containing 'a': apple, banana, apricot = 3 lines
+}
+
+#[tokio::test]
+async fn test_pipeline_empty() {
+    let result = Pipeline::new().run().await.unwrap();
+
+    // Empty pipeline should return error
+    assert!(!result.is_success());
+    assert!(result.stderr.contains("No commands"));
+}
+
+#[tokio::test]
+async fn test_pipeline_failure_propagation() {
+    let result = Pipeline::new()
+        .add("echo hello")
+        .add("false")  // This command always fails
+        .add("echo should not reach here")
+        .run()
+        .await
+        .unwrap();
+
+    // Pipeline should fail because 'false' returns non-zero
+    assert!(!result.is_success());
+}
+
+#[tokio::test]
+async fn test_pipeline_builder_pattern() {
+    // Test the fluent API
+    let pipeline = Pipeline::new()
+        .add("echo test")
+        .mirror_output(false)
+        .capture_output(true);
+
+    let result = pipeline.run().await.unwrap();
+    assert!(result.is_success());
+}