Tests pass.

src/commands/cp.rs

@@ -35,7 +35,6 @@ pub fn cp(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let mut source = PathBuf::from(args.shell_manager.path());
     let mut destination = PathBuf::from(args.shell_manager.path());
 
-    let mut dst = String::new();
 
     match args
         .nth(0)
@@ -55,26 +54,128 @@ pub fn cp(args: CommandArgs) -> Result<OutputStream, ShellError> {
         .as_str()
     {
         file => {
-            dst.push_str(file);
             destination.push(file);
         }
     }
 
+    let (sources, destinations) = (
+        glob::glob(&source.to_string_lossy()),
+        glob::glob(&destination.to_string_lossy()),
+    );
+
+    if sources.is_err() || destinations.is_err() {
+        return Err(ShellError::string("Invalid pattern."));
+    }
+
+    let (sources, destinations): (Vec<_>, Vec<_>) =
+        (sources.unwrap().collect(), destinations.unwrap().collect());
+
+    if sources.len() == 1 {
+        if let Ok(entry) = &sources[0] {
+            if entry.is_file() {
+                if destinations.len() == 1 {
+                    if let Ok(dst) = &destinations[0] {
+                        if dst.is_file() {
+                            std::fs::copy(entry, dst);
+                        }
+
+                        if dst.is_dir() {
+                            destination.push(entry.file_name().unwrap());
+                            std::fs::copy(entry, destination);
+                        }
+                    }
+                } else if destinations.is_empty() {
+                    if destination.is_dir() {
+                        destination.push(entry.file_name().unwrap());
+                        std::fs::copy(entry, destination);
+                    } else {
+                        std::fs::copy(entry, destination);
+                    }
+                }
+            }
+
+            if entry.is_dir() {
+                if destinations.len() == 1 {
+                    if let Ok(dst) = &destinations[0] {
+                        if dst.is_dir() && !args.has("recursive") {
+                            return Err(ShellError::string(&format!(
+                                "{:?} is a directory (not copied)",
+                                entry.to_string_lossy()
+                            )));
+                        }
+
+
+                        if dst.is_dir() && args.has("recursive") {
+                            let entries = std::fs::read_dir(&entry);
+
+                            let entries = match entries {
+                                Err(e) => {
+                                    if let Some(s) = args.nth(0) {
+                                        return Err(ShellError::labeled_error(
+                                            e.to_string(),
+                                            e.to_string(),
+                                            s.span(),
+                                        ));
+                                    } else {
+                                        return Err(ShellError::labeled_error(
+                                            e.to_string(),
+                                            e.to_string(),
+                                            args.call_info.name_span,
+                                        ));
+                                    }
+                                }
+                                Ok(o) => o,
+                            };
+
+                            let mut x = dst.clone();
+
+                            //x.pop();
+                            x.push(entry.file_name().unwrap());
+
+
+                            std::fs::create_dir(&x).expect("can not create directory");
+
+                            for entry in entries {
+                                let entry = entry?;
+                                let file_path = entry.path();
+                                let file_name = file_path.file_name().unwrap();
+
+                                let mut d = PathBuf::new();
+                                d.push(&x);
+                                d.push(file_name);
+
+                                std::fs::copy(entry.path(), d);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    /*
     if destination.is_dir() {
         if source.is_file() {
             let file_name = source.file_name().expect("");
             let file_name = file_name.to_str().expect("");
             destination.push(Path::new(file_name));
+
+            match std::fs::copy(source, destination) {
+                Err(_error) => return Err(ShellError::string("can not copy file")),
+                Ok(_) => return Ok(OutputStream::empty()),
+            }
         } else if source.is_dir() {
-            return Err(ShellError::string(&format!(
-                "{:?} is a directory (not copied)",
-                source.to_string_lossy()
-            )));
+
+                return Err(ShellError::string(&format!(
+                    "{:?} is a directory (not copied)",
+                    source.to_string_lossy()
+                )));
+
         }
     }
 
     match std::fs::copy(source, destination) {
         Err(_error) => Err(ShellError::string("can not copy file")),
         Ok(_) => Ok(OutputStream::empty()),
-    }
+    }*/
+    Ok(OutputStream::empty())
 }