From b0e2f957af86cbc034035225fbb4e971066583a1 Mon Sep 17 00:00:00 2001 From: Haruaki Tamada Date: Sun, 26 Jan 2025 14:22:02 +0900 Subject: [PATCH 1/3] refactor: streamline path handling by removing unnecessary references and simplifying method calls --- src/archiver.rs | 36 ++++++++++++++++------------------ src/archiver/cab.rs | 10 ++++------ src/archiver/os/linux.rs | 2 +- src/archiver/sevenz.rs | 14 ++++++-------- src/archiver/tar.rs | 22 ++++++++++----------- src/archiver/zip.rs | 12 +++++------- src/cli.rs | 2 +- src/extractor.rs | 42 +++++++++++++++++++--------------------- src/extractor/cab.rs | 6 +++--- src/extractor/lha.rs | 4 ++-- src/extractor/sevenz.rs | 6 +++--- src/extractor/tar.rs | 20 +++++++++---------- src/extractor/zip.rs | 4 ++-- src/format.rs | 21 +++++++------------- src/list.rs | 39 ++++++++++++++++++++++++++++++------- src/main.rs | 23 +++++++++++++--------- 16 files changed, 137 insertions(+), 126 deletions(-) diff --git a/src/archiver.rs b/src/archiver.rs index a90d801..666911e 100644 --- a/src/archiver.rs +++ b/src/archiver.rs @@ -83,13 +83,13 @@ impl<'a> TargetPath<'a> { /// Returns the directory traversing walker for the given path of this instance. pub fn walker(&self) -> Walk { - let mut builder = WalkBuilder::new(&self.base_path); + let mut builder = WalkBuilder::new(self.base_path); build_walker_impl(self.opts, &mut builder); builder.build() } } -impl<'a> Archiver { +impl Archiver { pub fn perform(&self) -> Result<()> { let archiver = match create_archiver(&self.archive_file) { Ok(a) => a, @@ -104,7 +104,7 @@ impl<'a> Archiver { let paths = self .targets .iter() - .map(|item| TargetPath::new(item, &self)) + .map(|item| TargetPath::new(item, self)) .collect::>(); log::info!("{:?}: {}", self.archive_file, self.archive_file.exists()); @@ -188,7 +188,7 @@ impl<'a> Archiver { r.insert(IgnoreType::GitGlobal); r.insert(IgnoreType::GitExclude); } else { - r.insert(it.clone()); + r.insert(it); } } r.into_iter().collect() @@ -225,21 +225,19 @@ fn create_archiver(dest: &PathBuf) -> Result> { let format = find_format(dest); match format { - Ok(format) => { - return match format { - Format::Cab => Ok(Box::new(CabArchiver {})), - Format::LHA => Ok(Box::new(LhaArchiver {})), - Format::Rar => Ok(Box::new(RarArchiver {})), - Format::SevenZ => Ok(Box::new(SevenZArchiver {})), - Format::Tar => Ok(Box::new(TarArchiver {})), - Format::TarBz2 => Ok(Box::new(TarBz2Archiver {})), - Format::TarGz => Ok(Box::new(TarGzArchiver {})), - Format::TarXz => Ok(Box::new(TarXzArchiver {})), - Format::TarZstd => Ok(Box::new(TarZstdArchiver {})), - Format::Zip => Ok(Box::new(ZipArchiver::new())), - _ => Err(ToteError::UnknownFormat(format.to_string())), - } - } + Ok(format) => match format { + Format::Cab => Ok(Box::new(CabArchiver {})), + Format::LHA => Ok(Box::new(LhaArchiver {})), + Format::Rar => Ok(Box::new(RarArchiver {})), + Format::SevenZ => Ok(Box::new(SevenZArchiver {})), + Format::Tar => Ok(Box::new(TarArchiver {})), + Format::TarBz2 => Ok(Box::new(TarBz2Archiver {})), + Format::TarGz => Ok(Box::new(TarGzArchiver {})), + Format::TarXz => Ok(Box::new(TarXzArchiver {})), + Format::TarZstd => Ok(Box::new(TarZstdArchiver {})), + Format::Zip => Ok(Box::new(ZipArchiver::new())), + _ => Err(ToteError::UnknownFormat(format.to_string())), + }, Err(msg) => Err(msg), } } diff --git a/src/archiver/cab.rs b/src/archiver/cab.rs index fbd0ae7..7ef49f7 100644 --- a/src/archiver/cab.rs +++ b/src/archiver/cab.rs @@ -61,12 +61,10 @@ fn write_entry(writer: &mut CabinetWriter, path: PathBuf) -> Result<()> { fn collect_entries<'a>(tps: &'a Vec) -> Vec<(PathBuf, &'a TargetPath<'a>)> { let mut r = vec![]; for tp in tps { - for entry in tp.walker() { - if let Ok(t) = entry { - let path = t.into_path(); - if path.is_file() { - r.push((path, tp)); - } + for t in tp.walker().flatten() { + let path = t.into_path(); + if path.is_file() { + r.push((path, tp)); } } } diff --git a/src/archiver/os/linux.rs b/src/archiver/os/linux.rs index 02799ec..bc23f77 100644 --- a/src/archiver/os/linux.rs +++ b/src/archiver/os/linux.rs @@ -6,7 +6,7 @@ use zip::write::SimpleFileOptions; use zip::DateTime; pub fn create_file_opts(target: &PathBuf) -> SimpleFileOptions { - let metadata = std::fs::metadata(&target).unwrap(); + let metadata = std::fs::metadata(target).unwrap(); let mod_time = DateTime::try_from(OffsetDateTime::from(metadata.modified().unwrap())); SimpleFileOptions::default() diff --git a/src/archiver/sevenz.rs b/src/archiver/sevenz.rs index ad587f1..dbc21a2 100644 --- a/src/archiver/sevenz.rs +++ b/src/archiver/sevenz.rs @@ -18,13 +18,11 @@ impl ToteArchiver for SevenZArchiver { }; let mut errs = vec![]; for tp in tps { - for entry in tp.walker() { - if let Ok(t) = entry { - let path = t.into_path(); - if path.is_file() { - if let Err(e) = process_file(&mut w, &path, &tp.dest_path(&path)) { - errs.push(e); - } + for t in tp.walker().flatten() { + let path = t.into_path(); + if path.is_file() { + if let Err(e) = process_file(&mut w, &path, &tp.dest_path(&path)) { + errs.push(e); } } } @@ -51,7 +49,7 @@ impl ToteArchiver for SevenZArchiver { fn process_file(szw: &mut SevenZWriter, target: &PathBuf, dest_path: &PathBuf) -> Result<()> { let name = &dest_path.to_str().unwrap(); if let Err(e) = szw.push_archive_entry( - SevenZArchiveEntry::from_path(&dest_path, name.to_string()), + SevenZArchiveEntry::from_path(dest_path, name.to_string()), Some(File::open(target).unwrap()), ) { return Err(ToteError::Archiver(e.to_string())); diff --git a/src/archiver/tar.rs b/src/archiver/tar.rs index 09d56f5..081fd45 100644 --- a/src/archiver/tar.rs +++ b/src/archiver/tar.rs @@ -83,18 +83,16 @@ fn write_tar(tps: Vec, f: W) -> Result<()> { let mut builder = tar::Builder::new(f); let mut errs = vec![]; for tp in tps { - for entry in tp.walker() { - if let Ok(t) = entry { - let path = t.into_path(); - let dest_dir = tp.dest_path(&path); - if path.is_file() { - if let Err(e) = process_file(&mut builder, &path, &dest_dir) { - errs.push(e); - } - } else if path.is_dir() { - if let Err(e) = builder.append_dir(&dest_dir, &path) { - errs.push(ToteError::Archiver(e.to_string())); - } + for t in tp.walker().flatten() { + let path = t.into_path(); + let dest_dir = tp.dest_path(&path); + if path.is_file() { + if let Err(e) = process_file(&mut builder, &path, &dest_dir) { + errs.push(e); + } + } else if path.is_dir() { + if let Err(e) = builder.append_dir(&dest_dir, &path) { + errs.push(ToteError::Archiver(e.to_string())); } } } diff --git a/src/archiver/zip.rs b/src/archiver/zip.rs index 5826d56..cd15b4d 100644 --- a/src/archiver/zip.rs +++ b/src/archiver/zip.rs @@ -44,13 +44,11 @@ impl ToteArchiver for ZipArchiver { let mut errs = vec![]; let mut zw = zip::ZipWriter::new(file); for tp in tps { - for entry in tp.walker() { - if let Ok(t) = entry { - let path = t.into_path(); - if path.is_file() { - if let Err(e) = self.process_file(&mut zw, path, &tp) { - errs.push(e); - } + for t in tp.walker().flatten() { + let path = t.into_path(); + if path.is_file() { + if let Err(e) = self.process_file(&mut zw, path, &tp) { + errs.push(e); } } } diff --git a/src/cli.rs b/src/cli.rs index 9de08f6..753a868 100644 --- a/src/cli.rs +++ b/src/cli.rs @@ -122,7 +122,7 @@ pub enum LogLevel { impl CliOpts { pub fn run_mode(&mut self) -> Result { - if self.args.len() == 0 { + if self.args.is_empty() { return Err(ToteError::NoArgumentsGiven); } if self.mode == RunMode::Auto { diff --git a/src/extractor.rs b/src/extractor.rs index 3d8fae3..e3c5482 100644 --- a/src/extractor.rs +++ b/src/extractor.rs @@ -31,7 +31,7 @@ */ use chrono::NaiveDateTime; use std::fmt::Display; -use std::path::PathBuf; +use std::path::{Path, PathBuf}; use typed_builder::TypedBuilder; use super::format::{find_format, Format}; @@ -82,7 +82,7 @@ pub struct PathUtils<'a> { e: &'a Extractor, } -impl<'a> PathUtils<'a> { +impl PathUtils<'_> { pub fn base_dir(&self) -> PathBuf { self.e.base_dir() } @@ -197,27 +197,25 @@ pub(crate) trait ToteExtractor { /// Returns the extractor for the given archive file. /// The supported format is `cab`, `lha`, `rar`, `7z`, `tar`, `tar.gz`, `tar.bz2`, `tar.xz`, `tar.zst`, and `zip`. -fn create(file: &PathBuf) -> Result> { - let format = find_format(&file); +fn create(file: &Path) -> Result> { + let format = find_format(file); match format { - Ok(format) => { - return match format { - Format::Cab => Ok(Box::new(cab::CabExtractor {})), - Format::LHA => Ok(Box::new(lha::LhaExtractor {})), - Format::Rar => Ok(Box::new(rar::RarExtractor {})), - Format::SevenZ => Ok(Box::new(sevenz::SevenZExtractor {})), - Format::Tar => Ok(Box::new(tar::TarExtractor {})), - Format::TarBz2 => Ok(Box::new(tar::TarBz2Extractor {})), - Format::TarGz => Ok(Box::new(tar::TarGzExtractor {})), - Format::TarXz => Ok(Box::new(tar::TarXzExtractor {})), - Format::TarZstd => Ok(Box::new(tar::TarZstdExtractor {})), - Format::Zip => Ok(Box::new(zip::ZipExtractor {})), - Format::Unknown(s) => Err(ToteError::UnknownFormat(format!( - "{}: unsupported format", - s - ))), - } - } + Ok(format) => match format { + Format::Cab => Ok(Box::new(cab::CabExtractor {})), + Format::LHA => Ok(Box::new(lha::LhaExtractor {})), + Format::Rar => Ok(Box::new(rar::RarExtractor {})), + Format::SevenZ => Ok(Box::new(sevenz::SevenZExtractor {})), + Format::Tar => Ok(Box::new(tar::TarExtractor {})), + Format::TarBz2 => Ok(Box::new(tar::TarBz2Extractor {})), + Format::TarGz => Ok(Box::new(tar::TarGzExtractor {})), + Format::TarXz => Ok(Box::new(tar::TarXzExtractor {})), + Format::TarZstd => Ok(Box::new(tar::TarZstdExtractor {})), + Format::Zip => Ok(Box::new(zip::ZipExtractor {})), + Format::Unknown(s) => Err(ToteError::UnknownFormat(format!( + "{}: unsupported format", + s + ))), + }, Err(msg) => Err(msg), } } diff --git a/src/extractor/cab.rs b/src/extractor/cab.rs index deebdea..ad2e49f 100644 --- a/src/extractor/cab.rs +++ b/src/extractor/cab.rs @@ -11,7 +11,7 @@ pub(super) struct CabExtractor {} impl ToteExtractor for CabExtractor { fn list(&self, target: &PathBuf) -> Result> { - list_impl(target, |file| convert(file)) + list_impl(target, convert) } fn perform(&self, target: &PathBuf, opts: PathUtils) -> Result<()> { @@ -83,7 +83,7 @@ fn list_impl(archive_file: &PathBuf, mapper: F) -> Result> where F: Fn(&cab::FileEntry) -> T, { - let cabinet = open_cabinet(&archive_file)?; + let cabinet = open_cabinet(archive_file)?; let mut result = vec![]; for folder in cabinet.folder_entries() { for file in folder.file_entries() { @@ -96,7 +96,7 @@ where fn convert(f: &FileEntry) -> Entry { let name = f.name().to_string(); let uncompressed_size = f.uncompressed_size(); - let mtime = f.datetime().map(|t| to_naive_datetime(t)); + let mtime = f.datetime().map(to_naive_datetime); Entry::new(name, None, Some(uncompressed_size as u64), None, mtime) } diff --git a/src/extractor/lha.rs b/src/extractor/lha.rs index 6153cb1..d143dea 100644 --- a/src/extractor/lha.rs +++ b/src/extractor/lha.rs @@ -14,7 +14,7 @@ pub(super) struct LhaExtractor {} impl ToteExtractor for LhaExtractor { fn list(&self, archive_file: &PathBuf) -> Result> { let mut result = vec![]; - let mut reader = match delharc::parse_file(&archive_file) { + let mut reader = match delharc::parse_file(archive_file) { Err(e) => return Err(ToteError::IO(e)), Ok(h) => h, }; @@ -36,7 +36,7 @@ impl ToteExtractor for LhaExtractor { } fn perform(&self, archive_file: &PathBuf, opts: PathUtils) -> Result<()> { - let mut reader = match delharc::parse_file(&archive_file) { + let mut reader = match delharc::parse_file(archive_file) { Err(e) => return Err(ToteError::IO(e)), Ok(h) => h, }; diff --git a/src/extractor/sevenz.rs b/src/extractor/sevenz.rs index 9f56384..8fe5ac6 100644 --- a/src/extractor/sevenz.rs +++ b/src/extractor/sevenz.rs @@ -11,7 +11,7 @@ pub(super) struct SevenZExtractor {} impl ToteExtractor for SevenZExtractor { fn list(&self, archive_file: &PathBuf) -> Result> { - let mut reader = File::open(&archive_file).unwrap(); + let mut reader = File::open(archive_file).unwrap(); let len = reader.metadata().unwrap().len(); match Archive::read(&mut reader, len, Password::empty().as_ref()) { Ok(archive) => { @@ -26,11 +26,11 @@ impl ToteExtractor for SevenZExtractor { } fn perform(&self, archive_file: &PathBuf, opts: PathUtils) -> Result<()> { - let mut file = match File::open(&archive_file) { + let file = match File::open(archive_file) { Ok(file) => file, Err(e) => return Err(ToteError::IO(e)), }; - extract(&mut file, opts) + extract(&file, opts) } #[cfg(test)] diff --git a/src/extractor/tar.rs b/src/extractor/tar.rs index 2a97c2c..f176a60 100644 --- a/src/extractor/tar.rs +++ b/src/extractor/tar.rs @@ -22,13 +22,13 @@ pub(super) struct TarZstdExtractor {} impl ToteExtractor for TarExtractor { fn list(&self, archive_file: &PathBuf) -> Result> { - match open_tar_file(&archive_file, |f| f) { + match open_tar_file(archive_file, |f| f) { Ok(archive) => list_tar(archive), Err(e) => Err(e), } } fn perform(&self, archive_file: &PathBuf, opts: PathUtils) -> Result<()> { - match open_tar_file(&archive_file, |f| f) { + match open_tar_file(archive_file, |f| f) { Err(e) => Err(e), Ok(archive) => extract_tar(archive, opts), } @@ -41,13 +41,13 @@ impl ToteExtractor for TarExtractor { impl ToteExtractor for TarGzExtractor { fn list(&self, archive_file: &PathBuf) -> Result> { - match open_tar_file(&archive_file, |f| flate2::read::GzDecoder::new(f)) { + match open_tar_file(archive_file, flate2::read::GzDecoder::new) { Ok(archive) => list_tar(archive), Err(e) => Err(e), } } fn perform(&self, archive_file: &PathBuf, opts: PathUtils) -> Result<()> { - match open_tar_file(&archive_file, |f| flate2::read::GzDecoder::new(f)) { + match open_tar_file(archive_file, flate2::read::GzDecoder::new) { Ok(archive) => extract_tar(archive, opts), Err(e) => Err(e), } @@ -60,13 +60,13 @@ impl ToteExtractor for TarGzExtractor { impl ToteExtractor for TarBz2Extractor { fn list(&self, archive_file: &PathBuf) -> Result> { - match open_tar_file(&archive_file, |f| bzip2::read::BzDecoder::new(f)) { + match open_tar_file(archive_file, bzip2::read::BzDecoder::new) { Ok(archive) => list_tar(archive), Err(e) => Err(e), } } fn perform(&self, archive_file: &PathBuf, opts: PathUtils) -> Result<()> { - match open_tar_file(&archive_file, |f| bzip2::read::BzDecoder::new(f)) { + match open_tar_file(archive_file, bzip2::read::BzDecoder::new) { Err(e) => Err(e), Ok(archive) => extract_tar(archive, opts), } @@ -79,13 +79,13 @@ impl ToteExtractor for TarBz2Extractor { impl ToteExtractor for TarXzExtractor { fn list(&self, archive_file: &PathBuf) -> Result> { - match open_tar_file(&archive_file, |f| XzDecoder::new(f)) { + match open_tar_file(archive_file, XzDecoder::new) { Err(e) => Err(e), Ok(archive) => list_tar(archive), } } fn perform(&self, archive_file: &PathBuf, opts: PathUtils) -> Result<()> { - match open_tar_file(&archive_file, |f| XzDecoder::new(f)) { + match open_tar_file(archive_file, XzDecoder::new) { Err(e) => Err(e), Ok(archive) => extract_tar(archive, opts), } @@ -98,13 +98,13 @@ impl ToteExtractor for TarXzExtractor { impl ToteExtractor for TarZstdExtractor { fn list(&self, archive_file: &PathBuf) -> Result> { - match open_tar_file(&archive_file, |f| zstd::Decoder::new(f).unwrap()) { + match open_tar_file(archive_file, |f| zstd::Decoder::new(f).unwrap()) { Err(e) => Err(e), Ok(archive) => list_tar(archive), } } fn perform(&self, archive_file: &PathBuf, opts: PathUtils) -> Result<()> { - match open_tar_file(&archive_file, |f| zstd::Decoder::new(f).unwrap()) { + match open_tar_file(archive_file, |f| zstd::Decoder::new(f).unwrap()) { Err(e) => Err(e), Ok(archive) => extract_tar(archive, opts), } diff --git a/src/extractor/zip.rs b/src/extractor/zip.rs index 0f33603..5a97f42 100644 --- a/src/extractor/zip.rs +++ b/src/extractor/zip.rs @@ -12,7 +12,7 @@ pub(super) struct ZipExtractor {} impl ToteExtractor for ZipExtractor { fn list(&self, archive_file: &PathBuf) -> Result> { - let zip_file = File::open(&archive_file).unwrap(); + let zip_file = File::open(archive_file).unwrap(); let mut zip = zip::ZipArchive::new(zip_file).unwrap(); let mut result = vec![]; @@ -24,7 +24,7 @@ impl ToteExtractor for ZipExtractor { } fn perform(&self, archive_file: &PathBuf, opts: PathUtils) -> Result<()> { - let zip_file = File::open(&archive_file).unwrap(); + let zip_file = File::open(archive_file).unwrap(); let mut zip = zip::ZipArchive::new(zip_file).unwrap(); for i in 0..zip.len() { let mut file = zip.by_index(i).unwrap(); diff --git a/src/format.rs b/src/format.rs index dd688e0..ed3cf24 100644 --- a/src/format.rs +++ b/src/format.rs @@ -1,5 +1,5 @@ use std::fmt::Display; -use std::{ffi::OsStr, path::PathBuf}; +use std::path::{Path, PathBuf}; use super::{Result, ToteError}; @@ -19,20 +19,13 @@ pub fn is_archive_file(arg: &PathBuf) -> bool { return true; } } - return false; + false } /// Find the format of the given file name. /// If the given file name has an unknown extension for totebag, it returns an `Err(ToteErro::Unknown)`. -pub fn find_format(path: &PathBuf) -> Result { - match find_format_impl(path.file_name()) { - Ok(f) => Ok(f), - Err(e) => Err(e), - } -} - -fn find_format_impl(file_name: Option<&OsStr>) -> Result { - match file_name { +pub fn find_format(path: &Path) -> Result { + match path.file_name() { Some(file_name) => { let name = file_name.to_str().unwrap().to_lowercase(); for ext in exts().iter() { @@ -40,9 +33,9 @@ fn find_format_impl(file_name: Option<&OsStr>) -> Result { return Ok(ext.0.clone()); } } - return Err(ToteError::UnknownFormat( + Err(ToteError::UnknownFormat( file_name.to_str().unwrap().to_string(), - )); + )) } None => Err(ToteError::NoArgumentsGiven), } @@ -145,7 +138,7 @@ mod tests { assert_eq!(f, Format::SevenZ); assert_eq!(f.to_string(), "SevenZ".to_string()); } - if let Err(e) = find_format_impl(None) { + if let Err(e) = find_format(&PathBuf::from(".")) { if let ToteError::NoArgumentsGiven = e { assert!(true); } else { diff --git a/src/list.rs b/src/list.rs index c4407a9..b99d30e 100644 --- a/src/list.rs +++ b/src/list.rs @@ -23,9 +23,9 @@ fn format_size(compressed: Option, original: Option) -> String { let formatter = humansize::make_format(humansize::DECIMAL); match (compressed, original) { (Some(c), Some(o)) => format!("{:>10}/{:>10}", formatter(c), formatter(o)), - (Some(c), None) => format!("{:>10}/ ", formatter(c)), - (None, Some(o)) => format!(" /{:>10}", formatter(o)), - (None, None) => " / ".to_string(), + (Some(c), None) => format!("{:>10}/ -------- ", formatter(c)), + (None, Some(o)) => format!(" -------- /{:>10}", formatter(o)), + (None, None) => " -------- / -------- ".to_string(), } } @@ -33,16 +33,16 @@ fn format_unix_mode(mode: Option) -> String { if let Some(mode) = mode { format!( "-{}{}{}", - format_mode(mode >> 6 & 0x7), - format_mode(mode >> 3 & 0x7), - format_mode(mode >> 0 & 0x7) + format_mode((mode >> 6 & 0x7) as u8), + format_mode((mode >> 3 & 0x7) as u8), + format_mode((mode & 0x7) as u8) ) } else { "----------".to_string() } } -fn format_mode(mode: u32) -> String { +fn format_mode(mode: u8) -> String { match mode { 0 => "---", 1 => "--x", @@ -59,6 +59,8 @@ fn format_mode(mode: u32) -> String { #[cfg(test)] mod tests { + use chrono::DateTime; + use super::*; #[test] @@ -77,4 +79,27 @@ mod tests { "-rw-r--r-- 100 B/ 200 B 2021-02-03 04:05:10 Cargo.toml" ); } + + #[test] + fn trivial_tests() { + assert_eq!(format_date(None), " "); + assert_eq!( + format_date(Some(DateTime::from_timestamp(0, 0).unwrap().naive_local())), + "1970-01-01 00:00:00" + ); + + assert_eq!(format_size(Some(100), Some(200)), " 100 B/ 200 B"); + assert_eq!(format_size(None, Some(200)), " -------- / 200 B"); + assert_eq!(format_size(None, None), " -------- / -------- "); + assert_eq!(format_size(Some(100), None), " 100 B/ -------- "); + + assert_eq!(format_unix_mode(None), "----------"); + assert_eq!(format_unix_mode(Some(0o644)), "-rw-r--r--"); + assert_eq!(format_unix_mode(Some(0o751)), "-rwxr-x--x"); + assert_eq!(format_unix_mode(Some(0o640)), "-rw-r-----"); + assert_eq!(format_unix_mode(Some(0o123)), "---x-w--wx"); + assert_eq!(format_unix_mode(Some(0o456)), "-r--r-xrw-"); + + assert_eq!(format_mode(128), "???"); + } } diff --git a/src/main.rs b/src/main.rs index 0be7958..9397d72 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,7 +1,7 @@ use clap::Parser; use std::path::PathBuf; -use cli::RunMode; +use cli::{LogLevel, RunMode}; use totebag::archiver::Archiver; use totebag::extractor::Extractor; use totebag::{Result, ToteError}; @@ -9,9 +9,9 @@ use totebag::{Result, ToteError}; mod cli; mod list; -fn update_loglevel(opts: &cli::CliOpts) { +fn update_loglevel(level: LogLevel) { use env_logger; - match opts.level { + match level { cli::LogLevel::Error => std::env::set_var("RUST_LOG", "error"), cli::LogLevel::Warn => std::env::set_var("RUST_LOG", "warn"), cli::LogLevel::Info => std::env::set_var("RUST_LOG", "info"), @@ -21,7 +21,7 @@ fn update_loglevel(opts: &cli::CliOpts) { } fn perform(mut opts: cli::CliOpts) -> Result<()> { - update_loglevel(&opts); + update_loglevel(opts.level); if cfg!(debug_assertions) { #[cfg(debug_assertions)] if opts.generate_completion { @@ -51,9 +51,8 @@ where log::info!("args: {:?}", args); let mut errs = vec![]; for arg in args { - match f(&opts, arg) { - Err(e) => errs.push(e), - Ok(_) => {} + if let Err(e) = f(&opts, arg) { + errs.push(e); } } if errs.is_empty() { @@ -104,7 +103,7 @@ fn perform_archive(cliopts: cli::CliOpts) -> Result<()> { cliopts .args .iter() - .map(|s| PathBuf::from(s)) + .map(PathBuf::from) .collect::>(), ) .rebase_dir(cliopts.archivers.base_dir) @@ -128,7 +127,7 @@ fn print_error(e: &ToteError) { match e { ToteError::Archiver(s) => println!("Archive error: {}", s), ToteError::Array(errs) => { - for err in errs.into_iter() { + for err in errs.iter() { print_error(err); } } @@ -214,4 +213,10 @@ mod tests { assert_eq!(opts.args.len(), 4); assert_eq!(opts.args, vec!["src", "LICENSE", "README.md", "Cargo.toml"]); } + + #[test] + fn test_update_loglevel_error() { + update_loglevel(LogLevel::Error); + assert_eq!(std::env::var("RUST_LOG").unwrap(), "error"); + } } From 503e90e93349b922aab5a94c7457822172f18df4 Mon Sep 17 00:00:00 2001 From: GitHub Actions Date: Sun, 26 Jan 2025 05:22:18 +0000 Subject: [PATCH 2/3] update version to 0.7.1, ready to publish v0.7.1 --- Cargo.toml | 2 +- README.md | 6 +++--- dockers/alpine/Dockerfile | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 3dc038e..ee88fa2 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "totebag" -version = "0.7.0" +version = "0.7.1" description = "A tool for extracting/archiving files and directories in multiple formats." repository = "https://github.com/tamada/totebag" readme = "README.md" diff --git a/README.md b/README.md index 9de9671..d5d4495 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,8 @@ # totebag -[![Version](https://shields.io/badge/Version-0.7.0-blue)](https://github.com/tamada/totebag/releases/tag/v0.7.0) +[![Version](https://shields.io/badge/Version-0.7.1-blue)](https://github.com/tamada/totebag/releases/tag/v0.7.1) [![MIT License](https://shields.io/badge/License-MIT-blue)](https://github.com/tamada/totebag/blob/main/LICENSE) -[![docker](https://shields.io/badge/Docker-0.7.0-blue?logo=docker)](https://github.com/tamada/totebag/pkgs/container/totebag) +[![docker](https://shields.io/badge/Docker-0.7.1-blue?logo=docker)](https://github.com/tamada/totebag/pkgs/container/totebag) [![build](https://github.com/tamada/totebag/actions/workflows/build.yaml/badge.svg)](https://github.com/tamada/totebag/actions/workflows/build.yaml) [![Rust Report Card](https://rust-reportcard.xuri.me/badge/github.com/tamada/totebag)](https://rust-reportcard.xuri.me/report/github.com/tamada/totebag) @@ -67,7 +67,7 @@ brew install tamada/tap/totebag ## :whale: Docker ```sh -docker run -it --rm -v $PWD:/workdir ghcr.io/tamada/totebag:0.7.0 [OPTIONS] [ARGUMENTS]... +docker run -it --rm -v $PWD:/workdir ghcr.io/tamada/totebag:0.7.1 [OPTIONS] [ARGUMENTS]... ``` - **Working directory**: `/workdir` diff --git a/dockers/alpine/Dockerfile b/dockers/alpine/Dockerfile index f6f46ab..710acb4 100644 --- a/dockers/alpine/Dockerfile +++ b/dockers/alpine/Dockerfile @@ -1,6 +1,6 @@ FROM alpine:3.16 AS builder -ARG VERSION=0.7.0 +ARG VERSION=0.7.1 ARG TARGETPLATFORM ARG PLATFORM=${TARGETPLATFORM#linux/} @@ -12,7 +12,7 @@ RUN apk add --no-cache curl tar gzip \ FROM alpine:3.16 -ARG VERSION=0.7.0 +ARG VERSION=0.7.1 LABEL org.opencontainers.image.source https://github.com/tamada/totebag From ab8e0c20b9f601bb5fe0a93a88250c10941bb8dd Mon Sep 17 00:00:00 2001 From: Haruaki Tamada Date: Sun, 26 Jan 2025 15:02:57 +0900 Subject: [PATCH 3/3] refactor: update method signatures to accept PathBuf directly instead of &PathBuf --- src/extractor.rs | 21 ++++++++++----------- src/extractor/cab.rs | 12 ++++++------ src/extractor/lha.rs | 6 +++--- src/extractor/rar.rs | 6 +++--- src/extractor/sevenz.rs | 6 +++--- src/extractor/tar.rs | 30 +++++++++++++++--------------- src/extractor/zip.rs | 6 +++--- 7 files changed, 43 insertions(+), 44 deletions(-) diff --git a/src/extractor.rs b/src/extractor.rs index e3c5482..45fa58c 100644 --- a/src/extractor.rs +++ b/src/extractor.rs @@ -87,7 +87,7 @@ impl PathUtils<'_> { self.e.base_dir() } - fn destination(&self, target: PathBuf) -> Result { + fn destination>(&self, target: P) -> Result { self.e.destination(target) } } @@ -121,7 +121,7 @@ impl Extractor { Ok(e) => e, Err(e) => return Err(e), }; - extractor.list(&self.archive_file) + extractor.list(self.archive_file.clone()) } /// Execute extraction of the archive file. @@ -131,7 +131,7 @@ impl Extractor { Err(e) => return Err(e), }; match self.can_extract() { - Ok(_) => extractor.perform(&self.archive_file, PathUtils { e: self }), + Ok(_) => extractor.perform(self.archive_file.clone(), PathUtils { e: &self }), Err(e) => Err(e), } } @@ -151,8 +151,7 @@ impl Extractor { fn base_dir(&self) -> PathBuf { if self.use_archive_name_dir { if let Some(stem) = self.archive_file.file_stem() { - let dir_name = stem.to_str().unwrap(); - self.destination.join(dir_name) + self.destination.join(stem) } else { self.destination.clone() } @@ -162,7 +161,7 @@ impl Extractor { } /// Return the path of the `target` file for output. - fn destination(&self, target: PathBuf) -> Result { + fn destination>(&self, target: P) -> Result { let base = self.base_dir(); let dest = base.join(target); if dest.exists() && !self.overwrite { @@ -187,9 +186,9 @@ impl Extractor { /// The trait for extracting the archive file. pub(crate) trait ToteExtractor { /// returns the entry list of the given archive file. - fn list(&self, archive_file: &PathBuf) -> Result>; + fn list(&self, archive_file: PathBuf) -> Result>; /// extract the given archive file into the specified directory with the given options. - fn perform(&self, archive_file: &PathBuf, opts: PathUtils) -> Result<()>; + fn perform(&self, archive_file: PathBuf, opts: PathUtils) -> Result<()>; #[cfg(test)] /// returns the supported format of the extractor. fn format(&self) -> Format; @@ -232,17 +231,17 @@ mod tests { .use_archive_name_dir(true) .build(); assert_eq!(opts1.base_dir(), PathBuf::from("./archive")); - if let Ok(t) = opts1.destination("text1.txt".into()) { + if let Ok(t) = opts1.destination("text1.txt") { assert_eq!(t, PathBuf::from("./archive/text1.txt")); } - if let Ok(t) = opts1.destination("text2.txt".into()) { + if let Ok(t) = opts1.destination("text2.txt") { assert_eq!(t, PathBuf::from("./archive/text2.txt")); } let archive_file = PathBuf::from("/tmp/archive.zip"); let opts2 = Extractor::builder().archive_file(archive_file).build(); assert_eq!(opts2.base_dir(), PathBuf::from(".")); - if let Ok(t) = opts2.destination("./text1.txt".into()) { + if let Ok(t) = opts2.destination("./text1.txt") { assert_eq!(t, PathBuf::from("./text1.txt")); } } diff --git a/src/extractor/cab.rs b/src/extractor/cab.rs index ad2e49f..bdf9243 100644 --- a/src/extractor/cab.rs +++ b/src/extractor/cab.rs @@ -10,19 +10,19 @@ use crate::{Result, ToteError}; pub(super) struct CabExtractor {} impl ToteExtractor for CabExtractor { - fn list(&self, target: &PathBuf) -> Result> { - list_impl(target, convert) + fn list(&self, target: PathBuf) -> Result> { + list_impl(&target, convert) } - fn perform(&self, target: &PathBuf, opts: PathUtils) -> Result<()> { - let list = match list_impl(target, |file| { + fn perform(&self, target: PathBuf, opts: PathUtils) -> Result<()> { + let list = match list_impl(&target, |file| { (file.name().to_string(), file.uncompressed_size()) }) { Ok(l) => l, Err(e) => return Err(e), }; let mut errs = vec![]; - let mut cabinet = open_cabinet(target)?; + let mut cabinet = open_cabinet(&target)?; for file in list { if let Err(e) = write_file_impl(&mut cabinet, file, &opts) { errs.push(e); @@ -116,7 +116,7 @@ mod tests { fn test_list_archives() { let file = PathBuf::from("testdata/test.cab"); let extractor = CabExtractor {}; - match extractor.list(&file) { + match extractor.list(file) { Ok(r) => { let r = r.iter().map(|e| e.name.clone()).collect::>(); assert_eq!(r.len(), 16); diff --git a/src/extractor/lha.rs b/src/extractor/lha.rs index d143dea..e4b7607 100644 --- a/src/extractor/lha.rs +++ b/src/extractor/lha.rs @@ -12,7 +12,7 @@ use crate::{Result, ToteError}; pub(super) struct LhaExtractor {} impl ToteExtractor for LhaExtractor { - fn list(&self, archive_file: &PathBuf) -> Result> { + fn list(&self, archive_file: PathBuf) -> Result> { let mut result = vec![]; let mut reader = match delharc::parse_file(archive_file) { Err(e) => return Err(ToteError::IO(e)), @@ -35,7 +35,7 @@ impl ToteExtractor for LhaExtractor { Ok(result) } - fn perform(&self, archive_file: &PathBuf, opts: PathUtils) -> Result<()> { + fn perform(&self, archive_file: PathBuf, opts: PathUtils) -> Result<()> { let mut reader = match delharc::parse_file(archive_file) { Err(e) => return Err(ToteError::IO(e)), Ok(h) => h, @@ -123,7 +123,7 @@ mod tests { fn test_list_archives() { let file = PathBuf::from("testdata/test.lzh"); let extractor = LhaExtractor {}; - match extractor.list(&file) { + match extractor.list(file) { Ok(r) => { let r = r.iter().map(|e| e.name.clone()).collect::>(); assert_eq!(r.len(), 23); diff --git a/src/extractor/rar.rs b/src/extractor/rar.rs index db6c3fa..82c3c75 100644 --- a/src/extractor/rar.rs +++ b/src/extractor/rar.rs @@ -11,7 +11,7 @@ use crate::extractor::{Entry, PathUtils, ToteExtractor}; pub(super) struct RarExtractor {} impl ToteExtractor for RarExtractor { - fn list(&self, archive_file: &PathBuf) -> Result> { + fn list(&self, archive_file: PathBuf) -> Result> { let mut r = vec![]; for entry in unrar::Archive::new(&archive_file) .open_for_listing() @@ -23,7 +23,7 @@ impl ToteExtractor for RarExtractor { Ok(r) } - fn perform(&self, archive_file: &PathBuf, opts: PathUtils) -> Result<()> { + fn perform(&self, archive_file: PathBuf, opts: PathUtils) -> Result<()> { let archive = unrar::Archive::new(&archive_file); let mut file = archive.open_for_processing().unwrap(); while let Some(header) = file.read_header().unwrap() { @@ -79,7 +79,7 @@ mod tests { fn test_list_archives() { let extractor = RarExtractor {}; let file = PathBuf::from("testdata/test.rar"); - match extractor.list(&file) { + match extractor.list(file) { Ok(r) => { let r = r.iter().map(|e| e.name.clone()).collect::>(); assert_eq!(r.len(), 18); diff --git a/src/extractor/sevenz.rs b/src/extractor/sevenz.rs index 8fe5ac6..65e1f0c 100644 --- a/src/extractor/sevenz.rs +++ b/src/extractor/sevenz.rs @@ -10,7 +10,7 @@ use crate::extractor::{Entry, PathUtils, ToteExtractor}; pub(super) struct SevenZExtractor {} impl ToteExtractor for SevenZExtractor { - fn list(&self, archive_file: &PathBuf) -> Result> { + fn list(&self, archive_file: PathBuf) -> Result> { let mut reader = File::open(archive_file).unwrap(); let len = reader.metadata().unwrap().len(); match Archive::read(&mut reader, len, Password::empty().as_ref()) { @@ -25,7 +25,7 @@ impl ToteExtractor for SevenZExtractor { } } - fn perform(&self, archive_file: &PathBuf, opts: PathUtils) -> Result<()> { + fn perform(&self, archive_file: PathBuf, opts: PathUtils) -> Result<()> { let file = match File::open(archive_file) { Ok(file) => file, Err(e) => return Err(ToteError::IO(e)), @@ -83,7 +83,7 @@ mod tests { fn test_list() { let file = PathBuf::from("testdata/test.7z"); let extractor = SevenZExtractor {}; - match extractor.list(&file) { + match extractor.list(file) { Ok(r) => { let r = r.iter().map(|e| e.name.clone()).collect::>(); assert_eq!(r.len(), 21); diff --git a/src/extractor/tar.rs b/src/extractor/tar.rs index f176a60..a42ee0f 100644 --- a/src/extractor/tar.rs +++ b/src/extractor/tar.rs @@ -21,13 +21,13 @@ pub(super) struct TarXzExtractor {} pub(super) struct TarZstdExtractor {} impl ToteExtractor for TarExtractor { - fn list(&self, archive_file: &PathBuf) -> Result> { + fn list(&self, archive_file: PathBuf) -> Result> { match open_tar_file(archive_file, |f| f) { Ok(archive) => list_tar(archive), Err(e) => Err(e), } } - fn perform(&self, archive_file: &PathBuf, opts: PathUtils) -> Result<()> { + fn perform(&self, archive_file: PathBuf, opts: PathUtils) -> Result<()> { match open_tar_file(archive_file, |f| f) { Err(e) => Err(e), Ok(archive) => extract_tar(archive, opts), @@ -40,13 +40,13 @@ impl ToteExtractor for TarExtractor { } impl ToteExtractor for TarGzExtractor { - fn list(&self, archive_file: &PathBuf) -> Result> { + fn list(&self, archive_file: PathBuf) -> Result> { match open_tar_file(archive_file, flate2::read::GzDecoder::new) { Ok(archive) => list_tar(archive), Err(e) => Err(e), } } - fn perform(&self, archive_file: &PathBuf, opts: PathUtils) -> Result<()> { + fn perform(&self, archive_file: PathBuf, opts: PathUtils) -> Result<()> { match open_tar_file(archive_file, flate2::read::GzDecoder::new) { Ok(archive) => extract_tar(archive, opts), Err(e) => Err(e), @@ -59,13 +59,13 @@ impl ToteExtractor for TarGzExtractor { } impl ToteExtractor for TarBz2Extractor { - fn list(&self, archive_file: &PathBuf) -> Result> { + fn list(&self, archive_file: PathBuf) -> Result> { match open_tar_file(archive_file, bzip2::read::BzDecoder::new) { Ok(archive) => list_tar(archive), Err(e) => Err(e), } } - fn perform(&self, archive_file: &PathBuf, opts: PathUtils) -> Result<()> { + fn perform(&self, archive_file: PathBuf, opts: PathUtils) -> Result<()> { match open_tar_file(archive_file, bzip2::read::BzDecoder::new) { Err(e) => Err(e), Ok(archive) => extract_tar(archive, opts), @@ -78,13 +78,13 @@ impl ToteExtractor for TarBz2Extractor { } impl ToteExtractor for TarXzExtractor { - fn list(&self, archive_file: &PathBuf) -> Result> { + fn list(&self, archive_file: PathBuf) -> Result> { match open_tar_file(archive_file, XzDecoder::new) { Err(e) => Err(e), Ok(archive) => list_tar(archive), } } - fn perform(&self, archive_file: &PathBuf, opts: PathUtils) -> Result<()> { + fn perform(&self, archive_file: PathBuf, opts: PathUtils) -> Result<()> { match open_tar_file(archive_file, XzDecoder::new) { Err(e) => Err(e), Ok(archive) => extract_tar(archive, opts), @@ -97,13 +97,13 @@ impl ToteExtractor for TarXzExtractor { } impl ToteExtractor for TarZstdExtractor { - fn list(&self, archive_file: &PathBuf) -> Result> { + fn list(&self, archive_file: PathBuf) -> Result> { match open_tar_file(archive_file, |f| zstd::Decoder::new(f).unwrap()) { Err(e) => Err(e), Ok(archive) => list_tar(archive), } } - fn perform(&self, archive_file: &PathBuf, opts: PathUtils) -> Result<()> { + fn perform(&self, archive_file: PathBuf, opts: PathUtils) -> Result<()> { match open_tar_file(archive_file, |f| zstd::Decoder::new(f).unwrap()) { Err(e) => Err(e), Ok(archive) => extract_tar(archive, opts), @@ -115,7 +115,7 @@ impl ToteExtractor for TarZstdExtractor { } } -fn open_tar_file(file: &PathBuf, opener: F) -> Result> +fn open_tar_file(file: PathBuf, opener: F) -> Result> where F: FnOnce(File) -> R, { @@ -186,7 +186,7 @@ mod tests { fn test_list_tar_file() { let file = PathBuf::from("testdata/test.tar"); let extractor = TarExtractor {}; - match extractor.list(&file) { + match extractor.list(file) { Ok(r) => { let r = r.iter().map(|e| e.name.clone()).collect::>(); assert_eq!(r.len(), 16); @@ -220,7 +220,7 @@ mod tests { fn test_list_tarbz2_file() { let file = PathBuf::from("testdata/test.tar.bz2"); let extractor = TarBz2Extractor {}; - match extractor.list(&file) { + match extractor.list(file) { Ok(r) => { let r = r.iter().map(|e| e.name.clone()).collect::>(); assert_eq!(r.len(), 16); @@ -237,7 +237,7 @@ mod tests { fn test_list_targz_file() { let file = PathBuf::from("testdata/test.tar.gz"); let extractor = TarGzExtractor {}; - match extractor.list(&file) { + match extractor.list(file) { Ok(r) => { let r = r.iter().map(|e| e.name.clone()).collect::>(); assert_eq!(r.len(), 16); @@ -254,7 +254,7 @@ mod tests { fn test_list_tarzstd_file() { let file = PathBuf::from("testdata/test.tar.zst"); let extractor = TarZstdExtractor {}; - match extractor.list(&file) { + match extractor.list(file) { Ok(r) => { let r = r.iter().map(|e| e.name.clone()).collect::>(); assert_eq!(r.len(), 16); diff --git a/src/extractor/zip.rs b/src/extractor/zip.rs index 5a97f42..589714b 100644 --- a/src/extractor/zip.rs +++ b/src/extractor/zip.rs @@ -11,7 +11,7 @@ use crate::Result; pub(super) struct ZipExtractor {} impl ToteExtractor for ZipExtractor { - fn list(&self, archive_file: &PathBuf) -> Result> { + fn list(&self, archive_file: PathBuf) -> Result> { let zip_file = File::open(archive_file).unwrap(); let mut zip = zip::ZipArchive::new(zip_file).unwrap(); @@ -23,7 +23,7 @@ impl ToteExtractor for ZipExtractor { Ok(result) } - fn perform(&self, archive_file: &PathBuf, opts: PathUtils) -> Result<()> { + fn perform(&self, archive_file: PathBuf, opts: PathUtils) -> Result<()> { let zip_file = File::open(archive_file).unwrap(); let mut zip = zip::ZipArchive::new(zip_file).unwrap(); for i in 0..zip.len() { @@ -89,7 +89,7 @@ mod tests { fn test_list_archives() { let file = PathBuf::from("testdata/test.zip"); let extractor = ZipExtractor {}; - match extractor.list(&file) { + match extractor.list(file) { Ok(r) => { assert_eq!(r.len(), 19); assert_eq!(