Add helpful error messages

src/args.rs

···
                     if val.contains("/") {
                         let entries: Vec<_> = val.split("/").collect();
                         if entries.len() != 2 {
+                            println!("Invalid argument: `{}` is malformed", val);
                             return Err(());
                         }
                         handle = Some(entries[0][1..].to_string());

src/did.rs

···
     // create a txt resolver
     let resolver = match Resolver::new(ResolverConfig::default(), ResolverOpts::default()) {
         Ok(val) => val,
-        Err(_) => return Err(()),
+        Err(_) => {
+            println!("            Couldn't create a DNS resolver");
+            return Err(());
+        }
     };
 
     // resolve _atproto.handle to a TXT record
     let txt_res = match resolver.txt_lookup("_atproto.".to_owned() + &handle) {
         Ok(val) => val,
-        Err(_) => return Err(()), // collect all entries and convert to strings
+        Err(_) => {
+            println!("            Couldn't resolve to a TXT record");
+            return Err(());
+        } // collect all entries and convert to strings
     }
     .into_iter()
     .map(|x| x.to_string())
···
     // only 1 did= can exist
     // https://atproto.com/specs/handle#:~:text=If%20multiple%20valid%20records%20with%20different%20DIDs%20are%20present,%20resolution%20should%20fail.
     if did_res.len() != 1 {
+        println!("            Found too many DIDs for this handle");
         return Err(());
     }
 
···
 }
 
 fn get_http_did(handle: &String) -> Result<String, ()> {
-    println!("        Trying https for https://{}/.well-known/atproto-did", handle);
+    println!(
+        "        Trying https for https://{}/.well-known/atproto-did",
+        handle
+    );
     let res =
         match reqwest::blocking::get("https://".to_owned() + handle + "/.well-known/atproto-did") {
             Ok(val) => val,
-            Err(_) => return Err(()),
+            Err(_) => {
+                println!("            GET request failed");
+                return Err(());
+            }
         };
 
     // as per spec, non 2xx code means failure
     if !res.status().is_success() {
+        println!(
+            "            Got non 2xx status code: {}",
+            res.status().as_str()
+        );
         return Err(());
     }
 
     let did_unparsed = match res.text() {
         Ok(val) => val,
-        Err(_) => return Err(()),
+        Err(_) => {
+            println!("            Missing or malformed body response");
+            return Err(());
+        }
     };
 
     let did = did_unparsed.trim();
 
     if !did.starts_with("did:") {
+        println!("            Did not find a DID");
         return Err(());
     };
     return Ok(String::from(did));
···
 fn parse_doc(did: String, text: String) -> Result<DidDoc, ()> {
     let text_json = match json::parse(&text) {
         Ok(val) => val,
-        Err(_) => return Err(()),
+        Err(_) => {
+            println!("        Malformed DID document");
+            return Err(());
+        }
     };
 
     for service in text_json["service"].members() {
···
         }
     }
 
+    println!("        Missing fields from DID document");
     return Err(());
 }
 
 fn get_plc_doc(plc: &str) -> Result<DidDoc, ()> {
     let res = match reqwest::blocking::get("https://plc.directory/did:plc:".to_owned() + plc) {
         Ok(val) => val,
-        Err(_) => return Err(()),
+        Err(_) => {
+            println!("        GET request failed");
+            return Err(());
+        }
     };
 
     if !res.status().is_success() {
+        println!("        Got non 2xx status code: {}", res.status().as_str());
+
         return Err(());
     }
 
···
         "did:plc:".to_owned() + plc,
         match res.text() {
             Ok(val) => val,
-            Err(_) => return Err(()),
+            Err(_) => {
+                println!("        Missing or malformed body response");
+                return Err(());
+            }
         },
     );
 }
···
 fn get_web_doc(web: &str) -> Result<DidDoc, ()> {
     let res = match reqwest::blocking::get("https://".to_owned() + web + "/.well-known/did.json") {
         Ok(val) => val,
-        Err(_) => return Err(()),
+        Err(_) => {
+            println!("        GET request failed");
+            return Err(());
+        }
     };
 
     if !res.status().is_success() {
+        println!("        Got non 2xx status code: {}", res.status().as_str());
         return Err(());
     }
 
···
         "did:web:".to_owned() + web,
         match res.text() {
             Ok(val) => val,
-            Err(_) => return Err(()),
+            Err(_) => {
+                println!("        Missing or malformed body response");
+                return Err(());
+            }
         },
     );
 }
···
         if let Ok(did) = get_http_did(&handle) {
             did
         } else {
+            println!("        Could not get a DID");
             return Err(());
         }
     };
···
     } else if did.starts_with("did:web:") {
         get_web_doc(&did[8..])
     } else {
+        println!("        Could not get a DID document");
         Err(())
     };
 

src/main.rs

···
     // load configuration
     let config = match args::load_config() {
         Ok(res) => res,
-        Err(_) => {
-            // q
-            return Err(());
-        }
+        Err(_) => return Err(()),
     };
 
     // resolve handle to did
     println!("Resolving {}", config.handle);
     let did_doc = match did::get_did(config.handle) {
         Ok(res) => res,
-        Err(_) => {
-            // q
-            return Err(());
-        }
+        Err(_) => return Err(()),
     };
     // resolve did+repoName to knotserver