9167978950

Committed 21 May 2024 02:37AM UTC coverage: 80.667% (+4.8%) from 75.855%

Build # 9167978950

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #21 from tamada/release/v0.4.0

Release/v0.4.0

Run Details

52 of 59 new or added lines in 5 files covered. (88.14%)

7 existing lines in 1 file now uncovered.

847 of 1050 relevant lines covered (80.67%)

4.4 hits per line

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

85.92

/src/format.rs

use std::ffi::OsStr;
use std::fmt::Display;
use crate::cli::{ToteError, Result};

pub fn find_format(file_name: Option<&OsStr>) -> Result<Format> {
    match file_name {
        Some(file_name) => {
            let name = file_name.to_str().unwrap().to_lowercase();
            if name.ends_with(".tar.gz") || name.ends_with(".tgz") {
                return Ok(Format::TarGz);
            } else if name.ends_with(".tar.bz2") || name.ends_with(".tbz2") {
                return Ok(Format::TarBz2);
            } else if name.ends_with(".tar.xz") || name.ends_with(".txz") {
                return Ok(Format::TarXz);
            } else if name.ends_with(".7z") {
                return Ok(Format::SevenZ);
            } else if name.ends_with(".tar") {
                return Ok(Format::Tar);
            } else if name.ends_with(".rar") {
                return Ok(Format::Rar);
            } else if name.ends_with(".zip") || name.ends_with(".jar") || name.ends_with(".war") || name.ends_with(".ear") {
                return Ok(Format::Zip);
            } else {
                return Ok(Format::Unknown(file_name.to_str().unwrap().to_string()));
            }
        }
        None => Err(ToteError::NoArgumentsGiven),
    }
}


#[derive(Debug, PartialEq)]
pub enum Format {
    Zip,
    Tar,
    TarGz,
    TarBz2,
    TarXz,
    SevenZ,
    Rar,
    Unknown(String),
}

impl Display for Format {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Format::Zip => write!(f, "Zip"),
            Format::Tar => write!(f, "Tar"),
            Format::TarGz => write!(f, "TarGz"),
            Format::TarBz2 => write!(f, "TarBz2"),
            Format::TarXz => write!(f, "TarXz"),
            Format::SevenZ => write!(f, "SevenZ"),
            Format::Rar => write!(f, "Rar"),
            Format::Unknown(s) => write!(f, "{}: unknown format", s),
        }
    }
}

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

    #[test]
    fn test_format() {
        assert!(find_format(None).is_err());
        if let Ok(f) = find_format(Some(OsStr::new("hoge.zip"))) {
            assert_eq!(f, Format::Zip);
            assert_eq!(f.to_string(), "Zip".to_string());
        }
        if let Ok(f) = find_format(Some(OsStr::new("hoge.unknown"))) {
            assert_eq!(f.to_string(), "hoge.unknown: unknown format".to_string());
        }
        if let Ok(f) = find_format(Some(OsStr::new("hoge.tar"))) {
            assert_eq!(f, Format::Tar);
            assert_eq!(f.to_string(), "Tar".to_string());
        }
        if let Ok(f) = find_format(Some(OsStr::new("hoge.rar"))) {
            assert_eq!(f, Format::Rar);
            assert_eq!(f.to_string(), "Rar".to_string());
        }
        if let Ok(f) = find_format(Some(OsStr::new("hoge.tar.gz"))) {
            assert_eq!(f, Format::TarGz);
            assert_eq!(f.to_string(), "TarGz".to_string());
        }
        if let Ok(f) = find_format(Some(OsStr::new("hoge.tar.bz2"))) {
            assert_eq!(f, Format::TarBz2);
            assert_eq!(f.to_string(), "TarBz2".to_string());
        }
        if let Ok(f) = find_format(Some(OsStr::new("hoge.tar.xz"))) {
            assert_eq!(f, Format::TarXz);
            assert_eq!(f.to_string(), "TarXz".to_string());
        }
        if let Ok(f) = find_format(Some(OsStr::new("hoge.7z"))) {
            assert_eq!(f, Format::SevenZ);
            assert_eq!(f.to_string(), "SevenZ".to_string());
        }
        if let Err(e) = find_format(None) {
            if let ToteError::NoArgumentsGiven = e {
                assert!(true);
            } else {
                assert!(false);
            }
        }
    }
}

1	use std::ffi::OsStr;
2	use std::fmt::Display;
3	use crate::cli::{ToteError, Result};
4
5	pub fn find_format(file_name: Option<&OsStr>) -> Result<Format> {	26✔
6	match file_name {	26✔
7	Some(file_name) => {	24✔
8	let name = file_name.to_str().unwrap().to_lowercase();	24✔
9	if name.ends_with(".tar.gz") \|\| name.ends_with(".tgz") {	24✔
10	return Ok(Format::TarGz);	3✔
11	} else if name.ends_with(".tar.bz2") \|\| name.ends_with(".tbz2") {	21✔
12	return Ok(Format::TarBz2);	3✔
13	} else if name.ends_with(".tar.xz") \|\| name.ends_with(".txz") {	18✔
14	return Ok(Format::TarXz);	3✔
15	} else if name.ends_with(".7z") {	15✔
16	return Ok(Format::SevenZ);	3✔
17	} else if name.ends_with(".tar") {	12✔
18	return Ok(Format::Tar);	3✔
19	} else if name.ends_with(".rar") {	9✔
20	return Ok(Format::Rar);	3✔
21	} else if name.ends_with(".zip") \|\| name.ends_with(".jar") \|\| name.ends_with(".war") \|\| name.ends_with(".ear") {	6✔
22	return Ok(Format::Zip);	3✔
23	} else {
24	return Ok(Format::Unknown(file_name.to_str().unwrap().to_string()));	3✔
25	}
26	}
27	None => Err(ToteError::NoArgumentsGiven),	2✔
28	}
29	}	26✔
30
31
32	#[derive(Debug, PartialEq)]
33	pub enum Format {
34	Zip,
35	Tar,
36	TarGz,
37	TarBz2,
38	TarXz,
39	SevenZ,
40	Rar,
41	Unknown(String),
42	}
43
44	impl Display for Format {
45	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {	9✔
46	match self {	9✔
47	Format::Zip => write!(f, "Zip"),	1✔
48	Format::Tar => write!(f, "Tar"),	1✔
49	Format::TarGz => write!(f, "TarGz"),	1✔
50	Format::TarBz2 => write!(f, "TarBz2"),	1✔
51	Format::TarXz => write!(f, "TarXz"),	1✔
52	Format::SevenZ => write!(f, "SevenZ"),	1✔
53	Format::Rar => write!(f, "Rar"),	1✔
54	Format::Unknown(s) => write!(f, "{}: unknown format", s),	2✔
55	}
56	}	9✔
57	}
58
59	#[cfg(test)]
60	mod tests {
61	use super::*;
62
63	#[test]
64	fn test_format() {	1✔
65	assert!(find_format(None).is_err());	1✔
66	if let Ok(f) = find_format(Some(OsStr::new("hoge.zip"))) {	1✔
67	assert_eq!(f, Format::Zip);	1✔
68	assert_eq!(f.to_string(), "Zip".to_string());	1✔
UNCOV 69	}	×
70	if let Ok(f) = find_format(Some(OsStr::new("hoge.unknown"))) {	1✔
71	assert_eq!(f.to_string(), "hoge.unknown: unknown format".to_string());	1✔
72	}	×
73	if let Ok(f) = find_format(Some(OsStr::new("hoge.tar"))) {	1✔
74	assert_eq!(f, Format::Tar);	1✔
75	assert_eq!(f.to_string(), "Tar".to_string());	1✔
UNCOV 76	}	×
77	if let Ok(f) = find_format(Some(OsStr::new("hoge.rar"))) {	1✔
78	assert_eq!(f, Format::Rar);	1✔
79	assert_eq!(f.to_string(), "Rar".to_string());	1✔
UNCOV 80	}	×
81	if let Ok(f) = find_format(Some(OsStr::new("hoge.tar.gz"))) {	1✔
82	assert_eq!(f, Format::TarGz);	1✔
83	assert_eq!(f.to_string(), "TarGz".to_string());	1✔
UNCOV 84	}	×
85	if let Ok(f) = find_format(Some(OsStr::new("hoge.tar.bz2"))) {	1✔
86	assert_eq!(f, Format::TarBz2);	1✔
87	assert_eq!(f.to_string(), "TarBz2".to_string());	1✔
UNCOV 88	}	×
89	if let Ok(f) = find_format(Some(OsStr::new("hoge.tar.xz"))) {	1✔
90	assert_eq!(f, Format::TarXz);	1✔
91	assert_eq!(f.to_string(), "TarXz".to_string());	1✔
UNCOV 92	}	×
93	if let Ok(f) = find_format(Some(OsStr::new("hoge.7z"))) {	1✔
94	assert_eq!(f, Format::SevenZ);	1✔
95	assert_eq!(f.to_string(), "SevenZ".to_string());	1✔
NEW 96	}	×
97	if let Err(e) = find_format(None) {	1✔
98	if let ToteError::NoArgumentsGiven = e {	1✔
99	assert!(true);	1✔
100	} else {
NEW 101	assert!(false);	×
102	}
UNCOV 103	}	×
104	}	1✔
105	}

tamada / totebag / 9167978950

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