Add foreman github-auth.

Closes #14.

Author: LPGhatguy

CHANGELOG.md

@@ -1,5 +1,8 @@
 # Foreman Changelog
 
+## [Unreleased]
+- Added `foreman github-auth` command for authenticating with GitHub.
+
 ## 0.5.1
 - On Unix systems, tools now always have permissions of 777.
 	- This ensures that they're executable, even when the containing archives fail to preserve permissions.

Cargo.lock

@@ -17,7 +17,9 @@ log = "0.4.8"
 reqwest = { version = "0.10.1", features = ["json", "blocking"] }
 semver = { version = "0.9.0", features = ["serde"] }
 serde = { version = "1.0.104", features = ["derive"] }
+rpassword = "4.0.5"
 serde_json = "1.0.47"
 structopt = "0.3.9"
 toml = "0.5.6"
+toml_edit = "0.1.5"
 zip = "0.5"

Cargo.toml

@@ -4,7 +4,8 @@
 # `github` key. This is useful if you hit GitHub API rate limits or if you need
 # to access private tools.
 
-# In order to use sources from private repositories, this token will need "repo"
-# permissions granted to it and potentially SSO authorization.
+# You can also run `foreman github-auth` to update this file, optionally passing
+# the token as the first argument.
 
-# github = "<PAC HERE>"
+# In order to use sources from private repositories, this token will need "repo"
+# permissions granted to it and potentially SSO authorization.

resources/default-auth.toml

@@ -1,9 +1,12 @@
 use std::io;
 
 use serde::{Deserialize, Serialize};
+use toml_edit::{value, Document};
 
 use crate::{fs, paths};
 
+pub static DEFAULT_AUTH_CONFIG: &str = include_str!("../resources/default-auth.toml");
+
 /// Contains stored user tokens that Foreman can use to download tools.
 #[derive(Debug, Default, Serialize, Deserialize)]
 pub struct AuthStore {
@@ -35,4 +38,23 @@ impl AuthStore {
             }
         }
     }
+
+    pub fn set_github_token(token: &str) -> io::Result<()> {
+        let contents = match fs::read_to_string(paths::auth_store()) {
+            Ok(contents) => contents,
+            Err(err) => {
+                if err.kind() == io::ErrorKind::NotFound {
+                    DEFAULT_AUTH_CONFIG.to_owned()
+                } else {
+                    return Err(err);
+                }
+            }
+        };
+
+        let mut store: Document = contents.parse().unwrap();
+        store["github"] = value(token);
+
+        let serialized = store.to_string();
+        fs::write(paths::auth_store(), serialized)
+    }
 }

src/auth_store.rs

@@ -21,6 +21,13 @@ pub fn read<P: AsRef<Path>>(path: P) -> Result<Vec<u8>> {
     fs::read(path).map_err(|source| Error::new(source, path))
 }
 
+/// A wrapper around std::fs::read_to_string.
+pub fn read_to_string<P: AsRef<Path>>(path: P) -> Result<String> {
+    let path = path.as_ref();
+
+    fs::read_to_string(path).map_err(|source| Error::new(source, path))
+}
+
 /// A wrapper around std::fs::write.
 pub fn write<P: AsRef<Path>, C: AsRef<[u8]>>(path: P, contents: C) -> Result<()> {
     let path = path.as_ref();

src/fs.rs

@@ -12,7 +12,9 @@ use std::{env, error::Error, io};
 
 use structopt::StructOpt;
 
-use crate::{aliaser::add_self_alias, config::ConfigFile, tool_cache::ToolCache};
+use crate::{
+    aliaser::add_self_alias, auth_store::AuthStore, config::ConfigFile, tool_cache::ToolCache,
+};
 
 #[derive(Debug)]
 struct ToolInvocation {
@@ -88,6 +90,21 @@ enum Subcommand {
 
     /// List installed tools.
     List,
+
+    /// Set the GitHub Personal Access Token that Foreman should use with the
+    /// GitHub API.
+    ///
+    /// This token can also be configured by editing ~/.foreman/auth.toml.
+    #[structopt(name = "github-auth")]
+    GitHubAuth(GitHubAuthCommand),
+}
+
+#[derive(Debug, StructOpt)]
+struct GitHubAuthCommand {
+    /// GitHub personal access token that Foreman should use.
+    ///
+    /// If not specified, Foreman will prompt for it.
+    token: Option<String>,
 }
 
 fn actual_main() -> io::Result<()> {
@@ -117,6 +134,30 @@ fn actual_main() -> io::Result<()> {
                 }
             }
         }
+        Subcommand::GitHubAuth(subcommand) => {
+            let token = match subcommand.token {
+                Some(token) => token,
+                None => {
+                    println!("Foreman authenticates to GitHub using Personal Access Tokens.");
+                    println!("https://help.github.com/en/github/authenticating-to-github/creating-a-personal-access-token-for-the-command-line");
+                    println!();
+
+                    loop {
+                        let token = rpassword::read_password_from_tty(Some("GitHub Token: "))?;
+
+                        if token.is_empty() {
+                            println!("Token must be non-empty.");
+                        } else {
+                            break token;
+                        }
+                    }
+                }
+            };
+
+            AuthStore::set_github_token(&token)?;
+
+            println!("GitHub auth saved successfully.");
+        }
     }
 
     Ok(())

src/main.rs

@@ -2,10 +2,9 @@
 
 use std::{io, path::PathBuf};
 
-use crate::fs;
+use crate::{auth_store::DEFAULT_AUTH_CONFIG, fs};
 
 static DEFAULT_USER_CONFIG: &str = include_str!("../resources/default-foreman.toml");
-static DEFAULT_AUTH_STORE: &str = include_str!("../resources/default-auth.toml");
 
 pub fn base_dir() -> PathBuf {
     let mut dir = dirs::home_dir().unwrap();
@@ -54,7 +53,7 @@ pub fn create() -> io::Result<()> {
     let auth = auth_store();
     if let Err(err) = fs::metadata(&auth) {
         if err.kind() == io::ErrorKind::NotFound {
-            fs::write(&auth, DEFAULT_AUTH_STORE)?;
+            fs::write(&auth, DEFAULT_AUTH_CONFIG)?;
         } else {
             return Err(err);
         }