feat: add ability to specify no remote for unfetcheable remote files

src/commands/data.rs

@@ -218,39 +218,38 @@ pub fn fetch_remote_data(config: KerblamTomlOptions) -> Result<()> {
     }
 
     // Send a message reminding the user that there are some unfetcheable remote files
-    let non_fetcheable: Vec<&RemoteFile> = remote_files
-        .iter()
-        .filter_map(|x| {
-            if x.path.to_str().unwrap() == "_" {
-                Some(x)
-            } else {
-                None
-            }
-        })
-        .collect();
+    let non_fetcheable: Vec<&RemoteFile> =
+        remote_files.iter().filter(|x| x.url.is_none()).collect();
 
     if !non_fetcheable.is_empty() {
         if non_fetcheable.len() <= 5 {
             let names: Vec<&str> = non_fetcheable
                 .into_iter()
                 .map(|x| x.to_owned().path.to_str().unwrap())
                 .collect();
-            eprintln!(
-                "There are {} remote files that Kerblam! cannot fetch: {}",
-                names.len(),
-                names.join(", ")
-            );
+            if names.len() == 1 {
+                eprintln!(
+                    "❓ There is one remote file that Kerblam! cannot fetch: {}",
+                    names.join(", ")
+                );
+            } else {
+                eprintln!(
+                    "❓ There are {} remote files that Kerblam! cannot fetch: {}",
+                    names.len(),
+                    names.join(", ")
+                );
+            }
         } else {
             eprintln!(
-                "There are {} remote files that Kerblam! cannot fetch",
+                "❓ There are {} remote files that Kerblam! cannot fetch",
                 non_fetcheable.len(),
             );
         }
     }
 
     let remote_files: Vec<RemoteFile> = remote_files
         .into_iter()
-        .filter(|x| x.path.to_str().unwrap() != "_")
+        .filter(|x| x.url.is_some())
         .collect();
 
     log::debug!("Fetching files: {:?}", remote_files);
@@ -291,7 +290,11 @@ pub fn fetch_remote_data(config: KerblamTomlOptions) -> Result<()> {
             continue;
         }
 
-        if let Err(msg) = fetch_remote_file(&client, file.url, file.path) {
+        if let Err(msg) = fetch_remote_file(
+            &client,
+            file.url.expect("This is expected due to above filtering"),
+            file.path,
+        ) {
             eprintln!("{}", msg);
             success = false;
         }

src/options.rs

@@ -36,7 +36,7 @@ pub struct DataOptions {
     pub paths: Option<DataPaths>,
     // Profiles are like HashMap<profile_name, HashMap<old_file_name, new_file_name>>
     pub profiles: Option<HashMap<String, HashMap<PathBuf, PathBuf>>>,
-    pub remote: Option<HashMap<Url, PathBuf>>,
+    pub remote: Option<HashMap<String, String>>,
 }
 
 #[derive(Debug, Deserialize, Clone)]
@@ -101,7 +101,7 @@ pub fn parse_kerblam_toml(toml_file: impl AsRef<Path>) -> Result<KerblamTomlOpti
 
 #[derive(Debug)]
 pub struct RemoteFile {
-    pub url: Url,
+    pub url: Option<Url>,
     pub path: PathBuf,
 }
 
@@ -111,9 +111,29 @@ impl From<RemoteFile> for PathBuf {
     }
 }
 
-impl From<RemoteFile> for Url {
-    fn from(val: RemoteFile) -> Self {
-        val.url
+impl TryFrom<RemoteFile> for Url {
+    fn try_from(value: RemoteFile) -> Result<Self> {
+        value
+            .url
+            .ok_or(anyhow!("Cannot convert to URL - it's missing"))
+    }
+
+    type Error = anyhow::Error;
+}
+
+impl RemoteFile {
+    fn from_string_pair(value: (&str, &str), base_directory: PathBuf) -> Result<Self> {
+        if value.0 == "_" {
+            Ok(RemoteFile {
+                url: None,
+                path: base_directory.join(value.1),
+            })
+        } else {
+            Ok(RemoteFile {
+                url: Some(Url::try_from(value.0)?),
+                path: base_directory.join(value.1),
+            })
+        }
     }
 }
 
@@ -262,9 +282,14 @@ impl KerblamTomlOptions {
             .and_then(|x| x.remote)
             .map(|y| {
                 y.iter()
-                    .map(|pairs| RemoteFile {
-                        url: pairs.0.clone(),
-                        path: root_data_dir.join(pairs.1),
+                    // TODO: This fails horribly if the URL is not valid
+                    // due to the .unwrap here. Pretty print a nice error?
+                    .map(|(a, b)| {
+                        RemoteFile::from_string_pair(
+                            (a.as_str(), b.as_str()),
+                            self.input_data_dir(),
+                        )
+                        .unwrap()
                     })
                     .collect()
             })