wymiller/gt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: generate config, load shell env vars

Browse Source
This commit is contained in:
Wyatt J. Miller 2023-01-29 19:19:50 -05:00
parent 58b4b00311
commit 7c5c0c13fb
8 changed files with 275 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/arg.rs
View File

@ -66,6 +66,7 @@ pub fn get_args() -> ArgMatches<'static> {
.help("Create an issue for a repository")
)
)
.arg(Arg::with_name(""))
.subcommand(SubCommand::with_name("pr")
.about("Create, search, comment, merge, and close pull requests")
.arg(Arg::with_name("create")

99
src/config.rs
View File

@ -1,10 +1,13 @@
use std::env;
use std::ops::Deref;
use std::process;
use config::File;
use serde::Deserialize;
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, Deserialize)]
use crate::generate;
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct Configuration {
pub api_token: Option<String>,
pub base_api: String,
@ -15,6 +18,16 @@ pub struct Configuration {
impl Configuration {
pub fn new() -> Configuration {
Configuration {
api_token: None,
base_api: String::new(),
base_url: String::new(),
username: None,
password: None,
}
}
pub fn load_config_file(&mut self) {
let home_dir_env = env::var("HOME").unwrap();
let mut settings = config::Config::default();
let mut location: Vec<String> = Vec::new();
@ -24,18 +37,21 @@ impl Configuration {
"windows" => {
location.push(String::from("config.json"));
location.push(format!("{:?}/AppData/Roaming/gt/config.json", home_dir_env))
},
}
// this case is currently untested
"macos" => {
location.push(String::from("config.json"));
},
}
"linux" => {
location.push(String::from("config.json"));
location.push(String::from("/etc/gt/config.json"));
location.push(format!("{:?}/.config/gt/config.json", home_dir_env));
},
location.push(format!("{:?}/.config/gt/config.json", home_dir_env));
}
_ => {
println!("Unsupported operating system! {:?} might cause some instabilities!", env::consts::OS);
println!(
"Unsupported operating system! {:?} might cause some instabilities!",
env::consts::OS
);
location.push(String::from("config.json"));
}
}
@ -44,46 +60,75 @@ impl Configuration {
settings.merge(File::with_name(&i).required(false)).unwrap();
}
let config = settings
.try_into::<Configuration>()
.expect("Couldn't load config into gt!");
let config: Result<Configuration, config::ConfigError> =
settings.try_into::<Configuration>();
config
match config {
Ok(_) => {
let c = config.unwrap();
if (self.api_token.is_none()) {
self.api_token = c.api_token;
}
if (self.base_url.is_empty()) {
self.base_url = c.base_url;
}
if (self.base_api.is_empty()) {
self.base_api = c.base_api;
}
if (self.username.is_none()) {
self.username = c.username;
}
if (self.password.is_none()) {
self.password = c.password;
}
println!("{:?}", self);
}
Err(e) => {
println!("No config found! Trying to generate config: {}", e);
generate::generate_config();
print!("Go fill out your config.json file in your present working directory. If you need assistance, please reference the readme.");
process::exit(4);
}
}
}
pub fn load_envs(&mut self) {
// get environment variables
let username_env = env::var("GT_USERNAME").unwrap_or_else(|_| "".to_string());
let password_env = env::var("GT_PASSWORD").unwrap_or_else(|_| "".to_string());
let api_token_env = env::var("GT_API_TOKEN").unwrap_or_else(|_| "".to_string());
// get struct fields
let mut user_config = self.username.as_ref().unwrap();
let mut password_config = self.password.as_ref().unwrap();
let mut api_token_config = self.api_token.as_ref().unwrap();
let username_env = env::var("GT_USERNAME").unwrap_or_else(|_| String::new());
let password_env = env::var("GT_PASSWORD").unwrap_or_else(|_| String::new());
let api_token_env = env::var("GT_API_TOKEN").unwrap_or_else(|_| String::new());
let base_url_env = env::var("GT_URL").unwrap_or_else(|_| String::new());
// check and see if the env vars are empty
// if they are not, put the env vars in place of the config property
if username_env != "".to_string() {
if !username_env.is_empty() {
self.username = Some(username_env);
} else {
println!("cannot find username env var");
}
if password_env != "".to_string() {
password_config = &password_env.deref().to_string();
if !password_env.is_empty() {
self.password = Some(password_env);
} else {
println!("cannot find password env var");
}
if api_token_env != "".to_string() {
api_token_config = &api_token_env.deref().to_string();
if !api_token_env.is_empty() {
self.api_token = Some(api_token_env);
} else {
println!("cannot find api token env var");
}
println!("{:?}", &self);
if !base_url_env.is_empty() {
self.base_url = base_url_env;
}
println!("{:?}", &self);
}
}

21
src/generate.rs
View File

@ -1,5 +1,20 @@
use crate::config::Configuration;
use std::fs;
use std::path::Path;
fn generate_config() {
}
pub fn generate_config() {
let json_file = String::from("config.json");
if !Path::new(&json_file).exists() {
let generate = Configuration {
api_token: Some("".to_string()),
base_api: "/api/v1".to_string(),
base_url: "https://gitea.com".to_string(),
username: Some("gitea".to_string()),
password: Some("".to_string()),
};
let json = serde_json::to_string(&generate).unwrap();
fs::write(json_file, json).expect("Failed to write file.");
}
}

91
src/issue.rs
View File

@ -1,11 +1,12 @@
use std::collections::HashMap;
use colored::*;
use reqwest::StatusCode;
use reqwest::blocking::Client;
use reqwest::{StatusCode, Response};
use serde_derive::{Serialize, Deserialize};
use serde_json::Value;
use crate::request::Request;
use crate::request::{Request, Authentication, AuthenticationType};
use crate::util;
pub struct Issue;
@ -66,6 +67,17 @@ pub struct Repository {
pub full_name: String,
}
// trait IssueRequest {
// fn client() -> &'static Client;
// fn url_request_decision() -> String;
// fn arg_value_decision() -> Vec<&'static str>;
// }
// impl IssueRequest for Issue {
// fn client() -> &'static Client {
// return
// }
// }
impl Issue {
pub fn new() -> Issue {
@ -118,4 +130,79 @@ impl Issue {
Err(e) => panic!("{}", e),
}
}
pub fn list_issue(&self, request: &Request) {
let client = &request.client;
let url = self.url_request_decision(&request);
let response = client.get(&url).send();
// TODO: fix this to match context
match response {
Ok(repo) => {
match repo.status() {
StatusCode::CREATED => println!("{}", "Issue successfully created!".green()),
StatusCode::FORBIDDEN => println!("{}", "Issue creation forbidden!".red()),
StatusCode::UNPROCESSABLE_ENTITY => println!("{}", "Issue input validation failed!".red()),
_ => println!(),
}
},
Err(e) => panic!("{}", e),
}
}
pub fn search_issue(&self, request: &Request) {
let client = &request.client;
let url = self.url_request_decision(&request);
let response = client.get(&url).send();
// TODO: fix this to match context
match response {
Ok(repo) => {
match repo.status() {
StatusCode::CREATED => println!("{}", "Issue successfully created!".green()),
StatusCode::FORBIDDEN => println!("{}", "Issue creation forbidden!".red()),
StatusCode::UNPROCESSABLE_ENTITY => println!("{}", "Issue input validation failed!".red()),
_ => println!(),
}
},
Err(e) => panic!("{}", e),
}
}
fn url_request_decision(&self, request: &Request) -> String {
let arg_value: Vec<&str> = request
.arg_value
.subcommand()
.1
.unwrap()
// TODO: fix the command line variable listed below
.values_of("search")
.unwrap()
.collect();
// TODO: fix the url formatting for basic auth
match &request.authentication.auth_type {
AuthenticationType::ApiToken => {
format!(
"{request}/repos/{owner}/{repo}/issues?token={api_token}",
request = request.url.as_ref().unwrap(),
owner = arg_value[0],
repo = arg_value[1],
api_token = request.authentication.credentials.1.as_ref().unwrap()
)
},
AuthenticationType::BasicAuth => {
format!(
"{request}/repos/{owner}/{repo}/issues?token={api_token}",
request = request.url.as_ref().unwrap(),
owner = arg_value[0],
repo = arg_value[1],
api_token = request.authentication.credentials.1.as_ref().unwrap()
)
},
// this case _shouldn't_ happen but ya know
AuthenticationType::None => panic!("idk what happened man you wrote the code 🤷")
}
}
}

11
src/main.rs
View File

@ -5,10 +5,11 @@
mod arg;
mod config;
mod generate;
mod issue;
mod pr;
mod repo;
mod request;
mod pr;
mod user;
mod util;
@ -18,6 +19,14 @@ fn main() {
let matches: ArgMatches = arg::get_args();
let mut config = crate::config::Configuration::new();
config.load_envs();
if config.base_url.is_empty()
|| config.api_token.is_none()
|| (config.username.is_none() && config.password.is_none())
{
config.load_config_file();
}
let auth = request::Authentication::new(&config);
let request = auth.request_chooser(config.clone(), matches);

62
src/repo.rs
View File

@ -1,7 +1,7 @@
use std::collections::HashMap;
use std::{collections::HashMap, path::{Path, self}, file};
use colored::*;
use git2::Repository as Repo;
use git2::{Repository as Repo, build::RepoBuilder, Credentials, Cred, CredentialType, RemoteCallbacks, FetchOptions};
use reqwest::StatusCode;
use serde_derive::{Deserialize, Serialize};
@ -287,7 +287,7 @@ impl Repository {
println!("{}.\tRepository name: {:1}\n\tRepository owner: {:2}\n\tRepository description: {:3}\n", i + 1, data.name, data.owner.as_ref().unwrap().full_name, data.description)
}
println!("Total number of repositories indexed: {}", deserialized.data.iter().count())
println!("Total number of repositories indexed: {}", deserialized.data.len())
},
false => println!("{}", "The authenticated user doesn't have any repositories. Why not create one?".yellow())
}
@ -299,12 +299,15 @@ impl Repository {
}
}
pub fn push_to_remote(&self, request: &Request) {
pub fn push_to_remote(&self, request: &Request, config: &Configuration) {
// code to push to the remote server goes here
// this is based on the user, the remote, and the branch
}
pub fn pull_from_remote(&self, request: &Request) {
pub fn pull_from_remote(&self, request: &Request, config: &Configuration) {
// code to pull from the remote server goes here
// this is based on the user, the remote, and the branch
}
pub fn clone_from_remote(&self, request: &Request, config: &Configuration) {
@ -322,7 +325,48 @@ impl Repository {
owner = arg_value[0],
repo = arg_value[1]
);
Repo::clone(url.as_str(), ".").unwrap();
println!("Repository successfully cloned!");
let mut builder = RepoBuilder::new();
let mut callbacks = RemoteCallbacks::new();
callbacks.credentials(|_url, _user_from_url, _allowed_types| {
let user = _user_from_url.unwrap_or("git");
if _allowed_types.contains(CredentialType::USERNAME) {
return Cred::username(user)
}
// if request.url_request() {
// Cred::ssh_key(
// user,
// Some(Path::new(&format!("{}/.ssh/id_ed25519.pub", std::env::var("HOME").unwrap()).as_str())),
// Path::new(&format!("{}/.ssh/id_ed25519", std::env::var("HOME").unwrap()).as_str()),
// None
// )
// } else {
// Cred::userpass_plaintext(
// request.authentication.credentials.0.as_ref().unwrap().as_str(),
// request.authentication.credentials.1.as_ref().unwrap().as_str()
// )
// }
Cred::userpass_plaintext(
request.authentication.credentials.0.as_ref().unwrap().as_str(),
config.password.as_ref().unwrap().as_str()
)
});
builder.branch("master");
match builder.clone(url.as_str(), Path::new(arg_value[1])) {
Ok(_r) => Ok(println!("Repository cloned successfully!")),
Err(_e) => Err(println!("Repository clone failed!")),
_ => panic!("agh")
};
}
pub fn add_to_staging(&self, request: &Request, config: Configuration) {
}
pub fn create_commit(&self, request: &Request, config: Configuration) {
}
}

16
src/request.rs
View File

@ -1,4 +1,4 @@
use std::collections::HashMap;
use std::{collections::HashMap, process};
use clap::ArgMatches;
use reqwest::blocking::Client;
@ -56,17 +56,6 @@ impl<'a> Request<'a> {
authentication: auth,
}
}
/// public method that decides whether to format the request url
/// based on the authentication written in the config file.
/// Returns an integer.
pub fn url_request(&self) -> bool {
if self.authentication.api_token {
true
} else {
false
}
}
}
impl Authentication {
@ -90,7 +79,8 @@ impl Authentication {
basic_auth,
)
} else {
panic!("Must have some form of authentication! Exiting...");
println!("Must have some form of authentication! Exiting...");
process::exit(3)
}
} else {
Authentication::with_api_token(config.username.as_ref().unwrap().to_string(), api_auth)

30
src/user.rs
View File

@ -1,3 +1,6 @@
use std::collections::HashMap;
use crate::{request::Request, util};
use serde_derive::{Deserialize, Serialize};
pub struct User;
@ -30,4 +33,29 @@ impl User {
pub fn new() -> User {
User {}
}
}
pub fn create_user(request: &Request) {
let client = &request.client;
let arg_value = &request
.arg_value
.subcommand()
.1
.unwrap()
.value_of("create")
.unwrap();
let mut user_create_input: HashMap<String, String> = HashMap::new();
let username = util::get_input(String::from("Please enter a username:"));
let email = util::get_input(String::from("Please enter a email address:"));
let password = util::get_input(String::from("Please enter a password:"));
user_create_input.insert("login".to_string(), username);
user_create_input.insert("email".to_string(), email);
user_create_input.insert("password".to_string(), password);
}
pub fn list_user() {}
pub fn search_user() {}
pub fn delete_user() {}
}