Move args and did resolution to seperate files

src/args.rs

···
+fn help() {
+    println!(
+        "Help: tangled-on-commit
+Listen for commits on a specified repository and execute a shell command.
+
+CLI Arguments:
+    `tangled-on-commit (-h | --help)`
+            Displays this message
+
+    `tangled-on-commit`
+            No specified handle, repo, or command. Falls back to config/env
+
+    `tangled-on-commit SHELL`
+            Uses config/env for handle and repo
+
+    `tangled-on-commit @HANDLE SHELL`
+            Uses config/env for repo
+
+    `tangled-on-commit REPO SHELL`
+            Uses config/env for handle
+
+    `tangled-on-commit @HANDLE/REPO SHELL`
+    `tangled-on-commit HANDLE REPO SHELL`
+            No config/env
+
+JSON:
+    Loads the file `tangled-on-commit.json` from cwd if it exists.
+    Reads keys \"handle\", \"repo_name\", and \"shell\".
+    Unknown keys are ignored and any key can be ommitted
+    JSON is used if the arguments aren't passed to the CLI
+
+Env:
+    Loads the environment variables `TANGLED_ON_COMMIT_HANDLE` and `TANGLED_ON_COMMIT_REPO_NAME`
+    Shell cannot be set by environment variables.
+    Env variables are used if relevant keys are ommitted an arguments aren't passed to the CLI.
+"
+    )
+}
+
+#[derive(Debug)]
+pub struct Config {
+    pub handle: String,
+    pub repo_name: String,
+    pub shell: String,
+}
+
+pub fn load_config() -> Result<Config, ()> {
+    // load config from cli args if present
+    // if omitted, fallback to a local `tangled-on-commit.json` file
+    // if key omitted or file not found, fall back to env
+    // if env omitted, error out and quit
+    // note: shell is not loaded from env (to avoid the user unknowingly executing scripts)
+
+    // if any args are `-h` || `--help` display help and quit
+    for arg in std::env::args() {
+        if arg == "-h" || arg == "--help" {
+            help();
+            return Err(());
+        }
+    }
+
+    // if 0 args are passed, skip
+    // if 1 arg is passed, its the shell command
+    // if 2 args are passed:
+    //   if arg 1 starts in @ its a handle
+    //     if it contains a / the contents after the slash is the reponame
+    //   else its the reponame
+    //   arg 2 is always the shell command
+    // if 3 args are passed its handle repo shell
+    // if more args are passed its an error
+
+    let mut handle: Option<String> = None;
+    let mut repo_name: Option<String> = None;
+    let mut shell: Option<String> = None;
+    match std::env::args().collect::<Vec<_>>().len() {
+        // 0 args (std env args includes this script)
+        1 => {}
+        2 => {
+            shell = Some(
+                std::env::args()
+                    .last()
+                    .expect("Invalid state: 2 `Some` std::env::args() but found no Some values"),
+            )
+        }
+        3 => {
+            // load args and consume first
+            let mut args = std::env::args();
+            args.next();
+
+            if let Some(val) = args.next() {
+                if val.starts_with("@") {
+                    if val.contains("/") {
+                        let entries: Vec<_> = val.split("/").collect();
+                        if entries.len() != 2 {
+                            return Err(());
+                        }
+                        handle = Some(entries[0][1..].to_string());
+                        repo_name = Some(entries[1].to_string());
+                    } else {
+                        handle = Some(val[1..].to_string());
+                    }
+                } else {
+                    repo_name = Some(val)
+                };
+            }
+            shell = Some(
+                args.next()
+                    .expect("Invalid state: 3 `Some` std::env::args() but only found 2"),
+            );
+        }
+        4 => {
+            // load args and consume first
+            let mut args = std::env::args();
+            args.next();
+
+            handle = Some(
+                args.next()
+                    .expect("Invalid state: 4 `Some` std::env::args() but only found 1"),
+            );
+            repo_name = Some(
+                args.next()
+                    .expect("Invalid state: 4 `Some` std::env::args() but only found 2"),
+            );
+            shell = Some(
+                args.next()
+                    .expect("Invalid state: 4 `Some` std::env::args() but only found 3"),
+            );
+        }
+        _ => {
+            // err
+        }
+    }
+
+    if let Some(ref handle) = handle
+        && let Some(ref repo_name) = repo_name
+        && let Some(ref shell) = shell
+    {
+        return Ok(Config {
+            handle: handle.to_string(),
+            repo_name: repo_name.to_string(),
+            shell: shell.to_string(),
+        });
+    }
+
+    // now load config
+    if let Ok(file) = std::fs::read_to_string("./tangled-on-commit.json") {
+        if let Ok(parsed) = json::parse(&file) {
+            if handle.is_none()
+                && let Some(json_handle) = parsed["handle"].as_str()
+            {
+                handle = Some(String::from(json_handle))
+            }
+            if repo_name.is_none()
+                && let Some(json_repo_name) = parsed["repo_name"].as_str()
+            {
+                repo_name = Some(String::from(json_repo_name))
+            }
+            if shell.is_none()
+                && let Some(json_shell) = parsed["shell"].as_str()
+            {
+                shell = Some(String::from(json_shell))
+            }
+        }
+    }
+
+    if let Some(ref handle) = handle
+        && let Some(ref repo_name) = repo_name
+        && let Some(ref shell) = shell
+    {
+        return Ok(Config {
+            handle: handle.to_string(),
+            repo_name: repo_name.to_string(),
+            shell: shell.to_string(),
+        });
+    }
+
+    // now load from env
+    if handle.is_none()
+        && let Ok(env_handle) = std::env::var("TANGLED_ON_COMMIT_HANDLE")
+    {
+        handle = Some(String::from(env_handle))
+    }
+    if repo_name.is_none()
+        && let Ok(env_repo_name) = std::env::var("TANGLED_ON_COMMIT_REPO_NAME")
+    {
+        repo_name = Some(String::from(env_repo_name))
+    }
+
+    if let Some(ref handle) = handle
+        && let Some(ref repo_name) = repo_name
+        && let Some(ref shell) = shell
+    {
+        return Ok(Config {
+            handle: handle.to_string(),
+            repo_name: repo_name.to_string(),
+            shell: shell.to_string(),
+        });
+    }
+
+    // couldnt resolve every value
+    // print an error and quit
+    println!("Unable to find a value for every setting. Missing values for:");
+    if handle.is_none() {
+        println!("- handle");
+    }
+    if repo_name.is_none() {
+        println!("- repo_name");
+    }
+    if shell.is_none() {
+        println!("- shell");
+    }
+    println!("\nRun `tangled-on-commit --help` to see the help message");
+    return Err(());
+}

src/did.rs

···
+use trust_dns_resolver::Resolver;
+use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
+
+#[derive(Debug)]
+pub struct DidDoc {
+    pub did: String,
+}
+
+fn get_txt_did(handle: &String) -> Result<String, ()> {
+    // create a txt resolver
+    let resolver = match Resolver::new(ResolverConfig::default(), ResolverOpts::default()) {
+        Ok(val) => val,
+        Err(_) => 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
+    }
+    .into_iter()
+    .map(|x| x.to_string())
+    .collect::<Vec<_>>();
+
+    // filter entries which do not start with `did=`
+    let did_res = txt_res
+        .clone()
+        .extract_if(.., |x| x.starts_with("did="))
+        .collect::<Vec<_>>();
+    // 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 {
+        return Err(());
+    }
+    let did = did_res[0].clone();
+
+    return Ok(did.clone());
+}
+
+fn get_http_did(handle: &String) -> Result<String, ()> {
+    return Ok(String::new());
+}
+
+pub fn get_did(handle: String) -> Result<DidDoc, ()> {
+    let did = if let Ok(did) = get_txt_did(&handle) {
+        did
+    } else {
+        if let Ok(did) = get_http_did(&handle) {
+            did
+        } else {
+            return Err(());
+        }
+    };
+
+    return Ok(DidDoc { did });
+}

src/main.rs

···
-use trust_dns_resolver::Resolver;
-use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
-
-fn help() {
-    println!(
-        "Help: tangled-on-commit
-Listen for commits on a specified repository and execute a shell command.
-
-CLI Arguments:
-    `tangled-on-commit (-h | --help)`
-            Displays this message
-
-    `tangled-on-commit`
-            No specified handle, repo, or command. Falls back to config/env
-
-    `tangled-on-commit SHELL`
-            Uses config/env for handle and repo
-
-    `tangled-on-commit @HANDLE SHELL`
-            Uses config/env for repo
-
-    `tangled-on-commit REPO SHELL`
-            Uses config/env for handle
-
-    `tangled-on-commit @HANDLE/REPO SHELL`
-    `tangled-on-commit HANDLE REPO SHELL`
-            No config/env
-
-JSON:
-    Loads the file `tangled-on-commit.json` from cwd if it exists.
-    Reads keys \"handle\", \"repo_name\", and \"shell\".
-    Unknown keys are ignored and any key can be ommitted
-    JSON is used if the arguments aren't passed to the CLI
-
-Env:
-    Loads the environment variables `TANGLED_ON_COMMIT_HANDLE` and `TANGLED_ON_COMMIT_REPO_NAME`
-    Shell cannot be set by environment variables.
-    Env variables are used if relevant keys are ommitted an arguments aren't passed to the CLI.
-"
-    )
-}
-
-#[derive(Debug)]
-struct Config {
-    handle: String,
-    repo_name: String,
-    shell: String,
-}
-
-fn load_config() -> Result<Config, ()> {
-    // load config from cli args if present
-    // if omitted, fallback to a local `tangled-on-commit.json` file
-    // if key omitted or file not found, fall back to env
-    // if env omitted, error out and quit
-    // note: shell is not loaded from env (to avoid the user unknowingly executing scripts)
-
-    // if any args are `-h` || `--help` display help and quit
-    for arg in std::env::args() {
-        if arg == "-h" || arg == "--help" {
-            help();
-            return Err(());
-        }
-    }
-
-    // if 0 args are passed, skip
-    // if 1 arg is passed, its the shell command
-    // if 2 args are passed:
-    //   if arg 1 starts in @ its a handle
-    //     if it contains a / the contents after the slash is the reponame
-    //   else its the reponame
-    //   arg 2 is always the shell command
-    // if 3 args are passed its handle repo shell
-    // if more args are passed its an error
-
-    let mut handle: Option<String> = None;
-    let mut repo_name: Option<String> = None;
-    let mut shell: Option<String> = None;
-    match std::env::args().collect::<Vec<_>>().len() {
-        // 0 args (std env args includes this script)
-        1 => {}
-        2 => {
-            shell = Some(
-                std::env::args()
-                    .last()
-                    .expect("Invalid state: 2 `Some` std::env::args() but found no Some values"),
-            )
-        }
-        3 => {
-            // load args and consume first
-            let mut args = std::env::args();
-            args.next();
-
-            if let Some(val) = args.next() {
-                if val.starts_with("@") {
-                    if val.contains("/") {
-                        let entries: Vec<_> = val.split("/").collect();
-                        if entries.len() != 2 {
-                            return Err(());
-                        }
-                        handle = Some(entries[0][1..].to_string());
-                        repo_name = Some(entries[1].to_string());
-                    } else {
-                        handle = Some(val[1..].to_string());
-                    }
-                } else {
-                    repo_name = Some(val)
-                };
-            }
-            shell = Some(
-                args.next()
-                    .expect("Invalid state: 3 `Some` std::env::args() but only found 2"),
-            );
-        }
-        4 => {
-            // load args and consume first
-            let mut args = std::env::args();
-            args.next();
-
-            handle = Some(
-                args.next()
-                    .expect("Invalid state: 4 `Some` std::env::args() but only found 1"),
-            );
-            repo_name = Some(
-                args.next()
-                    .expect("Invalid state: 4 `Some` std::env::args() but only found 2"),
-            );
-            shell = Some(
-                args.next()
-                    .expect("Invalid state: 4 `Some` std::env::args() but only found 3"),
-            );
-        }
-        _ => {
-            // err
-        }
-    }
-
-    if let Some(ref handle) = handle
-        && let Some(ref repo_name) = repo_name
-        && let Some(ref shell) = shell
-    {
-        return Ok(Config {
-            handle: handle.to_string(),
-            repo_name: repo_name.to_string(),
-            shell: shell.to_string(),
-        });
-    }
-
-    // now load config
-    if let Ok(file) = std::fs::read_to_string("./tangled-on-commit.json") {
-        if let Ok(parsed) = json::parse(&file) {
-            if handle.is_none()
-                && let Some(json_handle) = parsed["handle"].as_str()
-            {
-                handle = Some(String::from(json_handle))
-            }
-            if repo_name.is_none()
-                && let Some(json_repo_name) = parsed["repo_name"].as_str()
-            {
-                repo_name = Some(String::from(json_repo_name))
-            }
-            if shell.is_none()
-                && let Some(json_shell) = parsed["shell"].as_str()
-            {
-                shell = Some(String::from(json_shell))
-            }
-        }
-    }
-
-    if let Some(ref handle) = handle
-        && let Some(ref repo_name) = repo_name
-        && let Some(ref shell) = shell
-    {
-        return Ok(Config {
-            handle: handle.to_string(),
-            repo_name: repo_name.to_string(),
-            shell: shell.to_string(),
-        });
-    }
-
-    // now load from env
-    if handle.is_none()
-        && let Ok(env_handle) = std::env::var("TANGLED_ON_COMMIT_HANDLE")
-    {
-        handle = Some(String::from(env_handle))
-    }
-    if repo_name.is_none()
-        && let Ok(env_repo_name) = std::env::var("TANGLED_ON_COMMIT_REPO_NAME")
-    {
-        repo_name = Some(String::from(env_repo_name))
-    }
-
-    if let Some(ref handle) = handle
-        && let Some(ref repo_name) = repo_name
-        && let Some(ref shell) = shell
-    {
-        return Ok(Config {
-            handle: handle.to_string(),
-            repo_name: repo_name.to_string(),
-            shell: shell.to_string(),
-        });
-    }
-
-    // couldnt resolve every value
-    // print an error and quit
-    println!("Unable to find a value for every setting. Missing values for:");
-    if handle.is_none() {
-        println!("- handle");
-    }
-    if repo_name.is_none() {
-        println!("- repo_name");
-    }
-    if shell.is_none() {
-        println!("- shell");
-    }
-    println!("\nRun `tangled-on-commit --help` to see the help message");
-    return Err(());
-}
-
-#[derive(Debug)]
-struct DidDoc {
-    did: String,
-}
-
-fn get_did(handle: String) -> Result<DidDoc, ()> {
-    // create a txt resolver
-    let resolver = match Resolver::new(ResolverConfig::default(), ResolverOpts::default()) {
-        Ok(val) => val,
-        Err(_) => 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
-    }
-    .into_iter()
-    .map(|x| x.to_string())
-    .collect::<Vec<_>>();
-
-    // filter entries which do not start with `did=`
-    let did_res = txt_res
-        .clone()
-        .extract_if(.., |x| x.starts_with("did="))
-        .collect::<Vec<_>>();
-    // 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 {
-        return Err(());
-    }
-    let did = did_res[0].clone();
-
-    return Ok(DidDoc { did: did.clone() });
-}
+mod args;
+mod did;
 
 fn main() -> Result<(), ()> {
     // load configuration
-    let config = match load_config() {
+    let config = match args::load_config() {
         Ok(res) => res,
         Err(_) => {
             // q
···
     println!("{:#?}", config);
 
     // resolve handle to did
-    let did_doc = match get_did(config.handle) {
+    let did_doc = match did::get_did(config.handle) {
         Ok(res) => res,
         Err(_) => {
             // q