upload: strip source dir prefix from key and minor refactor

hashmap key no longer includes the source directory from the cli arguments
source dir `./dist`:
./dist/index.html => index.html
./dist/assets/cat.jpg => cat.jpg
etc

refactor things and log the tree state in main bc its debugging info

upload/src/main.rs

···
 use clap::{ArgAction, Parser};
 use std::path::PathBuf;
 
+use crate::utils::url_to_rkey;
+
 mod sitemap;
 mod utils;
 
···
   );
 
   // get local site info
-  let sitemap = sitemap::local_sitemap(config.dir, config.all_files, config.git_ignore);
+  let sitemap =
+    sitemap::local_sitemap(config.dir, config.all_files, config.git_ignore).or_else(|err| {
+      println!("Error: {}", err);
+      Err(())
+    })?;
+
+  println!(
+    "{}",
+    sitemap
+      .iter()
+      .map(|(k, v)| {
+        let rkey = url_to_rkey(k.to_string());
+        if let Some(rkey) = rkey {
+          return format!(
+            "\t\t\t\t\t\t\t\t\t\t\t\t{:?}\r\t\t\t\t\t\t\t\t{}\r  - {}",
+            v.blob, v.mime_type, rkey
+          );
+        } else {
+          return String::new();
+        }
+      })
+      .collect::<Vec<_>>()
+      .join("\n")
+  );
 
   // create session
 

upload/src/sitemap.rs

···
 use ignore::WalkBuilder;
+use mime_guess::mime;
 use std::{collections::HashMap, error::Error, fmt, path::PathBuf};
 
 pub type Sitemap = HashMap<String, SitemapNode>;
···
 pub enum SitemapErr {
   IoErr(std::io::Error),
   IgnoreErr(ignore::Error),
+  StripPrefixErr(std::path::StripPrefixError),
+  NotUTF8Path,
 }
 
 impl From<std::io::Error> for SitemapErr {
···
   }
 }
 
+impl From<std::path::StripPrefixError> for SitemapErr {
+  fn from(value: std::path::StripPrefixError) -> Self {
+    SitemapErr::StripPrefixErr(value)
+  }
+}
+
 impl Error for SitemapErr {}
 
 impl fmt::Display for SitemapErr {
···
     match self {
       SitemapErr::IoErr(err) => write!(f, "IO Error: {}", err),
       SitemapErr::IgnoreErr(err) => write!(f, "Ignore Error: {}", err),
+      SitemapErr::StripPrefixErr(err) => write!(f, "File Path Error: {}", err),
+      SitemapErr::NotUTF8Path => write!(f, "Found a path that was not UTF-8"),
     }
   }
 }
···
   include_dotfiles: bool,
   use_gitignore: bool,
 ) -> Result<Sitemap, SitemapErr> {
-  let res = WalkBuilder::new(dir)
+  let prefix = dir.canonicalize()?;
+
+  let mut res = HashMap::new();
+  for file in WalkBuilder::new(dir)
     .hidden(!include_dotfiles)
     .git_ignore(use_gitignore)
     .git_exclude(use_gitignore)
     .git_global(use_gitignore)
     .follow_links(true)
     .build()
-    .filter_map(|x| {
-      let x = x
-        .or_else(|err| {
-          println!("Warning: {} ", err);
-          Err(())
-        })
-        .ok()?;
+  {
+    let file = file?;
 
-      let metadata = x
-        .metadata()
-        .or_else(|err| {
-          println!("Warning on file {}:\n{} ", x.path().display(), err);
-          Err(())
-        })
-        .ok()?;
-
-      if !metadata.is_file() {
-        return None;
-      };
+    let metadata = file.metadata()?;
 
-      let key = x.path().to_str()?;
-      let key = String::from(key);
-
-      let mime = mime_guess::from_path(&key);
-      let mime = mime.first()?;
-      let mime = mime.essence_str();
+    if !metadata.is_file() {
+      continue;
+    };
 
-      Some((
-        key,
-        SitemapNode {
-          mime_type: String::from(mime),
-          blob: BlobRef::Local(x.path().to_owned()),
-        },
-      ))
-    })
-    .collect::<HashMap<_, _>>();
+    // find the path of the files relative to the source directory
+    // source dir `./dist`:
+    //    ./dist/index.html => index.html
+    //    ./dist/assets/cat.jpg => cat.jpg
+    // etc
+    let key = file.path().canonicalize()?;
+    let key = key.strip_prefix(&prefix)?;
+    let key = String::from(key.to_str().ok_or_else(|| SitemapErr::NotUTF8Path)?);
 
-  println!(
-    "  - {}",
-    res
-      .iter()
-      .map(|(k, v)| format!("{}: {:?}", k, v))
-      .collect::<Vec<_>>()
-      .join("\n  - ")
-  );
+    let mime = mime_guess::from_path(&key);
+    let mime = mime.first().unwrap_or(mime::APPLICATION_OCTET_STREAM);
+    let mime = mime.essence_str();
 
+    res.insert(
+      key,
+      SitemapNode {
+        mime_type: String::from(mime),
+        blob: BlobRef::Local(file.path().to_owned()),
+      },
+    );
+  }
   Ok(res)
 }