bashkit 0.1.16__tar.gz → 0.1.17__tar.gz

{bashkit-0.1.16 → bashkit-0.1.17}/Cargo.lock

@@ -319,7 +319,7 @@ checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
 
 [[package]]
 name = "bashkit"
-version = "0.1.16"
+version = "0.1.17"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -362,7 +362,7 @@ dependencies = [
 
 [[package]]
 name = "bashkit-bench"
-version = "0.1.16"
+version = "0.1.17"
 dependencies = [
  "anyhow",
  "bashkit",
@@ -378,7 +378,7 @@ dependencies = [
 
 [[package]]
 name = "bashkit-cli"
-version = "0.1.16"
+version = "0.1.17"
 dependencies = [
  "anyhow",
  "bashkit",
@@ -391,7 +391,7 @@ dependencies = [
 
 [[package]]
 name = "bashkit-eval"
-version = "0.1.16"
+version = "0.1.17"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -407,7 +407,7 @@ dependencies = [
 
 [[package]]
 name = "bashkit-js"
-version = "0.1.16"
+version = "0.1.17"
 dependencies = [
  "bashkit",
  "napi",
@@ -420,7 +420,7 @@ dependencies = [
 
 [[package]]
 name = "bashkit-python"
-version = "0.1.16"
+version = "0.1.17"
 dependencies = [
  "bashkit",
  "num-bigint",

{bashkit-0.1.16 → bashkit-0.1.17}/Cargo.toml

@@ -7,7 +7,7 @@ resolver = "2"
 members = ["crates/*"]
 
 [workspace.package]
-version = "0.1.16"
+version = "0.1.17"
 edition = "2024"
 license = "MIT"
 authors = ["Everruns"]

{bashkit-0.1.16 → bashkit-0.1.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bashkit
-Version: 0.1.16
+Version: 0.1.17
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{bashkit-0.1.16 → bashkit-0.1.17}/crates/bashkit/src/builtins/archive.rs

@@ -165,7 +165,15 @@ impl Builtin for Tar {
                     2,
                 ));
             }
-            create_tar(&ctx, &archive_name, &files, verbose, gzip).await
+            create_tar(
+                &ctx,
+                &archive_name,
+                &files,
+                verbose,
+                gzip,
+                change_dir.as_deref(),
+            )
+            .await
         } else if extract {
             extract_tar(
                 &ctx,
@@ -192,12 +200,19 @@ async fn create_tar(
     files: &[String],
     verbose: bool,
     gzip: bool,
+    change_dir: Option<&str>,
 ) -> Result<ExecResult> {
     let mut output_data: Vec<u8> = Vec::new();
     let mut verbose_output = String::new();
 
+    let base_dir = if let Some(dir) = change_dir {
+        resolve_path(ctx.cwd, dir)
+    } else {
+        ctx.cwd.clone()
+    };
+
     for file in files {
-        let path = resolve_path(ctx.cwd, file);
+        let path = resolve_path(&base_dir, file);
 
         if !ctx.fs.exists(&path).await.unwrap_or(false) {
             return Ok(ExecResult::err(

{bashkit-0.1.16 → bashkit-0.1.17}/crates/bashkit/src/builtins/date.rs

@@ -6,6 +6,7 @@
 //! caught and return graceful errors.
 
 use std::fmt::Write;
+use std::path::Path;
 
 use async_trait::async_trait;
 use chrono::format::{Item, StrftimeItems};
@@ -17,13 +18,14 @@ use crate::interpreter::ExecResult;
 
 /// The date builtin - display or set date and time.
 ///
-/// Usage: date [+FORMAT] [-u] [-R] [-I[TIMESPEC]]
+/// Usage: date [+FORMAT] [-u] [-R] [-I[TIMESPEC]] [-r FILE]
 ///
 /// Options:
 ///   +FORMAT  Output date according to FORMAT
 ///   -u       Display UTC time instead of local time
 ///   -R       Output RFC 2822 formatted date
 ///   -I[FMT]  Output ISO 8601 formatted date (FMT: date, hours, minutes, seconds)
+///   -r FILE  Display the last modification time of FILE
 ///
 /// FORMAT specifiers:
 ///   %Y  Year with century (e.g., 2024)
@@ -327,6 +329,7 @@ impl Builtin for Date {
         let mut utc = false;
         let mut format_arg: Option<String> = None;
         let mut date_str: Option<String> = None;
+        let mut ref_file: Option<String> = None;
         let mut rfc2822 = false;
         let mut iso8601: Option<String> = None;
 
@@ -343,6 +346,15 @@ impl Builtin for Date {
                 if let Some(val) = p.positional() {
                     date_str = Some(val.to_string());
                 }
+            } else if let Some(val) = p.current().and_then(|s| s.strip_prefix("--reference=")) {
+                ref_file = Some(val.to_string());
+                p.advance();
+            } else if let Some(val) = p.flag_value_opt("-r") {
+                ref_file = Some(val.to_string());
+            } else if p.flag("--reference") {
+                if let Some(val) = p.positional() {
+                    ref_file = Some(val.to_string());
+                }
             } else if p.flag_any(&["-R", "--rfc-2822", "--rfc-email"]) {
                 rfc2822 = true;
             } else if let Some(val) = p.current().and_then(|s| s.strip_prefix("--iso-8601=")) {
@@ -364,14 +376,34 @@ impl Builtin for Date {
         // Get the datetime to format
         // THREAT[TM-INF-018]: Use virtual time if configured
         let now = self.now();
-        let epoch_input = date_str.as_deref().is_some_and(uses_epoch_input);
-        let dt_utc = if let Some(ref ds) = date_str {
-            match parse_date_string(ds, now) {
+
+        // Resolve the datetime: -r (file mtime) > -d (date string) > now
+        let epoch_input;
+        let dt_utc;
+        if let Some(ref file) = ref_file {
+            // -r / --reference: stat file to get modification time
+            let path = Path::new(file);
+            match ctx.fs.stat(path).await {
+                Ok(meta) => {
+                    dt_utc = meta.modified.into();
+                    epoch_input = false;
+                }
+                Err(_) => {
+                    return Ok(ExecResult::err(
+                        format!("date: cannot stat '{}': No such file or directory\n", file),
+                        1,
+                    ));
+                }
+            }
+        } else if let Some(ref ds) = date_str {
+            epoch_input = uses_epoch_input(ds);
+            dt_utc = match parse_date_string(ds, now) {
                 Ok(dt) => dt,
                 Err(e) => return Ok(ExecResult::err(format!("{}\n", e), 1)),
-            }
+            };
         } else {
-            now
+            epoch_input = false;
+            dt_utc = now;
         };
 
         // Handle -R (RFC 2822) output
@@ -857,4 +889,109 @@ mod tests {
         // We only expand single %N, not %%N
         assert_eq!(expand_nanoseconds("%%N", 123), "%%N");
     }
+
+    // Helper to run date with a pre-configured filesystem
+    async fn run_date_with_fs(args: &[&str], fs: Arc<InMemoryFs>) -> ExecResult {
+        let mut variables = HashMap::new();
+        let env = HashMap::new();
+        let mut cwd = PathBuf::from("/");
+
+        let args: Vec<String> = args.iter().map(|s| s.to_string()).collect();
+        let ctx = Context {
+            args: &args,
+            env: &env,
+            variables: &mut variables,
+            cwd: &mut cwd,
+            fs,
+            stdin: None,
+            #[cfg(feature = "http_client")]
+            http_client: None,
+            #[cfg(feature = "git")]
+            git_client: None,
+            #[cfg(feature = "ssh")]
+            ssh_client: None,
+            shell: None,
+        };
+
+        Date::new().execute(ctx).await.unwrap()
+    }
+
+    // === -r / --reference (file mtime) tests ===
+
+    #[tokio::test]
+    async fn test_date_r_file_mtime() {
+        use crate::fs::FileSystem;
+
+        let fs = Arc::new(InMemoryFs::new());
+        fs.mkdir(std::path::Path::new("/tmp"), true).await.unwrap();
+        fs.write_file(std::path::Path::new("/tmp/test.txt"), b"hello")
+            .await
+            .unwrap();
+
+        // -r should return the file's mtime, not an error
+        let result = run_date_with_fs(&["-r", "/tmp/test.txt", "+%Y-%m-%d"], fs).await;
+        assert_eq!(result.exit_code, 0);
+        let date = result.stdout.trim();
+        // Should be a valid date (YYYY-MM-DD)
+        assert_eq!(date.len(), 10);
+        assert!(date.contains('-'));
+    }
+
+    #[tokio::test]
+    async fn test_date_r_file_not_found() {
+        let fs = Arc::new(InMemoryFs::new());
+        let result = run_date_with_fs(&["-r", "/nonexistent.txt"], fs).await;
+        assert_eq!(result.exit_code, 1);
+        assert!(result.stderr.contains("cannot stat"));
+        assert!(result.stderr.contains("/nonexistent.txt"));
+    }
+
+    #[tokio::test]
+    async fn test_date_r_with_format() {
+        use crate::fs::FileSystem;
+
+        let fs = Arc::new(InMemoryFs::new());
+        fs.mkdir(std::path::Path::new("/tmp"), true).await.unwrap();
+        fs.write_file(std::path::Path::new("/tmp/test.txt"), b"content")
+            .await
+            .unwrap();
+
+        let result = run_date_with_fs(&["-r", "/tmp/test.txt", "+%B"], fs).await;
+        assert_eq!(result.exit_code, 0);
+        // Should be a month name, non-empty
+        let month = result.stdout.trim();
+        assert!(!month.is_empty());
+    }
+
+    #[tokio::test]
+    async fn test_date_reference_long_flag() {
+        use crate::fs::FileSystem;
+
+        let fs = Arc::new(InMemoryFs::new());
+        fs.mkdir(std::path::Path::new("/tmp"), true).await.unwrap();
+        fs.write_file(std::path::Path::new("/tmp/test.txt"), b"content")
+            .await
+            .unwrap();
+
+        let result = run_date_with_fs(&["--reference=/tmp/test.txt", "+%Y"], fs).await;
+        assert_eq!(result.exit_code, 0);
+        let year = result.stdout.trim();
+        assert_eq!(year.len(), 4);
+    }
+
+    #[tokio::test]
+    async fn test_date_r_with_utc() {
+        use crate::fs::FileSystem;
+
+        let fs = Arc::new(InMemoryFs::new());
+        fs.mkdir(std::path::Path::new("/tmp"), true).await.unwrap();
+        fs.write_file(std::path::Path::new("/tmp/test.txt"), b"content")
+            .await
+            .unwrap();
+
+        let result = run_date_with_fs(&["-u", "-r", "/tmp/test.txt", "+%Z"], fs).await;
+        assert_eq!(result.exit_code, 0);
+        let tz = result.stdout.trim();
+        assert!(tz.contains("UTC") || tz == "+0000" || tz == "+00:00");
+    }
 }

{bashkit-0.1.16 → bashkit-0.1.17}/crates/bashkit/src/builtins/iconv.rs

@@ -17,6 +17,17 @@ use crate::interpreter::ExecResult;
 /// iconv builtin - character encoding conversion.
 pub struct Iconv;
 
+/// Parse an encoding spec like "ascii//translit" into (encoding, translit).
+fn parse_encoding_spec(spec: &str) -> (Option<&'static str>, bool) {
+    let (name, translit) = if let Some(pos) = spec.find("//") {
+        let suffix = &spec[pos + 2..];
+        (&spec[..pos], suffix.eq_ignore_ascii_case("translit"))
+    } else {
+        (spec, false)
+    };
+    (normalize_encoding(name), translit)
+}
+
 /// Normalize encoding name to canonical form.
 fn normalize_encoding(name: &str) -> Option<&'static str> {
     match name.to_ascii_lowercase().replace('-', "").as_str() {
@@ -29,6 +40,54 @@ fn normalize_encoding(name: &str) -> Option<&'static str> {
     }
 }
 
+/// Transliterate non-ASCII characters to their closest ASCII equivalents.
+fn transliterate_to_ascii(input: &str) -> String {
+    let mut result = String::with_capacity(input.len());
+    for ch in input.chars() {
+        if ch.is_ascii() {
+            result.push(ch);
+        } else {
+            result.push(match ch {
+                'á' | 'à' | 'â' | 'ã' | 'ä' | 'å' | 'ā' | 'ă' | 'ą' => 'a',
+                'é' | 'è' | 'ê' | 'ë' | 'ē' | 'ĕ' | 'ė' | 'ę' | 'ě' => 'e',
+                'í' | 'ì' | 'î' | 'ï' | 'ĩ' | 'ī' | 'ĭ' | 'į' => 'i',
+                'ó' | 'ò' | 'ô' | 'õ' | 'ö' | 'ø' | 'ō' | 'ŏ' | 'ő' => 'o',
+                'ú' | 'ù' | 'û' | 'ü' | 'ũ' | 'ū' | 'ŭ' | 'ů' | 'ű' | 'ų' => 'u',
+                'ý' | 'ÿ' | 'ŷ' => 'y',
+                'ñ' | 'ń' | 'ņ' | 'ň' => 'n',
+                'ç' | 'ć' | 'č' | 'ĉ' | 'ċ' => 'c',
+                'ß' => 's',
+                'æ' => 'a',
+                'œ' => 'o',
+                'ð' => 'd',
+                'þ' => 't',
+                'ł' => 'l',
+                'đ' => 'd',
+                'ğ' => 'g',
+                'ş' | 'š' | 'ś' | 'ŝ' => 's',
+                'ž' | 'ź' | 'ż' => 'z',
+                'ř' => 'r',
+                'ť' | 'ţ' => 't',
+                'Á' | 'À' | 'Â' | 'Ã' | 'Ä' | 'Å' => 'A',
+                'É' | 'È' | 'Ê' | 'Ë' => 'E',
+                'Í' | 'Ì' | 'Î' | 'Ï' => 'I',
+                'Ó' | 'Ò' | 'Ô' | 'Õ' | 'Ö' | 'Ø' => 'O',
+                'Ú' | 'Ù' | 'Û' | 'Ü' => 'U',
+                'Ý' => 'Y',
+                'Ñ' => 'N',
+                'Ç' => 'C',
+                'Š' => 'S',
+                'Ž' => 'Z',
+                'Ř' => 'R',
+                'Ť' => 'T',
+                'Ď' => 'D',
+                _ => '?',
+            });
+        }
+    }
+    result
+}
+
 const SUPPORTED_ENCODINGS: &[&str] = &[
     "ASCII",
     "ISO-8859-1",
@@ -39,22 +98,33 @@ const SUPPORTED_ENCODINGS: &[&str] = &[
 ];
 
 /// Encode bytes from UTF-8 string into target encoding.
-fn encode_to(input: &str, encoding: &str) -> std::result::Result<Vec<u8>, String> {
+/// When `transliterate` is true, non-ASCII characters are replaced with
+/// ASCII equivalents before encoding (supports `//translit` mode).
+fn encode_to(
+    input: &str,
+    encoding: &str,
+    transliterate: bool,
+) -> std::result::Result<Vec<u8>, String> {
+    let text = if transliterate {
+        transliterate_to_ascii(input)
+    } else {
+        input.to_string()
+    };
     match encoding {
-        "utf-8" => Ok(input.as_bytes().to_vec()),
+        "utf-8" => Ok(text.as_bytes().to_vec()),
         "ascii" => {
-            for (i, b) in input.bytes().enumerate() {
+            for (i, b) in text.bytes().enumerate() {
                 if b > 127 {
                     return Err(format!(
                         "iconv: cannot convert character at byte {i} to ASCII\n"
                     ));
                 }
             }
-            Ok(input.as_bytes().to_vec())
+            Ok(text.as_bytes().to_vec())
         }
         "latin1" => {
-            let mut out = Vec::with_capacity(input.len());
-            for ch in input.chars() {
+            let mut out = Vec::with_capacity(text.len());
+            for ch in text.chars() {
                 let cp = ch as u32;
                 if cp > 255 {
                     return Err(format!("iconv: cannot convert U+{cp:04X} to LATIN1\n"));
@@ -67,7 +137,7 @@ fn encode_to(input: &str, encoding: &str) -> std::result::Result<Vec<u8>, String
             let mut out = Vec::new();
             // BOM little-endian
             out.extend_from_slice(&[0xFF, 0xFE]);
-            for ch in input.chars() {
+            for ch in text.chars() {
                 let mut buf = [0u16; 2];
                 let encoded = ch.encode_utf16(&mut buf);
                 for u in encoded {
@@ -78,7 +148,7 @@ fn encode_to(input: &str, encoding: &str) -> std::result::Result<Vec<u8>, String
         }
         "utf-16be" => {
             let mut out = Vec::new();
-            for ch in input.chars() {
+            for ch in text.chars() {
                 let mut buf = [0u16; 2];
                 let encoded = ch.encode_utf16(&mut buf);
                 for u in encoded {
@@ -227,10 +297,10 @@ impl Builtin for Iconv {
             }
         };
 
-        let to = match &to_enc {
-            Some(t) => match normalize_encoding(t) {
-                Some(e) => e,
-                None => {
+        let (to, to_translit) = match &to_enc {
+            Some(t) => match parse_encoding_spec(t) {
+                (Some(e), translit) => (e, translit),
+                (None, _) => {
                     return Ok(ExecResult::err(
                         format!("iconv: unsupported encoding '{}'\n", t),
                         1,
@@ -268,7 +338,7 @@ impl Builtin for Iconv {
         };
 
         // Encode from UTF-8 string to target encoding
-        let output_bytes = match encode_to(&text, to) {
+        let output_bytes = match encode_to(&text, to, to_translit) {
             Ok(b) => b,
             Err(e) => return Ok(ExecResult::err(e, 1)),
         };
@@ -415,4 +485,40 @@ mod tests {
         assert_eq!(r.exit_code, 0);
         assert_eq!(r.stdout, "hello world\n");
     }
+
+    #[tokio::test]
+    async fn test_translit_to_ascii() {
+        let r = run(
+            &["-f", "UTF-8", "-t", "ascii//translit"],
+            Some("caf\u{00e9}"),
+            None,
+        )
+        .await;
+        assert_eq!(r.exit_code, 0);
+        assert_eq!(r.stdout, "cafe");
+    }
+
+    #[tokio::test]
+    async fn test_translit_multiple_diacritics() {
+        let r = run(
+            &["-f", "UTF-8", "-t", "ASCII//TRANSLIT"],
+            Some("na\u{00ef}ve"),
+            None,
+        )
+        .await;
+        assert_eq!(r.exit_code, 0);
+        assert_eq!(r.stdout, "naive");
+    }
+
+    #[tokio::test]
+    async fn test_translit_german() {
+        let r = run(
+            &["-f", "utf-8", "-t", "ascii//translit"],
+            Some("H\u{00e9}llo W\u{00f6}rld"),
+            None,
+        )
+        .await;
+        assert_eq!(r.exit_code, 0);
+        assert_eq!(r.stdout, "Hello World");
+    }
 }