tar: add explicit zstd compression support

Add an explicit --zstd flag for create, list, and extract so
.tar.zst archives work end to end.

Keep the scope narrow by requiring the flag instead of trying to
autodetect compression. Add CLI coverage and end-to-end tests for
creating, listing, and extracting zstd-compressed archives.

Author: kevinburke

Cargo.lock

@@ -50,6 +50,7 @@ tempfile = "3.10.1"
 textwrap = { version = "0.16.1", features = ["terminal_size"] }
 xattr = "1.3.1"
 zip = "8.0"
+zstd = "0.13.3"
 
 [dependencies]
 clap = { workspace = true }
@@ -74,6 +75,7 @@ tar-rs-crate = { version = "0.4", package = "tar" }
 tempfile = { workspace = true }
 uucore = { workspace = true, features = ["entries", "process", "signals"] }
 uutests = { workspace = true }
+zstd = { workspace = true }
 
 [target.'cfg(unix)'.dev-dependencies]
 xattr = { workspace = true }

Cargo.toml

@@ -18,6 +18,7 @@ clap = { workspace = true }
 regex = { workspace = true }
 tar = { workspace = true }
 chrono = { workspace = true }
+zstd = { workspace = true }
 
 [lib]
 path = "src/tar.rs"

src/uu/tar/Cargo.toml

@@ -0,0 +1,93 @@
+// This file is part of the uutils tar package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+use crate::errors::TarError;
+use crate::CompressionMode;
+use std::fs::File;
+use std::io::{Read, Write};
+use std::path::Path;
+
+pub fn open_archive_reader(
+    archive_path: &Path,
+    compression: CompressionMode,
+) -> Result<Box<dyn Read>, TarError> {
+    let file = File::open(archive_path).map_err(|e| TarError::from_io_error(e, archive_path))?;
+
+    match compression {
+        CompressionMode::None => Ok(Box::new(file)),
+        CompressionMode::Zstd => {
+            let decoder = zstd::stream::read::Decoder::new(file).map_err(|e| {
+                TarError::InvalidArchive(format!(
+                    "Failed to initialize zstd decoder for '{}': {}",
+                    archive_path.display(),
+                    e
+                ))
+            })?;
+            Ok(Box::new(decoder))
+        }
+    }
+}
+
+pub struct ArchiveWriter {
+    inner: ArchiveWriterInner,
+}
+
+enum ArchiveWriterInner {
+    Plain(File),
+    Zstd(zstd::stream::write::Encoder<'static, File>),
+}
+
+impl ArchiveWriter {
+    pub fn create(archive_path: &Path, compression: CompressionMode) -> Result<Self, TarError> {
+        let file = File::create(archive_path).map_err(|e| {
+            TarError::TarOperationError(format!(
+                "Cannot create archive '{}': {}",
+                archive_path.display(),
+                e
+            ))
+        })?;
+
+        let inner = match compression {
+            CompressionMode::None => ArchiveWriterInner::Plain(file),
+            CompressionMode::Zstd => {
+                let encoder = zstd::stream::write::Encoder::new(file, 0).map_err(|e| {
+                    TarError::TarOperationError(format!(
+                        "Failed to initialize zstd encoder for '{}': {}",
+                        archive_path.display(),
+                        e
+                    ))
+                })?;
+                ArchiveWriterInner::Zstd(encoder)
+            }
+        };
+
+        Ok(Self { inner })
+    }
+
+    pub fn finish(self) -> Result<(), TarError> {
+        match self.inner {
+            ArchiveWriterInner::Plain(mut file) => file.flush().map_err(TarError::from),
+            ArchiveWriterInner::Zstd(encoder) => encoder.finish().map(|_| ()).map_err(|e| {
+                TarError::TarOperationError(format!("Failed to finalize zstd archive: {e}"))
+            }),
+        }
+    }
+}
+
+impl Write for ArchiveWriter {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        match &mut self.inner {
+            ArchiveWriterInner::Plain(file) => file.write(buf),
+            ArchiveWriterInner::Zstd(encoder) => encoder.write(buf),
+        }
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        match &mut self.inner {
+            ArchiveWriterInner::Plain(file) => file.flush(),
+            ArchiveWriterInner::Zstd(encoder) => encoder.flush(),
+        }
+    }
+}

src/uu/tar/src/operations/compression.rs

@@ -4,8 +4,10 @@
 // file that was distributed with this source code.
 
 use crate::errors::TarError;
+use crate::operations::compression::ArchiveWriter;
+use crate::CompressionMode;
 use std::collections::VecDeque;
-use std::fs::{self, File};
+use std::fs;
 use std::path::Component::{self, ParentDir, Prefix, RootDir};
 use std::path::{self, Path, PathBuf};
 use tar::Builder;
@@ -25,18 +27,14 @@ use uucore::error::UResult;
 /// - The archive file cannot be created
 /// - Any input file cannot be read
 /// - Files cannot be added due to I/O or permission errors
-pub fn create_archive(archive_path: &Path, files: &[&Path], verbose: bool) -> UResult<()> {
-    // Create the output file
-    let file = File::create(archive_path).map_err(|e| {
-        TarError::TarOperationError(format!(
-            "Cannot create archive '{}': {}",
-            archive_path.display(),
-            e
-        ))
-    })?;
-
-    // Create Builder instance
-    let mut builder = Builder::new(file);
+pub fn create_archive(
+    archive_path: &Path,
+    files: &[&Path],
+    verbose: bool,
+    compression: CompressionMode,
+) -> UResult<()> {
+    let writer = ArchiveWriter::create(archive_path, compression)?;
+    let mut builder = Builder::new(writer);
 
     // Add each file or directory to the archive
     for &path in files {
@@ -102,9 +100,10 @@ pub fn create_archive(archive_path: &Path, files: &[&Path], verbose: bool) -> UR
     }
 
     // Finish writing the archive
-    builder
-        .finish()
+    let writer = builder
+        .into_inner()
         .map_err(|e| TarError::TarOperationError(format!("Failed to finalize archive: {e}")))?;
+    writer.finish()?;
 
     Ok(())
 }

src/uu/tar/src/operations/create.rs

@@ -4,7 +4,8 @@
 // file that was distributed with this source code.
 
 use crate::errors::TarError;
-use std::fs::File;
+use crate::operations::compression::open_archive_reader;
+use crate::CompressionMode;
 use std::path::Path;
 use tar::Archive;
 use uucore::error::UResult;
@@ -22,12 +23,13 @@ use uucore::error::UResult;
 /// - The archive file cannot be opened
 /// - The archive format is invalid
 /// - Files cannot be extracted due to I/O or permission errors
-pub fn extract_archive(archive_path: &Path, verbose: bool) -> UResult<()> {
-    // Open the archive file
-    let file = File::open(archive_path).map_err(|e| TarError::from_io_error(e, archive_path))?;
-
-    // Create Archive instance
-    let mut archive = Archive::new(file);
+pub fn extract_archive(
+    archive_path: &Path,
+    verbose: bool,
+    compression: CompressionMode,
+) -> UResult<()> {
+    let reader = open_archive_reader(archive_path, compression)?;
+    let mut archive = Archive::new(reader);
 
     // Extract to current directory
     if verbose {

src/uu/tar/src/operations/extract.rs

@@ -4,18 +4,22 @@
 // file that was distributed with this source code.
 
 use crate::errors::TarError;
+use crate::operations::compression::open_archive_reader;
+use crate::CompressionMode;
 use chrono::{TimeZone, Utc};
-use std::fs::File;
 use std::path::Path;
 use tar::Archive;
 use uucore::error::UResult;
 use uucore::fs::display_permissions_unix;
 
 /// List the contents of a tar archive, printing one entry per line.
-pub fn list_archive(archive_path: &Path, verbose: bool) -> UResult<()> {
-    let file: File =
-        File::open(archive_path).map_err(|e| TarError::from_io_error(e, archive_path))?;
-    let mut archive = Archive::new(file);
+pub fn list_archive(
+    archive_path: &Path,
+    verbose: bool,
+    compression: CompressionMode,
+) -> UResult<()> {
+    let reader = open_archive_reader(archive_path, compression)?;
+    let mut archive = Archive::new(reader);
 
     for entry_result in archive
         .entries()

src/uu/tar/src/operations/list.rs

@@ -3,6 +3,7 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+pub mod compression;
 pub mod create;
 pub mod extract;
 pub mod list;

src/uu/tar/src/operations/mod.rs

@@ -14,6 +14,12 @@ use uucore::format_usage;
 const ABOUT: &str = "an archiving utility";
 const USAGE: &str = "tar key [FILE...]\n       tar {-c|-t|-x} [-v] -f ARCHIVE [FILE...]";
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum CompressionMode {
+    None,
+    Zstd,
+}
+
 /// Determines whether a string looks like a POSIX tar keystring.
 ///
 /// A valid keystring must not start with '-', must contain at least one
@@ -131,14 +137,19 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     };
 
     let verbose = matches.get_flag("verbose");
+    let compression = if matches.get_flag("zstd") {
+        CompressionMode::Zstd
+    } else {
+        CompressionMode::None
+    };
 
     // Handle extract operation
     if matches.get_flag("extract") {
         let archive_path = matches.get_one::<PathBuf>("file").ok_or_else(|| {
             uucore::error::USimpleError::new(64, "option requires an argument -- 'f'")
         })?;
 
-        return operations::extract::extract_archive(archive_path, verbose);
+        return operations::extract::extract_archive(archive_path, verbose, compression);
     }
 
     // Handle create operation
@@ -159,7 +170,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             ));
         }
 
-        return operations::create::create_archive(archive_path, &files, verbose);
+        return operations::create::create_archive(archive_path, &files, verbose, compression);
     }
 
     // Handle list operation
@@ -168,7 +179,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             uucore::error::USimpleError::new(64, "option requires an argument -- 'f'")
         })?;
 
-        return operations::list::list_archive(archive_path, verbose);
+        return operations::list::list_archive(archive_path, verbose, compression);
     }
 
     // If no operation specified, show error
@@ -203,6 +214,7 @@ pub fn uu_app() -> Command {
             // arg!(-z --gzip "Filter through gzip"),
             // arg!(-j --bzip2 "Filter through bzip2"),
             // arg!(-J --xz "Filter through xz"),
+            arg!(--zstd "Filter through zstd"),
             // Common options
             arg!(-v --verbose "Verbosely list files processed"),
             // arg!(-h --dereference "Follow symlinks"),

src/uu/tar/src/tar.rs

@@ -32,3 +32,14 @@ fn test_verbose_flag_parsing() {
     assert!(matches.get_flag("verbose"));
     assert!(matches.get_flag("create"));
 }
+
+#[test]
+fn test_zstd_flag_parsing() {
+    let app = uu_app();
+    let result =
+        app.try_get_matches_from(vec!["tar", "--zstd", "-cf", "archive.tar.zst", "file.txt"]);
+    assert!(result.is_ok());
+    let matches = result.unwrap();
+    assert!(matches.get_flag("zstd"));
+    assert!(matches.get_flag("create"));
+}