Implement TarOperation and TarParam foundations

Cargo.toml

@@ -63,7 +63,6 @@ uutests = { workspace = true }
 uucore = { workspace = true }
 uuhelp_parser = { workspace = true, optional = true }
 zip = { workspace = true, optional = true }
-
 tar = { optional = true, version = "0.0.1", package = "uu_tar", path = "src/uu/tar" }
 
 [dev-dependencies]

src/uu/tar/Cargo.toml

@@ -17,6 +17,7 @@ uucore = { workspace = true }
 clap = { workspace = true }
 regex = { workspace = true }
 tar = { workspace = true }
+jiff = "0.2.16"
 
 [lib]
 path = "src/tar.rs"

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

@@ -4,11 +4,29 @@
 // file that was distributed with this source code.
 
 use crate::errors::TarError;
+use crate::operations::TarOperation;
+use crate::options::{TarOption, TarParams};
 use std::fs::File;
 use std::path::Path;
+use std::path::PathBuf;
 use tar::Builder;
 use uucore::error::UResult;
 
+pub struct Create;
+
+impl TarOperation for Create {
+    fn exec(&self, options: &TarParams) -> UResult<()> {
+        create_archive(
+            options.archive(),
+            options.files().as_slice(),
+            options
+                .options()
+                .iter()
+                .any(|x| matches!(x, TarOption::Verbose)),
+        )
+    }
+}
+
 /// Create a tar archive from the specified files
 ///
 /// # Arguments
@@ -23,7 +41,7 @@ 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<()> {
+pub fn create_archive(archive_path: &Path, files: &[PathBuf], verbose: bool) -> UResult<()> {
     // Create the output file
     let file = File::create(archive_path).map_err(|e| {
         TarError::TarOperationError(format!(
@@ -41,7 +59,7 @@ pub fn create_archive(archive_path: &Path, files: &[&Path], verbose: bool) -> UR
     }
 
     // Add each file or directory to the archive
-    for &path in files {
+    for path in files {
         if verbose {
             println!("{}", path.display());
         }

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

@@ -4,11 +4,27 @@
 // file that was distributed with this source code.
 
 use crate::errors::TarError;
+use crate::operations::operation::TarOperation;
+use crate::options::options::{TarOption, TarParams};
 use std::fs::File;
 use std::path::Path;
 use tar::Archive;
 use uucore::error::UResult;
 
+pub(crate) struct Extract;
+
+impl TarOperation for Extract {
+    fn exec(&self, options: &TarParams) -> UResult<()> {
+        extract_archive(
+            options.archive(),
+            options
+                .options()
+                .iter()
+                .any(|x| matches!(x, TarOption::Verbose)),
+        )
+    }
+}
+
 /// Extract files from a tar archive
 ///
 /// # Arguments

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

@@ -5,3 +5,9 @@
 
 pub mod create;
 pub mod extract;
+pub mod operation;
+
+pub(crate) use self::create::Create;
+pub(crate) use self::extract::Extract;
+pub(crate) use self::operation::OperationKind;
+pub use self::operation::TarOperation;

src/uu/tar/src/operations/operation.rs

@@ -0,0 +1,58 @@
+use crate::errors::TarError;
+use crate::operations::Create;
+use crate::operations::Extract;
+use crate::options::TarParams;
+use uucore::error::UResult;
+
+/// The [`OperationKind`] Enum representation of Acdtrux arguments which is
+/// later leveraged as selector for enum dispatch by the [`TarOperation`]
+/// trait
+pub enum OperationKind {
+    Concatenate,
+    Create,
+    Diff,
+    List,
+    Append,
+    Update,
+    Extract,
+}
+
+impl TryFrom<&str> for OperationKind {
+    type Error = TarError;
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+            "concate" => Ok(Self::Concatenate),
+            "create" => Ok(Self::Create),
+            "diff" => Ok(Self::Diff),
+            "list" => Ok(Self::List),
+            "append" => Ok(Self::Append),
+            "update" => Ok(Self::Update),
+            "extract" => Ok(Self::Extract),
+            _ => Err(TarError::TarOperationError(format!(
+                "Invalid operation selected: {}",
+                value
+            ))),
+        }
+    }
+}
+
+impl TarOperation for OperationKind {
+    fn exec(&self, options: &TarParams) -> UResult<()> {
+        match self {
+            Self::List => unimplemented!(),
+            Self::Create => Create.exec(options),
+            Self::Diff => unimplemented!(),
+            Self::Append => unimplemented!(),
+            Self::Update => unimplemented!(),
+            Self::Extract => Extract.exec(options),
+            Self::Concatenate => unimplemented!(),
+        }
+    }
+}
+
+/// [`TarOperation`] allows enum dispatch by enforcing the impl of the
+/// trait to create the functionality to perform the operation requested via
+/// the command line arg for this execution of tar
+pub trait TarOperation {
+    fn exec(&self, options: &TarParams) -> UResult<()>;
+}

src/uu/tar/src/options/mod.rs

@@ -0,0 +1,6 @@
+// re-exported to remove the redundant level of inception in
+// the module tree
+#[allow(clippy::module_inception)]
+pub mod options;
+pub use crate::options::options::TarOption;
+pub use crate::options::options::TarParams;