feat: WebDAV support (#235)

src/utils/parser.rs

@@ -14,7 +14,9 @@ use tuirealm::utils::parser as tuirealm_parser;
 
 #[cfg(smb)]
 use crate::filetransfer::params::SmbParams;
-use crate::filetransfer::params::{AwsS3Params, GenericProtocolParams, ProtocolParams};
+use crate::filetransfer::params::{
+    AwsS3Params, GenericProtocolParams, ProtocolParams, WebDAVProtocolParams,
+};
 use crate::filetransfer::{FileTransferParams, FileTransferProtocol};
 #[cfg(not(test))] // NOTE: don't use configuration during tests
 use crate::system::config_client::ConfigClient;
@@ -43,6 +45,16 @@ static REMOTE_GENERIC_OPT_REGEX: Lazy<Regex> = lazy_regex!(
     r"(?:([^@]+)@)?(?:([^:]+))(?::((?:[0-9]{1,4}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5])(?:[0-9]{1,4}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5])))?(?::([^:]+))?"
 );
 
+/**
+ * Regex matches:
+ *  - group 1: Username
+ *  - group 2: Password
+ *  - group 2: Uri
+ *  - group 4: Some(path) | None
+ */
+static REMOTE_WEBDAV_OPT_REGEX: Lazy<Regex> =
+    lazy_regex!(r"(?:([^:]+):)(?:([^@]+)@)(?:([^/]+))(?:/(.+))?");
+
 /**
  * Regex matches:
  * - group 1: Bucket
@@ -145,14 +157,24 @@ pub fn parse_remote_opt(s: &str) -> Result<FileTransferParams, String> {
     #[cfg(test)] // NOTE: during test set protocol just to Sftp
     let default_protocol: FileTransferProtocol = FileTransferProtocol::Sftp;
     // Get protocol
-    let (protocol, s): (FileTransferProtocol, String) =
+    let (protocol, remote): (FileTransferProtocol, String) =
         parse_remote_opt_protocol(s, default_protocol)?;
     // Match against regex for protocol type
     match protocol {
-        FileTransferProtocol::AwsS3 => parse_s3_remote_opt(s.as_str()),
+        FileTransferProtocol::AwsS3 => parse_s3_remote_opt(remote.as_str()),
         #[cfg(smb)]
-        FileTransferProtocol::Smb => parse_smb_remote_opts(s.as_str()),
-        protocol => parse_generic_remote_opt(s.as_str(), protocol),
+        FileTransferProtocol::Smb => parse_smb_remote_opts(remote.as_str()),
+        FileTransferProtocol::WebDAV => {
+            // get the differnece between s and remote
+            let prefix = if s.starts_with("https") {
+                "https"
+            } else {
+                "http"
+            };
+
+            parse_webdav_remote_opt(remote.as_str(), prefix)
+        }
+        protocol => parse_generic_remote_opt(remote.as_str(), protocol),
     }
 }
 
@@ -232,6 +254,29 @@ fn parse_generic_remote_opt(
     }
 }
 
+fn parse_webdav_remote_opt(s: &str, prefix: &str) -> Result<FileTransferParams, String> {
+    match REMOTE_WEBDAV_OPT_REGEX.captures(s) {
+        Some(groups) => {
+            let username = groups.get(1).map(|x| x.as_str().to_string()).unwrap();
+            let password = groups.get(2).map(|x| x.as_str().to_string()).unwrap();
+            let uri = groups.get(3).map(|x| x.as_str().to_string()).unwrap();
+            let remote_path: Option<PathBuf> =
+                groups.get(4).map(|group| PathBuf::from(group.as_str()));
+
+            let params = ProtocolParams::WebDAV(WebDAVProtocolParams {
+                uri: format!("{}://{}", prefix, uri),
+                username,
+                password,
+            });
+            Ok(
+                FileTransferParams::new(FileTransferProtocol::WebDAV, params)
+                    .remote_path(remote_path),
+            )
+        }
+        None => Err(String::from("Bad remote host syntax!")),
+    }
+}
+
 /// Parse remote options for s3 protocol
 fn parse_s3_remote_opt(s: &str) -> Result<FileTransferParams, String> {
     match REMOTE_S3_OPT_REGEX.captures(s) {
@@ -553,6 +598,25 @@ mod tests {
         assert!(parse_remote_opt(&String::from("scp://172.26.104.1:650000")).is_err());
     }
 
+    #[test]
+    fn test_should_parse_webdav_opt() {
+        let result =
+            parse_remote_opt("https://omar:password@myserver:4445/myshare/dir/subdir").unwrap();
+
+        let params = result.params.webdav_params().unwrap();
+        assert_eq!(params.uri.as_str(), "https://myserver:4445");
+        assert_eq!(params.username.as_str(), "omar");
+        assert_eq!(params.password.as_str(), "password");
+
+        let result =
+            parse_remote_opt("http://omar:password@myserver:4445/myshare/dir/subdir").unwrap();
+
+        let params = result.params.webdav_params().unwrap();
+        assert_eq!(params.uri.as_str(), "http://myserver:4445");
+        assert_eq!(params.username.as_str(), "omar");
+        assert_eq!(params.password.as_str(), "password");
+    }
+
     #[test]
     fn parse_aws_s3_opt() {
         // Simple