rustfmt + code cleanup

i18n
jnats 3 years ago
parent ea5f18af9e
commit a12b2f692a

@ -1,6 +1,6 @@
[package] [package]
name = "ame" name = "ame"
version = "2.3.2" version = "2.4.0"
authors = [ "jnats <jnats@salyut.one>", "axtlos <axtlos@salyut.one>" ] authors = [ "jnats <jnats@salyut.one>", "axtlos <axtlos@salyut.one>" ]
edition = "2018" edition = "2018"
description = "a fast and efficient aur helper." description = "a fast and efficient aur helper."
@ -17,4 +17,4 @@ moins = "*"
regex = "*" regex = "*"
toml_edit = "*" toml_edit = "*"
toml = "*" toml = "*"
bytes = "*" bytes = "*"

@ -34,8 +34,7 @@ fn main() {
// update // update
} else if oper == "-Sy" || oper == "upd" { } else if oper == "-Sy" || oper == "upd" {
update(); update();
} else if oper == "-db" {
addPkg(pkgs);
// general search // general search
} else if oper == "-Ss" || oper == "sea" { } else if oper == "-Ss" || oper == "sea" {
r_search(&args[2]); r_search(&args[2]);

@ -14,7 +14,6 @@ use mods::{
upgrade::upgrade, upgrade::upgrade,
ver::ver, ver::ver,
xargs::*, xargs::*,
database::{addPkg, remPkg}
}; };
use std::{env, process::exit, process::Command}; use std::{env, process::exit, process::Command};

@ -1,5 +1,6 @@
pub mod clearcache; pub mod clearcache;
pub mod clone; pub mod clone;
pub mod database;
pub mod help; pub mod help;
pub mod inssort; pub mod inssort;
pub mod install; pub mod install;
@ -10,4 +11,3 @@ pub mod update;
pub mod upgrade; pub mod upgrade;
pub mod ver; pub mod ver;
pub mod xargs; pub mod xargs;
pub mod database;

@ -1,6 +1,6 @@
use crate::{ use crate::{
err_unrec, inf, inssort, mods::strs::prompt, mods::strs::sec, mods::strs::succ, err_unrec, inf, inssort, mods::database::add_pkg, mods::strs::prompt, mods::strs::sec,
mods::uninstall::uninstall, mods::database::addPkg mods::strs::succ, mods::uninstall::uninstall,
}; };
use git2::Repository; use git2::Repository;
use moins::Moins; use moins::Moins;
@ -102,7 +102,11 @@ pub fn clone(noconfirm: bool, pkg: &str) {
match install_result { match install_result {
Ok(_) => { Ok(_) => {
uninstall_make_depend(pkg); uninstall_make_depend(pkg);
addPkg(false, pkg); let add_pkg_res = add_pkg(false, pkg);
match add_pkg_res {
Ok(_) => inf(format!("Added package {} to database", pkg)),
Err(_) => err_unrec(format!("Couldn't add package {} to database", pkg)),
}
} }
Err(_) => { Err(_) => {
err_unrec(format!("Couldn't install {}", pkg)); err_unrec(format!("Couldn't install {}", pkg));
@ -118,7 +122,11 @@ pub fn clone(noconfirm: bool, pkg: &str) {
match install_result.code() { match install_result.code() {
Some(0) => { Some(0) => {
uninstall_make_depend(pkg); uninstall_make_depend(pkg);
addPkg(false, pkg); let add_pkg_res = add_pkg(false, pkg);
match add_pkg_res {
Ok(_) => inf(format!("Added package {} to database", pkg)),
Err(_) => err_unrec(format!("Couldn't add package {} to database", pkg)),
}
} }
Some(_) => { Some(_) => {
err_unrec(format!("Couldn't install {}", pkg)); err_unrec(format!("Couldn't install {}", pkg));

@ -1,46 +1,54 @@
use regex::bytes; use crate::{err_unrec, inf};
use toml_edit::{Document, value}; use std::fs::File;
use std::io::{Read, Write, Error}; use std::io::{Error, Write};
use std::fs::File; use toml_edit::{value, Document};
pub fn remPkg(pkgs: &Vec<String>) { pub fn rem_pkg(pkgs: &Vec<String>) {
let file = format!("{}/.local/ame/aurPkgs.db", std::env::var("HOME").unwrap()); let file = format!("{}/.local/ame/aurPkgs.db", std::env::var("HOME").unwrap());
let mut database = std::fs::read_to_string(&file).expect("cant open database"); let database = std::fs::read_to_string(&file).expect("Can't Open Database");
let mut updateDatabase = database; let mut update_database = database;
for i in pkgs { for i in pkgs {
if updateDatabase.contains(i) { if update_database.contains(i) {
let results = raur::search(&i); let results = raur::search(&i);
for res in &results { for res in &results {
let databaseEntry = format!("{} = {{ name = \"{}\", version = \"{}\"}}\n",&res[0].name, &res[0].name, &res[0].version); let database_entry = format!(
updateDatabase = format!("{}",updateDatabase.replace(&databaseEntry, "")); "{} = {{ name = \"{}\", version = \"{}\"}}\n",
} &res[0].name, &res[0].name, &res[0].version
} );
} update_database = format!("{}", update_database.replace(&database_entry, ""));
let fileAsPath = File::create(std::path::Path::new(&file)).unwrap(); }
write!(&fileAsPath, "{}", updateDatabase); }
}
} let file_as_path = File::create(std::path::Path::new(&file)).unwrap();
let db_update_res = write!(&file_as_path, "{}", update_database);
pub fn addPkg(fromRepo: bool, pkg: &str) -> Result<(), Error> { match db_update_res {
let file = format!("{}/.local/ame/aurPkgs.db", std::env::var("HOME").unwrap()); Ok(_) => inf(format!("Database update successful")),
let database = std::fs::read_to_string(&file).expect("cant open database"); Err(_) => err_unrec(format!("Couldn't update database")),
let mut fileAsPath = File::create(std::path::Path::new(&file))?; }
}
let mut dbParsed = database.parse::<Document>().expect("invalid Database");
if fromRepo == false { pub fn add_pkg(from_repo: bool, pkg: &str) -> Result<(), Error> {
let results = raur::search(&pkg); let file = format!("{}/.local/ame/aurPkgs.db", std::env::var("HOME").unwrap());
for res in &results { let database = std::fs::read_to_string(&file).expect("cant open database");
for r in res { let mut file_as_path = File::create(std::path::Path::new(&file))?;
dbParsed[&r.name]["name"] = value(&r.name);
dbParsed[&r.name]["version"] = value(&r.version); let mut db_parsed = database.parse::<Document>().expect("invalid Database");
} if from_repo == false {
} let results = raur::search(&pkg);
} else { for res in &results {
dbParsed[&pkg]["name"] = value(pkg); for r in res {
dbParsed[&pkg]["version"] = value(pkg); db_parsed[&r.name]["name"] = value(&r.name);
} db_parsed[&r.name]["version"] = value(&r.version);
print!("{}",dbParsed); }
fileAsPath.write_all(format!("{}",dbParsed).as_bytes()).unwrap(); }
Ok(()) } else {
} db_parsed[&pkg]["name"] = value(pkg);
db_parsed[&pkg]["version"] = value(pkg);
}
print!("{}", db_parsed);
file_as_path
.write_all(format!("{}", db_parsed).as_bytes())
.unwrap();
Ok(())
}

@ -1,4 +1,7 @@
use crate::mods::{strs::{err_rec, err_unrec, sec, succ}, database::remPkg}; use crate::mods::{
database::rem_pkg,
strs::{err_rec, err_unrec, sec, succ},
};
use runas::Command; use runas::Command;
use std::{fs, path::Path}; use std::{fs, path::Path};
@ -17,10 +20,11 @@ pub fn uninstall(noconfirm: bool, pkgs: Vec<String>) {
match result.code() { match result.code() {
Some(0) => { Some(0) => {
succ(format!( succ(format!(
"Succesfully uninstalled packages: {}", "Succesfully uninstalled packages: {}",
&pkgs.join(" "))); &pkgs.join(" ")
remPkg(&pkgs); ));
}, rem_pkg(&pkgs);
}
Some(_) => err_rec(format!("Couldn't uninstall packages: {}", &pkgs.join(" "))), Some(_) => err_rec(format!("Couldn't uninstall packages: {}", &pkgs.join(" "))),
None => err_rec(format!("Couldn't uninstall packages: {}", &pkgs.join(" "))), None => err_rec(format!("Couldn't uninstall packages: {}", &pkgs.join(" "))),
}; };
@ -33,10 +37,11 @@ pub fn uninstall(noconfirm: bool, pkgs: Vec<String>) {
match result.code() { match result.code() {
Some(0) => { Some(0) => {
succ(format!( succ(format!(
"Succesfully uninstalled packages: {}", "Succesfully uninstalled packages: {}",
&pkgs.join(" "))); &pkgs.join(" ")
remPkg(&pkgs); ));
}, rem_pkg(&pkgs);
}
Some(_) => err_rec(format!("Couldn't uninstall packages: {}", &pkgs.join(" "))), Some(_) => err_rec(format!("Couldn't uninstall packages: {}", &pkgs.join(" "))),
None => err_rec(format!("Couldn't uninstall packages: {}", &pkgs.join(" "))), None => err_rec(format!("Couldn't uninstall packages: {}", &pkgs.join(" "))),
}; };

@ -1,13 +1,11 @@
//use crate::mods::strs::{err_unrec, inf, sec, succ}; //use crate::mods::strs::{err_unrec, inf, sec, succ};
use crate::{ use crate::{
err_unrec, inf, inssort, mods::strs::prompt, mods::strs::sec, mods::strs::succ, err_unrec, inf, inssort, mods::strs::prompt, mods::strs::sec, mods::strs::succ, uninstall,
mods::uninstall::uninstall, mods::database::addPkg
}; };
use git2::Repository;
use runas::Command; use runas::Command;
use std::{env, fs, path::Path}; use std::{env, fs, path::Path};
use toml; use toml;
use git2::Repository;
fn uninstall_make_depend(pkg: &str) { fn uninstall_make_depend(pkg: &str) {
let make_depends = raur::info(&[&pkg]).unwrap()[0].make_depends.clone(); let make_depends = raur::info(&[&pkg]).unwrap()[0].make_depends.clone();
@ -30,19 +28,16 @@ pub fn upgrade(noconfirm: bool) {
let homepath = std::env::var("HOME").unwrap(); let homepath = std::env::var("HOME").unwrap();
let cachedir = format!("/{}/.cache/ame/", homepath); let cachedir = format!("/{}/.cache/ame/", homepath);
let cache_exists = std::path::Path::new(&format!("/{}/.cache/ame/", homepath)).is_dir(); let cache_exists = std::path::Path::new(&format!("/{}/.cache/ame/", homepath)).is_dir();
let file = format!("{}/.local/ame/aurPkgs.db", std::env::var("HOME").unwrap()); let file = format!("{}/.local/ame/aurPkgs.db", std::env::var("HOME").unwrap());
let database = std::fs::read_to_string(&file).expect("cant open database"); let database = std::fs::read_to_string(&file).expect("Can't open database");
let mut dbParsed = database.parse::<toml::Value>().expect("invalid Database"); let db_parsed = database.parse::<toml::Value>().expect("Invalid Database");
if cache_exists == false { if cache_exists == false {
let cachecreate = fs::create_dir_all(&cachedir); let cachecreate = fs::create_dir_all(&cachedir);
match cachecreate { match cachecreate {
Ok(_) => { Ok(_) => inf(format!("Creating cachedir. (didn't exist previously)")),
inf(format!("Creating cachedir. (didn't exist previously)")) Err(_) => err_unrec(format!("Couldn't create cachedir")),
} }
Err(_) => {
err_unrec(format!("Couldn't create cachedir"))
}}
} }
sec(format!("Performing system upgrade")); sec(format!("Performing system upgrade"));
if noconfirm == true { if noconfirm == true {
@ -68,99 +63,38 @@ pub fn upgrade(noconfirm: bool) {
}; };
} }
println!("{:?}", dbParsed); println!("{:?}", db_parsed);
for entry in dbParsed.as_table() { for entry in db_parsed.as_table() {
for (key, value) in &*entry { for (key, value) in &*entry {
let results = raur::search(format!("{}",key)); let results = raur::search(format!("{}", key));
for res in results { for res in results {
println!("{}",&res[0].name); println!("{}", &res[0].name);
let url = format!("https://aur.archlinux.org/{}.git", key); let url = format!("https://aur.archlinux.org/{}.git", key);
let package = raur::info(&[key]).unwrap(); let package = raur::info(&[key]).unwrap();
let version = value.to_string().replace("name", "").replace("version","").replace(" = ","").replace("\"","").replace(format!("{}",&res[0].name.to_string()).as_str(),""); let version = value
let name = value.to_string().replace("name", "").replace("version","").replace(" = ","").replace("\"","").replace(format!("{}",&res[0].version.to_string()).as_str(),""); .to_string()
println!("{} / {}",name,version); .replace("name", "")
if res[0].version.contains(&version) { .replace("version", "")
let keydir = format!("{}{}",&cachedir,&key); .replace(" = ", "")
if std::path::Path::new(&keydir).is_dir() { .replace("\"", "")
let cd_result = env::set_current_dir(&keydir); .replace(format!("{}", &res[0].name.to_string()).as_str(), "");
match cd_result { let name = value
Ok(_) => inf(format!("Entered package directory")), .to_string()
Err(_) => err_unrec(format!("Could not enter package directory")), .replace("name", "")
} .replace("version", "")
inssort(true, package[0].depends.clone()); .replace(" = ", "")
.replace("\"", "")
sec(format!("Installing {} ...", &key)); .replace(format!("{}", &res[0].version.to_string()).as_str(), "");
let install_result = std::process::Command::new("makepkg") println!("{} / {}", name, version);
.arg("-si") if res[0].version.contains(&version) {
.arg("--noconfirm") let keydir = format!("{}{}", &cachedir, &key);
.arg("--needed") if std::path::Path::new(&keydir).is_dir() {
.status(); let cd_result = env::set_current_dir(&keydir);
match install_result { match cd_result {
Ok(_) => { Ok(_) => inf(format!("Entered package directory")),
uninstall_make_depend(&key); Err(_) => err_unrec(format!("Could not enter package directory")),
}
Err(_) => {
err_unrec(format!("Couldn't install {}", &key));
}
};
sec(format!("Installing {} ...", &key));
let install_result = std::process::Command::new("makepkg")
.arg("-si")
.arg("--needed")
.status()
.expect("Couldn't call makepkg");
match install_result.code() {
Some(0) => {
uninstall_make_depend(&key);
}
Some(_) => {
err_unrec(format!("Couldn't install {}", &key));
}
None => {
err_unrec(format!("Couldn't install {}", &key));
}
};
} else {
inf(format!("Cloning {} ...", &key));
if Path::new(&keydir).is_dir() {
let rm_result = fs::remove_dir_all(&keydir);
match rm_result {
Ok(_) => inf(format!(
"Package path for {} already found. Removing to reinstall",
&key
)),
Err(_) => err_unrec(format!(
"Package path for {} already found, but could not remove to reinstall",
&key
)),
}
}
let dir_result = fs::create_dir(&keydir);
match dir_result {
Ok(_) => inf(format!("Created package directory for {}", &key)),
Err(_) => err_unrec(format!("Couldn't create package directory for {}", &key)),
}
let cd_result = env::set_current_dir(&keydir);
match cd_result {
Ok(_) => inf(format!("Entered package directory")),
Err(_) => err_unrec(format!("Could not enter package directory")),
}
inssort(true, package[0].depends.clone());
let clone = Repository::clone(&url, Path::new(&keydir));
match clone {
Ok(_) => {
inf(format!("Cloning {} into package directory", &key));
}
Err(_) => err_unrec(format!("Failed cloning {} into package directory", &key)),
}
} }
inssort(true, package[0].depends.clone());
sec(format!("Installing {} ...", &key)); sec(format!("Installing {} ...", &key));
let install_result = std::process::Command::new("makepkg") let install_result = std::process::Command::new("makepkg")
@ -176,6 +110,7 @@ pub fn upgrade(noconfirm: bool) {
err_unrec(format!("Couldn't install {}", &key)); err_unrec(format!("Couldn't install {}", &key));
} }
}; };
sec(format!("Installing {} ...", &key)); sec(format!("Installing {} ...", &key));
let install_result = std::process::Command::new("makepkg") let install_result = std::process::Command::new("makepkg")
.arg("-si") .arg("-si")
@ -193,17 +128,90 @@ pub fn upgrade(noconfirm: bool) {
err_unrec(format!("Couldn't install {}", &key)); err_unrec(format!("Couldn't install {}", &key));
} }
}; };
} else {
inf(format!("Cloning {} ...", &key));
if Path::new(&keydir).is_dir() {
let rm_result = fs::remove_dir_all(&keydir);
match rm_result {
Ok(_) => inf(format!(
"Package path for {} already found. Removing to reinstall",
&key
)),
Err(_) => err_unrec(format!(
"Package path for {} already found, but could not remove to reinstall",
&key
)),
}
}
} else { let dir_result = fs::create_dir(&keydir);
println!("not upgrading!"); match dir_result {
if std::path::Path::new(&format!("{}{}",&cachedir,&key)).is_dir() { Ok(_) => inf(format!("Created package directory for {}", &key)),
println!("not cloning"); Err(_) => {
} else { err_unrec(format!("Couldn't create package directory for {}", &key))
println!("cloning"); }
}
let cd_result = env::set_current_dir(&keydir);
match cd_result {
Ok(_) => inf(format!("Entered package directory")),
Err(_) => err_unrec(format!("Could not enter package directory")),
}
inssort(true, package[0].depends.clone());
let clone = Repository::clone(&url, Path::new(&keydir));
match clone {
Ok(_) => {
inf(format!("Cloning {} into package directory", &key));
}
Err(_) => {
err_unrec(format!("Failed cloning {} into package directory", &key))
}
}
}
sec(format!("Installing {} ...", &key));
let install_result = std::process::Command::new("makepkg")
.arg("-si")
.arg("--noconfirm")
.arg("--needed")
.status();
match install_result {
Ok(_) => {
uninstall_make_depend(&key);
}
Err(_) => {
err_unrec(format!("Couldn't install {}", &key));
}
};
sec(format!("Installing {} ...", &key));
let install_result = std::process::Command::new("makepkg")
.arg("-si")
.arg("--needed")
.status()
.expect("Couldn't call makepkg");
match install_result.code() {
Some(0) => {
uninstall_make_depend(&key);
}
Some(_) => {
err_unrec(format!("Couldn't install {}", &key));
}
None => {
err_unrec(format!("Couldn't install {}", &key));
} }
};
} else {
println!("not upgrading!");
if std::path::Path::new(&format!("{}{}", &cachedir, &key)).is_dir() {
println!("not cloning");
} else {
println!("cloning");
} }
} }
}
} }
} }
} }

@ -1,9 +1,9 @@
use crate::mods::strs::inf; use crate::inf;
use ansi_term::Colour; use ansi_term::Colour;
pub fn ver() { pub fn ver() {
println!(""); println!("");
inf(format!("ame - v2.3.2")); inf(format!("ame - v2.4.0"));
println!(""); println!("");
inf(format!("Contributors:")); inf(format!("Contributors:"));
println!("- axtlos <axtlos@salyut.one>"); println!("- axtlos <axtlos@salyut.one>");

Loading…
Cancel
Save