Find command now supports also directories

src/filetransfer/ftp_transfer.rs

@@ -1105,11 +1105,14 @@ mod tests {
         // Pwd
         assert_eq!(client.pwd().ok().unwrap(), PathBuf::from("/"));
         // Search for file (let's search for pop3-*.png); there should be 2
-        let search_res: Vec<FsFile> = client.find("pop3-*.png").ok().unwrap();
+        let search_res: Vec<FsEntry> = client.find("pop3-*.png").ok().unwrap();
         assert_eq!(search_res.len(), 2);
         // verify names
-        assert_eq!(search_res[0].name.as_str(), "pop3-browser.png");
+        assert_eq!(search_res[0].get_name(), "pop3-browser.png");
-        assert_eq!(search_res[1].name.as_str(), "pop3-console-client.png");
+        assert_eq!(search_res[1].get_name(), "pop3-console-client.png");
+        // Search directory
+        let search_res: Vec<FsEntry> = client.find("pub").ok().unwrap();
+        assert_eq!(search_res.len(), 1);
         // Disconnect
         assert!(client.disconnect().is_ok());
         // Verify err

src/filetransfer/mod.rs

@@ -237,7 +237,7 @@ pub trait FileTransfer {
     ///
     /// Find files from current directory (in all subdirectories) whose name matches the provided search
     /// Search supports wildcards ('?', '*')
-    fn find(&mut self, search: &str) -> Result<Vec<FsFile>, FileTransferError> {
+    fn find(&mut self, search: &str) -> Result<Vec<FsEntry>, FileTransferError> {
         match self.is_connected() {
             true => {
                 // Starting from current directory, iter dir
@@ -261,8 +261,8 @@ pub trait FileTransfer {
         &mut self,
         dir: &Path,
         filter: &WildMatch,
-    ) -> Result<Vec<FsFile>, FileTransferError> {
+    ) -> Result<Vec<FsEntry>, FileTransferError> {
-        let mut drained: Vec<FsFile> = Vec::new();
+        let mut drained: Vec<FsEntry> = Vec::new();
         // Scan directory
         match self.list_dir(dir) {
             Ok(entries) => {
@@ -275,6 +275,10 @@ pub trait FileTransfer {
                 for entry in entries.iter() {
                     match entry {
                         FsEntry::Directory(dir) => {
+                            // If directory name, matches wildcard, push it to drained
+                            if filter.is_match(dir.name.as_str()) {
+                                drained.push(FsEntry::Directory(dir.clone()));
+                            }
                             match self.iter_search(dir.abs_path.as_path(), filter) {
                                 Ok(mut filtered) => drained.append(&mut filtered),
                                 Err(err) => return Err(err),
@@ -282,7 +286,7 @@ pub trait FileTransfer {
                         }
                         FsEntry::File(file) => {
                             if filter.is_match(file.name.as_str()) {
-                                drained.push(file.clone());
+                                drained.push(FsEntry::File(file.clone()));
                             }
                         }
                     }

src/filetransfer/scp_transfer.rs

@@ -1070,11 +1070,14 @@ mod tests {
         // Check session and scp
         assert!(client.session.is_some());
         // Search for file (let's search for pop3-*.png); there should be 2
-        let search_res: Vec<FsFile> = client.find("pop3-*.png").ok().unwrap();
+        let search_res: Vec<FsEntry> = client.find("pop3-*.png").ok().unwrap();
         assert_eq!(search_res.len(), 2);
         // verify names
-        assert_eq!(search_res[0].name.as_str(), "pop3-browser.png");
+        assert_eq!(search_res[0].get_name(), "pop3-browser.png");
-        assert_eq!(search_res[1].name.as_str(), "pop3-console-client.png");
+        assert_eq!(search_res[1].get_name(), "pop3-console-client.png");
+        // Search directory
+        let search_res: Vec<FsEntry> = client.find("pub").ok().unwrap();
+        assert_eq!(search_res.len(), 1);
         // Disconnect
         assert!(client.disconnect().is_ok());
         // Verify err

src/filetransfer/sftp_transfer.rs

@@ -965,11 +965,14 @@ mod tests {
         // Check session and scp
         assert!(client.session.is_some());
         // Search for file (let's search for pop3-*.png); there should be 2
-        let search_res: Vec<FsFile> = client.find("pop3-*.png").ok().unwrap();
+        let search_res: Vec<FsEntry> = client.find("pop3-*.png").ok().unwrap();
         assert_eq!(search_res.len(), 2);
         // verify names
-        assert_eq!(search_res[0].name.as_str(), "pop3-browser.png");
+        assert_eq!(search_res[0].get_name(), "pop3-browser.png");
-        assert_eq!(search_res[1].name.as_str(), "pop3-console-client.png");
+        assert_eq!(search_res[1].get_name(), "pop3-console-client.png");
+        // Search directory
+        let search_res: Vec<FsEntry> = client.find("pub").ok().unwrap();
+        assert_eq!(search_res.len(), 1);
         // Disconnect
         assert!(client.disconnect().is_ok());
         // Verify err

src/host/mod.rs

@@ -547,7 +547,7 @@ impl Localhost {
     ///
     /// Find files matching `search` on localhost starting from current directory. Search supports recursive search of course.
     /// The `search` argument supports wilcards ('*', '?')
-    pub fn find(&self, search: &str) -> Result<Vec<FsFile>, HostError> {
+    pub fn find(&self, search: &str) -> Result<Vec<FsEntry>, HostError> {
         self.iter_search(self.wrkdir.as_path(), &WildMatch::new(search))
     }
 
@@ -558,9 +558,9 @@ impl Localhost {
     /// Recursive call for `find` method.
     /// Search in current directory for files which match `filter`.
     /// If a directory is found in current directory, `iter_search` will be called using that dir as argument.
-    fn iter_search(&self, dir: &Path, filter: &WildMatch) -> Result<Vec<FsFile>, HostError> {
+    fn iter_search(&self, dir: &Path, filter: &WildMatch) -> Result<Vec<FsEntry>, HostError> {
         // Scan directory
-        let mut drained: Vec<FsFile> = Vec::new();
+        let mut drained: Vec<FsEntry> = Vec::new();
         match self.scan_dir(dir) {
             Err(err) => Err(err),
             Ok(entries) => {
@@ -574,6 +574,10 @@ impl Localhost {
                 for entry in entries.iter() {
                     match entry {
                         FsEntry::Directory(dir) => {
+                            // If directory matches; push directory to drained
+                            if filter.is_match(dir.name.as_str()) {
+                                drained.push(FsEntry::Directory(dir.clone()));
+                            }
                             match self.iter_search(dir.abs_path.as_path(), filter) {
                                 Ok(mut filtered) => drained.append(&mut filtered),
                                 Err(err) => return Err(err),
@@ -581,7 +585,7 @@ impl Localhost {
                         }
                         FsEntry::File(file) => {
                             if filter.is_match(file.name.as_str()) {
-                                drained.push(file.clone());
+                                drained.push(FsEntry::File(file.clone()));
                             }
                         }
                     }
@@ -1043,15 +1047,21 @@ mod tests {
         assert!(make_sample_file(subdir.as_path(), "omar.txt").is_ok());
         assert!(make_sample_file(subdir.as_path(), "errors.txt").is_ok());
         assert!(make_sample_file(subdir.as_path(), "screenshot.png").is_ok());
+        assert!(make_sample_file(subdir.as_path(), "examples.csv").is_ok());
         let host: Localhost = Localhost::new(PathBuf::from(dir_path)).ok().unwrap();
         // Find txt files
-        let result: Vec<FsFile> = host.find("*.txt").ok().unwrap();
+        let result: Vec<FsEntry> = host.find("*.txt").ok().unwrap();
         // There should be 3 entries
         assert_eq!(result.len(), 3);
         // Check names (they should be sorted alphabetically already; NOTE: examples/ comes before pippo.txt)
-        assert_eq!(result[0].name.as_str(), "errors.txt");
+        assert_eq!(result[0].get_name(), "errors.txt");
-        assert_eq!(result[1].name.as_str(), "omar.txt");
+        assert_eq!(result[1].get_name(), "omar.txt");
-        assert_eq!(result[2].name.as_str(), "pippo.txt");
+        assert_eq!(result[2].get_name(), "pippo.txt");
+        // Search for directory
+        let result: Vec<FsEntry> = host.find("examples*").ok().unwrap();
+        assert_eq!(result.len(), 2);
+        assert_eq!(result[0].get_name(), "examples");
+        assert_eq!(result[1].get_name(), "examples.csv");
     }
 
     #[test]