command-stream 0.8.2 → 0.9.0

package/rust/src/commands/touch.rs

@@ -0,0 +1,99 @@
+//! Virtual `touch` command implementation
+
+use crate::commands::CommandContext;
+use crate::utils::{trace_lazy, CommandResult, VirtualUtils};
+use std::fs::{self, OpenOptions};
+use std::time::SystemTime;
+
+/// Execute the touch command
+///
+/// Updates file timestamps or creates empty files.
+pub async fn touch(ctx: CommandContext) -> CommandResult {
+    if ctx.args.is_empty() {
+        return VirtualUtils::missing_operand_error("touch");
+    }
+
+    let cwd = ctx.get_cwd();
+
+    for file in &ctx.args {
+        if file.starts_with('-') {
+            // Skip flags for now
+            continue;
+        }
+
+        let resolved_path = VirtualUtils::resolve_path(file, Some(&cwd));
+
+        trace_lazy("VirtualCommand", || {
+            format!("touch: touching {:?}", resolved_path)
+        });
+
+        if resolved_path.exists() {
+            // Update modification time
+            let now = SystemTime::now();
+            if let Err(e) = filetime::set_file_mtime(&resolved_path, filetime::FileTime::from_system_time(now)) {
+                // Fallback: try to just open and close the file
+                if let Err(e2) = OpenOptions::new().write(true).open(&resolved_path) {
+                    return CommandResult::error(format!("touch: cannot touch '{}': {}\n", file, e2));
+                }
+            }
+        } else {
+            // Create the file
+            if let Some(parent) = resolved_path.parent() {
+                if !parent.exists() {
+                    if let Err(e) = fs::create_dir_all(parent) {
+                        return CommandResult::error(format!("touch: cannot touch '{}': {}\n", file, e));
+                    }
+                }
+            }
+
+            if let Err(e) = fs::File::create(&resolved_path) {
+                return CommandResult::error(format!("touch: cannot touch '{}': {}\n", file, e));
+            }
+        }
+    }
+
+    CommandResult::success_empty()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::tempdir;
+
+    #[tokio::test]
+    async fn test_touch_new_file() {
+        let temp = tempdir().unwrap();
+        let new_file = temp.path().join("new_file.txt");
+
+        let ctx = CommandContext::new(vec![
+            new_file.to_string_lossy().to_string()
+        ]);
+        let result = touch(ctx).await;
+
+        assert!(result.is_success());
+        assert!(new_file.exists());
+    }
+
+    #[tokio::test]
+    async fn test_touch_existing_file() {
+        let temp = tempdir().unwrap();
+        let file = temp.path().join("existing.txt");
+        fs::write(&file, "test").unwrap();
+
+        let ctx = CommandContext::new(vec![
+            file.to_string_lossy().to_string()
+        ]);
+        let result = touch(ctx).await;
+
+        assert!(result.is_success());
+    }
+
+    #[tokio::test]
+    async fn test_touch_missing_operand() {
+        let ctx = CommandContext::new(vec![]);
+        let result = touch(ctx).await;
+
+        assert!(!result.is_success());
+        assert!(result.stderr.contains("missing operand"));
+    }
+}

package/rust/src/commands/true.rs

@@ -0,0 +1,24 @@
+//! Virtual `true` command implementation
+
+use crate::commands::CommandContext;
+use crate::utils::CommandResult;
+
+/// Execute the true command
+///
+/// Always returns success (exit code 0).
+pub async fn r#true(_ctx: CommandContext) -> CommandResult {
+    CommandResult::success_empty()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_true() {
+        let ctx = CommandContext::new(vec![]);
+        let result = r#true(ctx).await;
+        assert!(result.is_success());
+        assert_eq!(result.code, 0);
+    }
+}

package/rust/src/commands/which.rs

@@ -0,0 +1,87 @@
+//! Virtual `which` command implementation
+
+use crate::commands::CommandContext;
+use crate::utils::{CommandResult, VirtualUtils};
+
+/// List of virtual (shell builtin) commands
+const VIRTUAL_COMMANDS: &[&str] = &[
+    "echo", "pwd", "cd", "true", "false", "sleep", "cat", "ls", "mkdir", "rm",
+    "touch", "cp", "mv", "basename", "dirname", "env", "exit", "which", "yes",
+    "seq", "test",
+];
+
+/// Execute the which command
+///
+/// Locates commands in the PATH or identifies shell builtins.
+pub async fn which(ctx: CommandContext) -> CommandResult {
+    if ctx.args.is_empty() {
+        return VirtualUtils::missing_operand_error("which");
+    }
+
+    let mut output = String::new();
+    let mut errors = String::new();
+    let mut found_all = true;
+
+    for cmd in &ctx.args {
+        if cmd.starts_with('-') {
+            continue;
+        }
+
+        // Check if it's a virtual/builtin command
+        if VIRTUAL_COMMANDS.contains(&cmd.as_str()) {
+            output.push_str(&format!("{}: shell builtin\n", cmd));
+        } else {
+            // Try to find in PATH
+            match which::which(cmd) {
+                Ok(path) => {
+                    output.push_str(&format!("{}\n", path.display()));
+                }
+                Err(_) => {
+                    found_all = false;
+                    errors.push_str(&format!("which: no {} in PATH\n", cmd));
+                }
+            }
+        }
+    }
+
+    if output.is_empty() {
+        CommandResult {
+            stdout: String::new(),
+            stderr: errors,
+            code: 1,
+        }
+    } else if !found_all {
+        // Some commands found, some not
+        CommandResult {
+            stdout: output,
+            stderr: errors,
+            code: 1,
+        }
+    } else {
+        CommandResult::success(output)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_which_existing_command() {
+        // 'sh' should exist on most Unix systems
+        let ctx = CommandContext::new(vec!["sh".to_string()]);
+        let result = which(ctx).await;
+
+        // May or may not find sh depending on PATH
+        // Just check it doesn't panic
+        assert!(result.code == 0 || result.code == 1);
+    }
+
+    #[tokio::test]
+    async fn test_which_nonexistent_command() {
+        let ctx = CommandContext::new(vec!["nonexistent_command_12345".to_string()]);
+        let result = which(ctx).await;
+
+        assert_eq!(result.code, 1);
+    }
+}

package/rust/src/commands/yes.rs

@@ -0,0 +1,99 @@
+//! Virtual `yes` command implementation
+
+use crate::commands::{CommandContext, StreamChunk};
+use crate::utils::{trace_lazy, CommandResult};
+use tokio::time::Duration;
+
+/// Execute the yes command
+///
+/// Outputs a string repeatedly until cancelled.
+pub async fn yes(ctx: CommandContext) -> CommandResult {
+    let output_str = if ctx.args.is_empty() {
+        "y".to_string()
+    } else {
+        ctx.args.join(" ")
+    };
+
+    let line = format!("{}\n", output_str);
+
+    trace_lazy("VirtualCommand", || {
+        format!("yes: starting with output '{}'", output_str)
+    });
+
+    // If we have a streaming output channel, use it
+    if let Some(ref tx) = ctx.output_tx {
+        loop {
+            if ctx.is_cancelled() {
+                trace_lazy("VirtualCommand", || "yes: cancelled".to_string());
+                return CommandResult::error_with_code("", 130);
+            }
+
+            if tx.send(StreamChunk::Stdout(line.clone())).await.is_err() {
+                // Channel closed
+                break;
+            }
+
+            // Small delay to prevent overwhelming
+            tokio::time::sleep(Duration::from_micros(100)).await;
+        }
+    } else {
+        // Without streaming, just output a few lines and return
+        // This is a safety measure to prevent infinite output
+        let mut output = String::new();
+        let max_iterations = 1000;
+
+        for _ in 0..max_iterations {
+            if ctx.is_cancelled() {
+                trace_lazy("VirtualCommand", || "yes: cancelled".to_string());
+                return CommandResult::error_with_code("", 130);
+            }
+            output.push_str(&line);
+        }
+
+        return CommandResult::success(output);
+    }
+
+    CommandResult::error_with_code("", 130)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::atomic::{AtomicBool, Ordering};
+    use std::sync::Arc;
+
+    #[tokio::test]
+    async fn test_yes_with_cancellation() {
+        let cancelled = Arc::new(AtomicBool::new(false));
+        let cancelled_clone = cancelled.clone();
+
+        let mut ctx = CommandContext::new(vec![]);
+        ctx.is_cancelled = Some(Box::new(move || cancelled_clone.load(Ordering::SeqCst)));
+
+        // Cancel after a short delay
+        tokio::spawn(async move {
+            tokio::time::sleep(Duration::from_millis(10)).await;
+            cancelled.store(true, Ordering::SeqCst);
+        });
+
+        let result = yes(ctx).await;
+
+        // Should have produced some output before being cancelled
+        assert!(!result.stdout.is_empty() || result.code == 130);
+    }
+
+    #[tokio::test]
+    async fn test_yes_custom_string() {
+        let cancelled = Arc::new(AtomicBool::new(false));
+        let cancelled_clone = cancelled.clone();
+
+        let mut ctx = CommandContext::new(vec!["hello".to_string()]);
+        ctx.is_cancelled = Some(Box::new(move || cancelled_clone.load(Ordering::SeqCst)));
+
+        // Cancel immediately
+        cancelled.store(true, Ordering::SeqCst);
+
+        let result = yes(ctx).await;
+        assert_eq!(result.code, 130);
+    }
+}