9073633753

Committed 14 May 2024 04:12AM UTC coverage: 75.855% (-3.8%) from 79.637%

Build # 9073633753

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #19 from tamada/release/v0.3.0

Release/v0.3.0

Run Details

208 of 343 new or added lines in 12 files covered. (60.64%)

9 existing lines in 3 files now uncovered.

754 of 994 relevant lines covered (75.86%)

4.19 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

70.51

/src/extractor.rs

use std::path::PathBuf;

use crate::format::{find_format, Format};
use crate::cli::{Result, ToteError};
use crate::CliOpts;
use crate::verboser::{create_verboser, Verboser};

mod zip;
mod rar;
mod tar;
mod sevenz;

pub struct ExtractorOpts {
    pub dest: PathBuf,
    pub use_archive_name_dir: bool,
    pub overwrite: bool,
    pub v: Box<dyn Verboser>,
}

impl ExtractorOpts {
    pub fn new(opts: &CliOpts) -> ExtractorOpts {
        let d = opts.output.clone();
        ExtractorOpts {
            dest: d.unwrap_or_else(|| {
                PathBuf::from(".")
            }),
            use_archive_name_dir: opts.to_archive_name_dir,
            overwrite: opts.overwrite,
            v: create_verboser(opts.verbose),
        }
    }
    
    /// Returns the base of the destination directory for the archive file.
    /// The target is the archive file name of source.
    pub fn destination(&self, target: &PathBuf) -> PathBuf {
        if self.use_archive_name_dir {
            let file_name = target.file_name().unwrap().to_str().unwrap();
            let ext = target.extension().unwrap().to_str().unwrap();
            let dir_name = file_name.trim_end_matches(ext)
                .trim_end_matches(".").to_string();
            self.dest.join(dir_name)
        } else {
            self.dest.clone()
        }
    }
}

pub trait Extractor {
    fn list_archives(&self, archive_file: PathBuf) -> Result<Vec<String>>;
    fn perform(&self, archive_file: PathBuf, opts: &ExtractorOpts) -> Result<()>;
    fn format(&self) -> Format;
}

pub fn create_extractor(file: &PathBuf) -> Result<Box<dyn Extractor>> {
    let format = find_format(file.file_name());
    match format {
        Ok(format) => {
            return match format {
                Format::Zip => Ok(Box::new(zip::ZipExtractor{})),
                Format::Rar => Ok(Box::new(rar::RarExtractor{})),
                Format::Tar => Ok(Box::new(tar::TarExtractor{})),
                Format::TarGz => Ok(Box::new(tar::TarGzExtractor{})),
                Format::TarBz2 => Ok(Box::new(tar::TarBz2Extractor{})),
                Format::TarXz => Ok(Box::new(tar::TarXzExtractor{})),
                Format::SevenZ => Ok(Box::new(sevenz::SevenZExtractor{})),
                Format::Unknown(s) => Err(ToteError::UnknownFormat(format!("{}: unsupported format", s))),
            }
        }
        Err(msg) => Err(msg),
    }
}

pub fn extractor_info(extractor: &Box<dyn Extractor>, target: &PathBuf, opts: &ExtractorOpts) -> String {
    format!(
        "Format: {:?}\nFile: {:?}\nDestination: {:?}",
        extractor.format(),
        target,
        opts.dest,
    )
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_destination() {
        let opts1 = ExtractorOpts {
            dest: PathBuf::from("."),
            use_archive_name_dir: true,
            overwrite: false,
            v: create_verboser(false),
        };
        let target = PathBuf::from("/tmp/archive.zip");
        assert_eq!(opts1.destination(&target), PathBuf::from("./archive"));

        let opts2 = ExtractorOpts {
            dest: PathBuf::from("."),
            use_archive_name_dir: false,
            overwrite: false,
            v: create_verboser(false),
        };
        let target = PathBuf::from("/tmp/archive.zip");
        assert_eq!(opts2.destination(&target), PathBuf::from("."));
    }

    #[test]
    fn test_create_extractor() {
        let e1 = create_extractor(&PathBuf::from("results/test.zip"));
        assert!(e1.is_ok());
        assert_eq!(e1.unwrap().format(), Format::Zip);

        let e2 = create_extractor(&PathBuf::from("results/test.tar"));
        assert!(e2.is_ok());
        assert_eq!(e2.unwrap().format(), Format::Tar);

        let e3 = create_extractor(&PathBuf::from("results/test.tgz"));
        assert!(e3.is_ok());
        assert_eq!(e3.unwrap().format(), Format::TarGz);

        let e4 = create_extractor(&PathBuf::from("results/test.tbz2"));
        assert!(e4.is_ok());
        assert_eq!(e4.unwrap().format(), Format::TarBz2);

        let e5 = create_extractor(&PathBuf::from("results/test.rar"));
        assert!(e5.is_ok());
        assert_eq!(e5.unwrap().format(), Format::Rar);
    }
}

1	use std::path::PathBuf;
2
3	use crate::format::{find_format, Format};
4	use crate::cli::{Result, ToteError};
5	use crate::CliOpts;
6	use crate::verboser::{create_verboser, Verboser};
7
8	mod zip;
9	mod rar;
10	mod tar;
11	mod sevenz;
12
13	pub struct ExtractorOpts {
14	pub dest: PathBuf,
15	pub use_archive_name_dir: bool,
16	pub overwrite: bool,
17	pub v: Box<dyn Verboser>,
18	}
19
20	impl ExtractorOpts {
NEW 21	pub fn new(opts: &CliOpts) -> ExtractorOpts {	×
NEW 22	let d = opts.output.clone();	×
NEW 23	ExtractorOpts {	×
NEW 24	dest: d.unwrap_or_else(\|\| {	×
NEW 25	PathBuf::from(".")	×
NEW 26	}),	×
NEW 27	use_archive_name_dir: opts.to_archive_name_dir,	×
NEW 28	overwrite: opts.overwrite,	×
NEW 29	v: create_verboser(opts.verbose),	×
NEW 30	}	×
NEW 31	}	×
32
33	/// Returns the base of the destination directory for the archive file.
34	/// The target is the archive file name of source.
35	pub fn destination(&self, target: &PathBuf) -> PathBuf {	37✔
36	if self.use_archive_name_dir {	37✔
37	let file_name = target.file_name().unwrap().to_str().unwrap();	19✔
38	let ext = target.extension().unwrap().to_str().unwrap();	19✔
39	let dir_name = file_name.trim_end_matches(ext)	19✔
40	.trim_end_matches(".").to_string();	19✔
41	self.dest.join(dir_name)	19✔
42	} else {
43	self.dest.clone()	18✔
44	}
45	}	37✔
46	}
47
48	pub trait Extractor {
49	fn list_archives(&self, archive_file: PathBuf) -> Result<Vec<String>>;
50	fn perform(&self, archive_file: PathBuf, opts: &ExtractorOpts) -> Result<()>;
51	fn format(&self) -> Format;
52	}
53
54	pub fn create_extractor(file: &PathBuf) -> Result<Box<dyn Extractor>> {	5✔
55	let format = find_format(file.file_name());	5✔
56	match format {	5✔
57	Ok(format) => {	5✔
58	return match format {	5✔
59	Format::Zip => Ok(Box::new(zip::ZipExtractor{})),	1✔
60	Format::Rar => Ok(Box::new(rar::RarExtractor{})),	1✔
61	Format::Tar => Ok(Box::new(tar::TarExtractor{})),	1✔
62	Format::TarGz => Ok(Box::new(tar::TarGzExtractor{})),	1✔
63	Format::TarBz2 => Ok(Box::new(tar::TarBz2Extractor{})),	1✔
NEW 64	Format::TarXz => Ok(Box::new(tar::TarXzExtractor{})),	×
NEW 65	Format::SevenZ => Ok(Box::new(sevenz::SevenZExtractor{})),	×
NEW 66	Format::Unknown(s) => Err(ToteError::UnknownFormat(format!("{}: unsupported format", s))),	×
67	}
68	}
69	Err(msg) => Err(msg),	×
70	}
71	}	5✔
72
73	pub fn extractor_info(extractor: &Box<dyn Extractor>, target: &PathBuf, opts: &ExtractorOpts) -> String {	×
74	format!(	×
75	"Format: {:?}\nFile: {:?}\nDestination: {:?}",	×
76	extractor.format(),	×
77	target,	×
78	opts.dest,	×
79	)	×
80	}	×
81
82	#[cfg(test)]
83	mod tests {
84	use super::*;
85
86	#[test]
87	fn test_destination() {	1✔
88	let opts1 = ExtractorOpts {	1✔
89	dest: PathBuf::from("."),	1✔
90	use_archive_name_dir: true,	1✔
91	overwrite: false,	1✔
92	v: create_verboser(false),	1✔
93	};	1✔
94	let target = PathBuf::from("/tmp/archive.zip");	1✔
95	assert_eq!(opts1.destination(&target), PathBuf::from("./archive"));	1✔
96
97	let opts2 = ExtractorOpts {	1✔
98	dest: PathBuf::from("."),	1✔
99	use_archive_name_dir: false,	1✔
100	overwrite: false,	1✔
101	v: create_verboser(false),	1✔
102	};	1✔
103	let target = PathBuf::from("/tmp/archive.zip");	1✔
104	assert_eq!(opts2.destination(&target), PathBuf::from("."));	1✔
105	}	1✔
106
107	#[test]
108	fn test_create_extractor() {	1✔
109	let e1 = create_extractor(&PathBuf::from("results/test.zip"));	1✔
110	assert!(e1.is_ok());	1✔
111	assert_eq!(e1.unwrap().format(), Format::Zip);	1✔
112
113	let e2 = create_extractor(&PathBuf::from("results/test.tar"));	1✔
114	assert!(e2.is_ok());	1✔
115	assert_eq!(e2.unwrap().format(), Format::Tar);	1✔
116
117	let e3 = create_extractor(&PathBuf::from("results/test.tgz"));	1✔
118	assert!(e3.is_ok());	1✔
119	assert_eq!(e3.unwrap().format(), Format::TarGz);	1✔
120
121	let e4 = create_extractor(&PathBuf::from("results/test.tbz2"));	1✔
122	assert!(e4.is_ok());	1✔
123	assert_eq!(e4.unwrap().format(), Format::TarBz2);	1✔
124
125	let e5 = create_extractor(&PathBuf::from("results/test.rar"));	1✔
126	assert!(e5.is_ok());	1✔
127	assert_eq!(e5.unwrap().format(), Format::Rar);	1✔
128	}	1✔
129	}

tamada / totebag / 9073633753

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous