1use crate::cli::hidden::HiddenKind;
2use crate::config::Config;
3use crate::error::MyResult;
4use crate::fs::entry::{Entry, EntryResult};
5use crate::fs::system::FileSystem;
6use crate::zip::manager::PasswordManager;
7use crate::zip::parent::ZipParent;
8use crate::zip::{pkzip, seven, tar};
9use std::path::{Component, Path, PathBuf};
10use walkdir::DirEntry;
11
12#[derive(Debug, PartialEq)]
13pub enum ZipKind {
14 PkZip,
15 SevenZ,
16 Tar(bool),
17}
18
19impl ZipKind {
20 pub fn from_path(path: &Path, zip_expand: bool) -> Option<Self> {
21 if zip_expand {
22 if let Some(ext) = path.extension() {
23 let ext = ext.to_ascii_lowercase();
24 if ext == "zip" || ext == "jar" {
25 return Some(Self::PkZip);
26 }
27 if ext == "7z" {
28 return Some(Self::SevenZ);
29 }
30 if ext == "tar" {
31 return Some(Self::Tar(false));
32 }
33 if ext == "gz" {
34 let path = path.with_extension("");
35 if let Some(ext) = path.extension() {
36 let ext = ext.to_ascii_lowercase();
37 if ext == "tar" {
38 return Some(Self::Tar(true));
39 }
40 }
41 }
42 }
43 }
44 None
45 }
46
47 pub fn walk_entries<F: Fn(EntryResult)>(
48 &self,
49 config: &Config,
50 dir_entry: &DirEntry,
51 zip_manager: &mut PasswordManager,
52 function: &F,
53 ) -> MyResult<()> {
54 let parent_path = PathBuf::from(dir_entry.path());
55 let parent_depth = dir_entry.depth();
56 match ZipParent::new(parent_path, parent_depth) {
57 Ok(zip_parent) => {
58 self.walk_inner(config, &zip_parent, zip_manager, &|entry| {
59 match entry {
60 Ok(entry) if filter_entry(config, entry) => function(Ok(entry)),
61 Ok(_) => (),
62 Err(error) => function(Err(error)),
63 }
64 })
65 }
66 Err(error) => {
67 function(Err(error));
68 Ok(())
69 }
70 }
71 }
72
73 fn walk_inner<F: Fn(EntryResult)>(
74 &self,
75 config: &Config,
76 zip_parent: &ZipParent,
77 zip_manager: &mut PasswordManager,
78 function: &F,
79 ) -> MyResult<()> {
80 match self {
81 Self::PkZip => pkzip::walk_entries(zip_parent, zip_manager, config.want_decrypt(), function),
82 Self::SevenZ => seven::walk_entries(zip_parent, zip_manager, config.want_decrypt(), function),
83 Self::Tar(want_gzip) => tar::walk_entries(zip_parent, *want_gzip, function),
84 }
85 }
86}
87
88fn filter_entry(config: &Config, entry: &dyn Entry) -> bool {
89 if let Some(max_depth) = config.max_depth() {
90 if entry.file_depth() > max_depth {
91 return false;
92 }
93 }
94 if let Some(inner_path) = entry.inner_path() {
95 match config.show_hidden() {
96 HiddenKind::None => {
97 return filter_hidden_path(inner_path);
98 }
99 HiddenKind::Files => {
100 if let Some(parent) = inner_path.parent() {
101 return filter_hidden_path(parent);
102 }
103 }
104 HiddenKind::Recurse => {
105 return true;
106 }
107 }
108 }
109 true
110}
111
112fn filter_hidden_path(path: &Path) -> bool {
113 path.components().all(filter_hidden_name)
114}
115
116fn filter_hidden_name(component: Component) -> bool {
117 match component {
118 Component::Normal(name) => !FileSystem::is_hidden_name(name.to_str()),
119 _ => true,
120 }
121}
122
123#[cfg(test)]
124mod tests {
125 use crate::zip::wrapper::ZipKind;
126 use std::path::PathBuf;
127
128 #[test]
129 fn test_file_has_zip_kind() {
130 assert_eq!(None, test_zip_kind("lower", false));
131 assert_eq!(None, test_zip_kind("UPPER", false));
132 assert_eq!(None, test_zip_kind("lower.zip", false));
133 assert_eq!(None, test_zip_kind("UPPER.ZIP", false));
134 assert_eq!(None, test_zip_kind("lower.jar", false));
135 assert_eq!(None, test_zip_kind("UPPER.JAR", false));
136 assert_eq!(None, test_zip_kind("lower.7z", false));
137 assert_eq!(None, test_zip_kind("UPPER.7Z", false));
138 assert_eq!(None, test_zip_kind("lower.tar", false));
139 assert_eq!(None, test_zip_kind("UPPER.TAR", false));
140 assert_eq!(None, test_zip_kind("lower.gz", false));
141 assert_eq!(None, test_zip_kind("UPPER.GZ", false));
142 assert_eq!(None, test_zip_kind("lower.zip.gz", false));
143 assert_eq!(None, test_zip_kind("UPPER.ZIP.GZ", false));
144 assert_eq!(None, test_zip_kind("lower.jar.gz", false));
145 assert_eq!(None, test_zip_kind("UPPER.JAR.GZ", false));
146 assert_eq!(None, test_zip_kind("lower.7z.gz", false));
147 assert_eq!(None, test_zip_kind("UPPER.7Z.GZ", false));
148 assert_eq!(None, test_zip_kind("lower.tar.gz", false));
149 assert_eq!(None, test_zip_kind("UPPER.TAR.GZ", false));
150 }
151
152 #[test]
153 fn test_archive_has_zip_kind() {
154 assert_eq!(None, test_zip_kind("lower", true));
155 assert_eq!(None, test_zip_kind("UPPER", true));
156 assert_eq!(Some(ZipKind::PkZip), test_zip_kind("lower.zip", true));
157 assert_eq!(Some(ZipKind::PkZip), test_zip_kind("UPPER.ZIP", true));
158 assert_eq!(Some(ZipKind::PkZip), test_zip_kind("lower.jar", true));
159 assert_eq!(Some(ZipKind::PkZip), test_zip_kind("UPPER.JAR", true));
160 assert_eq!(Some(ZipKind::SevenZ), test_zip_kind("lower.7z", true));
161 assert_eq!(Some(ZipKind::SevenZ), test_zip_kind("UPPER.7Z", true));
162 assert_eq!(Some(ZipKind::Tar(false)), test_zip_kind("lower.tar", true));
163 assert_eq!(Some(ZipKind::Tar(false)), test_zip_kind("UPPER.TAR", true));
164 assert_eq!(None, test_zip_kind("lower.gz", true));
165 assert_eq!(None, test_zip_kind("UPPER.GZ", true));
166 assert_eq!(None, test_zip_kind("lower.zip.gz", true));
167 assert_eq!(None, test_zip_kind("UPPER.ZIP.GZ", true));
168 assert_eq!(None, test_zip_kind("lower.jar.gz", true));
169 assert_eq!(None, test_zip_kind("UPPER.JAR.GZ", true));
170 assert_eq!(None, test_zip_kind("lower.7z.gz", true));
171 assert_eq!(None, test_zip_kind("UPPER.7Z.GZ", true));
172 assert_eq!(Some(ZipKind::Tar(true)), test_zip_kind("lower.tar.gz", true));
173 assert_eq!(Some(ZipKind::Tar(true)), test_zip_kind("UPPER.TAR.GZ", true));
174 }
175
176 fn test_zip_kind(path: &str, zip_expand: bool) -> Option<ZipKind> {
177 let path = PathBuf::from(path);
178 ZipKind::from_path(&path, zip_expand)
179 }
180}