command-stream 0.8.2 → 0.9.0

package/rust/src/commands/rm.rs

@@ -0,0 +1,150 @@
+//! Virtual `rm` command implementation
+
+use crate::commands::CommandContext;
+use crate::utils::{trace_lazy, CommandResult, VirtualUtils};
+use std::fs;
+
+/// Execute the rm command
+///
+/// Removes files and directories.
+pub async fn rm(ctx: CommandContext) -> CommandResult {
+    if ctx.args.is_empty() {
+        return VirtualUtils::missing_operand_error("rm");
+    }
+
+    // Parse flags
+    let mut recursive = false;
+    let mut force = false;
+    let mut paths = Vec::new();
+
+    for arg in &ctx.args {
+        if arg == "-r" || arg == "-R" || arg == "--recursive" {
+            recursive = true;
+        } else if arg == "-f" || arg == "--force" {
+            force = true;
+        } else if arg == "-rf" || arg == "-fr" {
+            recursive = true;
+            force = true;
+        } else if arg.starts_with('-') {
+            // Check for combined flags like -rf
+            if arg.contains('r') || arg.contains('R') {
+                recursive = true;
+            }
+            if arg.contains('f') {
+                force = true;
+            }
+        } else {
+            paths.push(arg.clone());
+        }
+    }
+
+    if paths.is_empty() {
+        return VirtualUtils::missing_operand_error("rm");
+    }
+
+    let cwd = ctx.get_cwd();
+
+    for path_str in paths {
+        let resolved_path = VirtualUtils::resolve_path(&path_str, Some(&cwd));
+
+        trace_lazy("VirtualCommand", || {
+            format!("rm: removing {:?}, recursive: {}, force: {}", resolved_path, recursive, force)
+        });
+
+        if !resolved_path.exists() {
+            if !force {
+                return CommandResult::error(format!(
+                    "rm: cannot remove '{}': No such file or directory\n",
+                    path_str
+                ));
+            }
+            continue;
+        }
+
+        let result = if resolved_path.is_dir() {
+            if recursive {
+                fs::remove_dir_all(&resolved_path)
+            } else {
+                return CommandResult::error(format!(
+                    "rm: cannot remove '{}': Is a directory\n",
+                    path_str
+                ));
+            }
+        } else {
+            fs::remove_file(&resolved_path)
+        };
+
+        if let Err(e) = result {
+            if !force {
+                return CommandResult::error(format!("rm: cannot remove '{}': {}\n", path_str, e));
+            }
+        }
+    }
+
+    CommandResult::success_empty()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Write;
+    use tempfile::{tempdir, NamedTempFile};
+
+    #[tokio::test]
+    async fn test_rm_file() {
+        let mut temp = NamedTempFile::new().unwrap();
+        writeln!(temp, "test").unwrap();
+        let path = temp.path().to_path_buf();
+
+        // Keep the file but get the path
+        let path_str = path.to_string_lossy().to_string();
+        drop(temp);
+
+        // Create file again
+        fs::write(&path, "test").unwrap();
+
+        let ctx = CommandContext::new(vec![path_str.clone()]);
+        let result = rm(ctx).await;
+
+        assert!(result.is_success());
+        assert!(!path.exists());
+    }
+
+    #[tokio::test]
+    async fn test_rm_directory_recursive() {
+        let temp = tempdir().unwrap();
+        let dir = temp.path().join("subdir");
+        fs::create_dir(&dir).unwrap();
+        fs::write(dir.join("file.txt"), "test").unwrap();
+
+        let ctx = CommandContext::new(vec![
+            "-r".to_string(),
+            dir.to_string_lossy().to_string(),
+        ]);
+        let result = rm(ctx).await;
+
+        assert!(result.is_success());
+        assert!(!dir.exists());
+    }
+
+    #[tokio::test]
+    async fn test_rm_nonexistent_force() {
+        let ctx = CommandContext::new(vec![
+            "-f".to_string(),
+            "/nonexistent/file/12345".to_string(),
+        ]);
+        let result = rm(ctx).await;
+
+        assert!(result.is_success());
+    }
+
+    #[tokio::test]
+    async fn test_rm_nonexistent_no_force() {
+        let ctx = CommandContext::new(vec![
+            "/nonexistent/file/12345".to_string()
+        ]);
+        let result = rm(ctx).await;
+
+        assert!(!result.is_success());
+    }
+}

package/rust/src/commands/seq.rs

@@ -0,0 +1,179 @@
+//! Virtual `seq` command implementation
+
+use crate::commands::CommandContext;
+use crate::utils::{CommandResult, VirtualUtils};
+
+/// Execute the seq command
+///
+/// Prints a sequence of numbers.
+pub async fn seq(ctx: CommandContext) -> CommandResult {
+    if ctx.args.is_empty() {
+        return VirtualUtils::missing_operand_error("seq");
+    }
+
+    let (first, increment, last) = match ctx.args.len() {
+        1 => {
+            let last: f64 = match ctx.args[0].parse() {
+                Ok(n) => n,
+                Err(_) => {
+                    return CommandResult::error(format!(
+                        "seq: invalid floating point argument: '{}'\n",
+                        ctx.args[0]
+                    ));
+                }
+            };
+            (1.0, 1.0, last)
+        }
+        2 => {
+            let first: f64 = match ctx.args[0].parse() {
+                Ok(n) => n,
+                Err(_) => {
+                    return CommandResult::error(format!(
+                        "seq: invalid floating point argument: '{}'\n",
+                        ctx.args[0]
+                    ));
+                }
+            };
+            let last: f64 = match ctx.args[1].parse() {
+                Ok(n) => n,
+                Err(_) => {
+                    return CommandResult::error(format!(
+                        "seq: invalid floating point argument: '{}'\n",
+                        ctx.args[1]
+                    ));
+                }
+            };
+            (first, 1.0, last)
+        }
+        _ => {
+            let first: f64 = match ctx.args[0].parse() {
+                Ok(n) => n,
+                Err(_) => {
+                    return CommandResult::error(format!(
+                        "seq: invalid floating point argument: '{}'\n",
+                        ctx.args[0]
+                    ));
+                }
+            };
+            let increment: f64 = match ctx.args[1].parse() {
+                Ok(n) => n,
+                Err(_) => {
+                    return CommandResult::error(format!(
+                        "seq: invalid floating point argument: '{}'\n",
+                        ctx.args[1]
+                    ));
+                }
+            };
+            let last: f64 = match ctx.args[2].parse() {
+                Ok(n) => n,
+                Err(_) => {
+                    return CommandResult::error(format!(
+                        "seq: invalid floating point argument: '{}'\n",
+                        ctx.args[2]
+                    ));
+                }
+            };
+            (first, increment, last)
+        }
+    };
+
+    if increment == 0.0 {
+        return CommandResult::error("seq: zero increment\n");
+    }
+
+    let mut output = String::new();
+    let mut current = first;
+
+    if increment > 0.0 {
+        while current <= last {
+            if ctx.is_cancelled() {
+                return CommandResult::error_with_code("", 130);
+            }
+
+            // Format as integer if possible
+            if current.fract() == 0.0 {
+                output.push_str(&format!("{}\n", current as i64));
+            } else {
+                output.push_str(&format!("{}\n", current));
+            }
+            current += increment;
+        }
+    } else {
+        while current >= last {
+            if ctx.is_cancelled() {
+                return CommandResult::error_with_code("", 130);
+            }
+
+            if current.fract() == 0.0 {
+                output.push_str(&format!("{}\n", current as i64));
+            } else {
+                output.push_str(&format!("{}\n", current));
+            }
+            current += increment;
+        }
+    }
+
+    CommandResult::success(output)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_seq_single_arg() {
+        let ctx = CommandContext::new(vec!["5".to_string()]);
+        let result = seq(ctx).await;
+
+        assert!(result.is_success());
+        assert_eq!(result.stdout, "1\n2\n3\n4\n5\n");
+    }
+
+    #[tokio::test]
+    async fn test_seq_two_args() {
+        let ctx = CommandContext::new(vec!["3".to_string(), "7".to_string()]);
+        let result = seq(ctx).await;
+
+        assert!(result.is_success());
+        assert_eq!(result.stdout, "3\n4\n5\n6\n7\n");
+    }
+
+    #[tokio::test]
+    async fn test_seq_three_args() {
+        let ctx = CommandContext::new(vec![
+            "2".to_string(),
+            "2".to_string(),
+            "8".to_string(),
+        ]);
+        let result = seq(ctx).await;
+
+        assert!(result.is_success());
+        assert_eq!(result.stdout, "2\n4\n6\n8\n");
+    }
+
+    #[tokio::test]
+    async fn test_seq_descending() {
+        let ctx = CommandContext::new(vec![
+            "5".to_string(),
+            "-1".to_string(),
+            "1".to_string(),
+        ]);
+        let result = seq(ctx).await;
+
+        assert!(result.is_success());
+        assert_eq!(result.stdout, "5\n4\n3\n2\n1\n");
+    }
+
+    #[tokio::test]
+    async fn test_seq_zero_increment() {
+        let ctx = CommandContext::new(vec![
+            "1".to_string(),
+            "0".to_string(),
+            "5".to_string(),
+        ]);
+        let result = seq(ctx).await;
+
+        assert!(!result.is_success());
+        assert!(result.stderr.contains("zero increment"));
+    }
+}

package/rust/src/commands/sleep.rs

@@ -0,0 +1,97 @@
+//! Virtual `sleep` command implementation
+
+use crate::commands::CommandContext;
+use crate::utils::{trace_lazy, CommandResult};
+use tokio::time::{sleep as tokio_sleep, Duration};
+
+/// Execute the sleep command
+///
+/// Pauses for the specified number of seconds.
+pub async fn sleep(ctx: CommandContext) -> CommandResult {
+    let seconds_str = ctx.args.first().map(|s| s.as_str()).unwrap_or("0");
+
+    let seconds: f64 = match seconds_str.parse() {
+        Ok(s) => s,
+        Err(_) => {
+            return CommandResult::error(format!(
+                "sleep: invalid time interval '{}'\n",
+                seconds_str
+            ));
+        }
+    };
+
+    if seconds < 0.0 {
+        return CommandResult::error(format!(
+            "sleep: invalid time interval '{}'\n",
+            seconds_str
+        ));
+    }
+
+    trace_lazy("VirtualCommand", || {
+        format!("sleep: starting {} seconds", seconds)
+    });
+
+    let duration = Duration::from_secs_f64(seconds);
+
+    // Check for cancellation during sleep
+    tokio::select! {
+        _ = tokio_sleep(duration) => {
+            trace_lazy("VirtualCommand", || {
+                format!("sleep: completed naturally after {} seconds", seconds)
+            });
+            CommandResult::success_empty()
+        }
+        _ = async {
+            loop {
+                tokio::time::sleep(Duration::from_millis(100)).await;
+                if ctx.is_cancelled() {
+                    break;
+                }
+            }
+        } => {
+            trace_lazy("VirtualCommand", || {
+                format!("sleep: cancelled after partial sleep")
+            });
+            CommandResult::error_with_code("", 130) // SIGINT exit code
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::time::Instant;
+
+    #[tokio::test]
+    async fn test_sleep_short() {
+        let ctx = CommandContext::new(vec!["0.1".to_string()]);
+        let start = Instant::now();
+        let result = sleep(ctx).await;
+        let elapsed = start.elapsed();
+
+        assert!(result.is_success());
+        assert!(elapsed >= Duration::from_millis(100));
+        assert!(elapsed < Duration::from_millis(200));
+    }
+
+    #[tokio::test]
+    async fn test_sleep_zero() {
+        let ctx = CommandContext::new(vec!["0".to_string()]);
+        let result = sleep(ctx).await;
+        assert!(result.is_success());
+    }
+
+    #[tokio::test]
+    async fn test_sleep_invalid() {
+        let ctx = CommandContext::new(vec!["invalid".to_string()]);
+        let result = sleep(ctx).await;
+        assert!(!result.is_success());
+    }
+
+    #[tokio::test]
+    async fn test_sleep_negative() {
+        let ctx = CommandContext::new(vec!["-1".to_string()]);
+        let result = sleep(ctx).await;
+        assert!(!result.is_success());
+    }
+}

package/rust/src/commands/test.rs

@@ -0,0 +1,204 @@
+//! Virtual `test` command implementation
+
+use crate::commands::CommandContext;
+use crate::utils::CommandResult;
+use std::fs;
+use std::path::Path;
+
+/// Execute the test command
+///
+/// Evaluates conditional expressions.
+pub async fn test(ctx: CommandContext) -> CommandResult {
+    if ctx.args.is_empty() {
+        return CommandResult::error_with_code("", 1);
+    }
+
+    let result = evaluate_expression(&ctx.args);
+
+    if result {
+        CommandResult::success_empty()
+    } else {
+        CommandResult::error_with_code("", 1)
+    }
+}
+
+fn evaluate_expression(args: &[String]) -> bool {
+    if args.is_empty() {
+        return false;
+    }
+
+    // Handle unary operators
+    if args.len() == 2 {
+        let op = &args[0];
+        let arg = &args[1];
+
+        return match op.as_str() {
+            "-e" => Path::new(arg).exists(),
+            "-f" => Path::new(arg).is_file(),
+            "-d" => Path::new(arg).is_dir(),
+            "-r" => {
+                // Check if readable (simplified)
+                fs::metadata(arg).is_ok()
+            }
+            "-w" => {
+                // Check if writable (simplified)
+                fs::metadata(arg).map(|m| !m.permissions().readonly()).unwrap_or(false)
+            }
+            "-x" => {
+                // Check if executable (simplified - Unix only)
+                #[cfg(unix)]
+                {
+                    use std::os::unix::fs::PermissionsExt;
+                    fs::metadata(arg)
+                        .map(|m| m.permissions().mode() & 0o111 != 0)
+                        .unwrap_or(false)
+                }
+                #[cfg(not(unix))]
+                {
+                    Path::new(arg).exists()
+                }
+            }
+            "-s" => {
+                // Check if file has size > 0
+                fs::metadata(arg).map(|m| m.len() > 0).unwrap_or(false)
+            }
+            "-z" => arg.is_empty(),
+            "-n" => !arg.is_empty(),
+            "!" => !evaluate_expression(&args[1..]),
+            _ => false,
+        };
+    }
+
+    // Handle binary operators
+    if args.len() == 3 {
+        let left = &args[0];
+        let op = &args[1];
+        let right = &args[2];
+
+        return match op.as_str() {
+            "=" | "==" => left == right,
+            "!=" => left != right,
+            "-eq" => {
+                let l: i64 = left.parse().unwrap_or(0);
+                let r: i64 = right.parse().unwrap_or(0);
+                l == r
+            }
+            "-ne" => {
+                let l: i64 = left.parse().unwrap_or(0);
+                let r: i64 = right.parse().unwrap_or(0);
+                l != r
+            }
+            "-lt" => {
+                let l: i64 = left.parse().unwrap_or(0);
+                let r: i64 = right.parse().unwrap_or(0);
+                l < r
+            }
+            "-le" => {
+                let l: i64 = left.parse().unwrap_or(0);
+                let r: i64 = right.parse().unwrap_or(0);
+                l <= r
+            }
+            "-gt" => {
+                let l: i64 = left.parse().unwrap_or(0);
+                let r: i64 = right.parse().unwrap_or(0);
+                l > r
+            }
+            "-ge" => {
+                let l: i64 = left.parse().unwrap_or(0);
+                let r: i64 = right.parse().unwrap_or(0);
+                l >= r
+            }
+            _ => false,
+        };
+    }
+
+    // Single argument: true if non-empty
+    if args.len() == 1 {
+        return !args[0].is_empty();
+    }
+
+    false
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::tempdir;
+
+    #[tokio::test]
+    async fn test_file_exists() {
+        let temp = tempdir().unwrap();
+        let file = temp.path().join("test.txt");
+        fs::write(&file, "test").unwrap();
+
+        let ctx = CommandContext::new(vec![
+            "-e".to_string(),
+            file.to_string_lossy().to_string(),
+        ]);
+        let result = test(ctx).await;
+        assert!(result.is_success());
+    }
+
+    #[tokio::test]
+    async fn test_file_not_exists() {
+        let ctx = CommandContext::new(vec![
+            "-e".to_string(),
+            "/nonexistent/file/12345".to_string(),
+        ]);
+        let result = test(ctx).await;
+        assert!(!result.is_success());
+    }
+
+    #[tokio::test]
+    async fn test_string_equality() {
+        let ctx = CommandContext::new(vec![
+            "hello".to_string(),
+            "=".to_string(),
+            "hello".to_string(),
+        ]);
+        let result = test(ctx).await;
+        assert!(result.is_success());
+    }
+
+    #[tokio::test]
+    async fn test_string_inequality() {
+        let ctx = CommandContext::new(vec![
+            "hello".to_string(),
+            "!=".to_string(),
+            "world".to_string(),
+        ]);
+        let result = test(ctx).await;
+        assert!(result.is_success());
+    }
+
+    #[tokio::test]
+    async fn test_numeric_comparison() {
+        let ctx = CommandContext::new(vec![
+            "5".to_string(),
+            "-gt".to_string(),
+            "3".to_string(),
+        ]);
+        let result = test(ctx).await;
+        assert!(result.is_success());
+    }
+
+    #[tokio::test]
+    async fn test_empty_string() {
+        let ctx = CommandContext::new(vec![
+            "-z".to_string(),
+            "".to_string(),
+        ]);
+        let result = test(ctx).await;
+        assert!(result.is_success());
+    }
+
+    #[tokio::test]
+    async fn test_non_empty_string() {
+        let ctx = CommandContext::new(vec![
+            "-n".to_string(),
+            "hello".to_string(),
+        ]);
+        let result = test(ctx).await;
+        assert!(result.is_success());
+    }
+}