Merge pull request 'merge from testing' (#1) from testing into main

Reviewed-on: https://git.getcryst.al/crystal/ame/pulls/1
i18n
michal 3 years ago
commit fef9d41c24

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

@ -0,0 +1,79 @@
mod mods;
use mods::{clearcache::clearcache, clone::clone, help::help, install::install, inssort::inssort, search::{a_search, r_search}, uninstall::uninstall, upgrade::upgrade, update::update, ver::ver, strs::inf, strs::err_unrec, strs::err_rec, xargs::*, database::addPkg};
use std::{env, process::exit, process::Command};
fn main() {
// let statements
let args: Vec<String> = env::args().collect();
let mut pkgs: Vec<String> = env::args().skip(2).collect();
// args catch
if args.len() <= 1 {
help();
exit(1);
}
let oper = &args[1];
let noconfirm: bool = noconf(&args);
argssort(&mut pkgs);
// install
if oper == "-S" || oper == "-Sn" || oper == "ins" {
inssort(noconfirm, pkgs);
// remove
} else if oper == "-R" || oper == "-Rn " || oper == "-Rsn" || oper == "-Rs" || oper == "rm" {
uninstall(noconfirm, pkgs);
// upgrade
} else if oper == "-Syu" || oper == "-Syun" || oper == "upg" {
upgrade(noconfirm);
// update
} else if oper == "-Sy" || oper == "upd" {
update();
// general search
} else if oper == "-Ss" || oper == "sea" {
r_search(&args[2]);
a_search(&args[2]);
// aur search
} else if oper == "-Sa" || oper == "aursea" {
a_search(&args[2]);
// repo search
} else if oper == "-Sr" || oper == "repsea" {
r_search(&args[2]);
// clear cache !! DEBUG ONLY !! DO NOT DO THIS IF YOU DONT KNOW WHAT YOURE DOING !!
} else if oper == "-Cc" || oper == "clr" {
clearcache();
// version / contrib
} else if oper == "-v" || oper == "-V" || oper == "ver" {
ver();
// help
} else if oper == "-h" || oper == "help" {
help();
// pacman passthrough
} else {
let pass = Command::new("pacman")
.args(env::args().skip(1))
.status()
.expect("Something has gone wrong.");
match pass.code() {
Some(1) => {
err_rec(format!("No such operation \"{}\"", args.join(" ")));
inf(format!("Try running \"ame help\" for an overview of how to use ame"))
}
Some(_) => {}
None => {
err_unrec(format!("Something has gone terribly wrong."))
}}
}
}

@ -1,5 +1,6 @@
pub mod clearcache;
pub mod clone;
pub mod database;
pub mod help;
pub mod inssort;
pub mod install;

@ -1,6 +1,6 @@
use crate::{
err_unrec, inf, inssort, mods::strs::prompt, mods::strs::sec, mods::strs::succ,
mods::uninstall::uninstall,
err_unrec, inf, inssort, mods::database::add_pkg, mods::strs::prompt, mods::strs::sec,
mods::strs::succ, mods::uninstall::uninstall,
};
use git2::Repository;
use moins::Moins;
@ -102,6 +102,11 @@ pub fn clone(noconfirm: bool, pkg: &str) {
match install_result {
Ok(_) => {
uninstall_make_depend(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_unrec(format!("Couldn't install {}", pkg));
@ -117,6 +122,11 @@ pub fn clone(noconfirm: bool, pkg: &str) {
match install_result.code() {
Some(0) => {
uninstall_make_depend(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(_) => {
err_unrec(format!("Couldn't install {}", pkg));

@ -0,0 +1,54 @@
use crate::{err_unrec, inf};
use std::fs::File;
use std::io::{Error, Write};
use toml_edit::{value, Document};
pub fn rem_pkg(pkgs: &Vec<String>) {
let file = format!("{}/.local/ame/aurPkgs.db", std::env::var("HOME").unwrap());
let database = std::fs::read_to_string(&file).expect("Can't Open Database");
let mut update_database = database;
for i in pkgs {
if update_database.contains(i) {
let results = raur::search(&i);
for res in &results {
let database_entry = format!(
"{} = {{ name = \"{}\", version = \"{}\"}}\n",
&res[0].name, &res[0].name, &res[0].version
);
update_database = format!("{}", update_database.replace(&database_entry, ""));
}
}
}
let file_as_path = File::create(std::path::Path::new(&file)).unwrap();
let db_update_res = write!(&file_as_path, "{}", update_database);
match db_update_res {
Ok(_) => inf(format!("Database update successful")),
Err(_) => err_unrec(format!("Couldn't update database")),
}
}
pub fn add_pkg(from_repo: bool, pkg: &str) -> Result<(), Error> {
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 mut file_as_path = File::create(std::path::Path::new(&file))?;
let mut db_parsed = database.parse::<Document>().expect("invalid Database");
if from_repo == false {
let results = raur::search(&pkg);
for res in &results {
for r in res {
db_parsed[&r.name]["name"] = value(&r.name);
db_parsed[&r.name]["version"] = value(&r.version);
}
}
} 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};
use crate::mods::{
database::rem_pkg,
strs::{err_rec, err_unrec, sec, succ},
};
use runas::Command;
use std::{fs, path::Path};
@ -15,10 +18,13 @@ pub fn uninstall(noconfirm: bool, pkgs: Vec<String>) {
.status()
.expect("Couldn't call pacman");
match result.code() {
Some(0) => succ(format!(
"Succesfully uninstalled packages: {}",
&pkgs.join(" ")
)),
Some(0) => {
succ(format!(
"Succesfully uninstalled packages: {}",
&pkgs.join(" ")
));
rem_pkg(&pkgs);
}
Some(_) => err_rec(format!("Couldn't uninstall packages: {}", &pkgs.join(" "))),
None => err_rec(format!("Couldn't uninstall packages: {}", &pkgs.join(" "))),
};
@ -29,10 +35,13 @@ pub fn uninstall(noconfirm: bool, pkgs: Vec<String>) {
.status()
.expect("Couldn't call pacman");
match result.code() {
Some(0) => succ(format!(
"Succesfully uninstalled packages: {}",
&pkgs.join(" ")
)),
Some(0) => {
succ(format!(
"Succesfully uninstalled packages: {}",
&pkgs.join(" ")
));
rem_pkg(&pkgs);
}
Some(_) => err_rec(format!("Couldn't uninstall packages: {}", &pkgs.join(" "))),
None => err_rec(format!("Couldn't uninstall packages: {}", &pkgs.join(" "))),
};

@ -1,20 +1,43 @@
use crate::mods::strs::{err_unrec, inf, sec, succ};
//use crate::mods::strs::{err_unrec, inf, sec, succ};
use crate::{
err_unrec, inf, inssort, mods::strs::prompt, mods::strs::sec, mods::strs::succ, uninstall,
};
use git2::Repository;
use runas::Command;
use std::{env, fs};
use std::{env, fs, path::Path};
use toml;
fn uninstall_make_depend(pkg: &str) {
let make_depends = raur::info(&[&pkg]).unwrap()[0].make_depends.clone();
if make_depends.len() != 0 {
inf(format!(
"{} installed following make dependencies: {}",
pkg,
make_depends.join(", ")
));
let remove = prompt(format!("Would you like to remove them?"));
if remove == true {
uninstall(true, make_depends);
}
}
succ(format!("Succesfully upgraded {}", pkg));
}
pub fn upgrade(noconfirm: bool) {
let homepath = std::env::var("HOME").unwrap();
let cachedir = format!("/{}/.cache/ame/", homepath);
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 database = std::fs::read_to_string(&file).expect("Can't open database");
let db_parsed = database.parse::<toml::Value>().expect("Invalid Database");
if cache_exists == false {
let cachecreate = fs::create_dir_all(&cachedir);
match cachecreate {
Ok(_) => {
inf(format!("Creating cachedir. (didn't exist previously)"))
Ok(_) => 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"));
if noconfirm == true {
@ -40,47 +63,155 @@ pub fn upgrade(noconfirm: bool) {
};
}
for file in std::fs::read_dir(&cachedir).unwrap() {
let dir = &file.unwrap().path();
let output = std::process::Command::new("git")
.arg("pull")
.output()
.unwrap();
let update_available = String::from_utf8(output.stdout).unwrap();
println!("{:?}", db_parsed);
for entry in db_parsed.as_table() {
for (key, value) in &*entry {
let results = raur::search(format!("{}", key));
for res in results {
println!("{}", &res[0].name);
let url = format!("https://aur.archlinux.org/{}.git", key);
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 name = value
.to_string()
.replace("name", "")
.replace("version", "")
.replace(" = ", "")
.replace("\"", "")
.replace(format!("{}", &res[0].version.to_string()).as_str(), "");
println!("{} / {}", name, version);
if res[0].version.contains(&version) {
let keydir = format!("{}{}", &cachedir, &key);
if std::path::Path::new(&keydir).is_dir() {
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 cd_result = env::set_current_dir(&dir);
match cd_result {
Ok(_) => inf(format!("Entered AUR package directory to pull changes")),
Err(_) => err_unrec(format!(
"Could not enter AUR package directory to pull changes"
)),
}
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));
}
};
if update_available != "Already up to date." {
let path_as_str = &dir.display().to_string();
let pkg: Vec<&str> = path_as_str.split("/").collect();
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));
inf(format!("{} is up to date", pkg[pkg.len() - 1]));
} else {
let cd2_result = env::set_current_dir(&dir);
match cd2_result {
Ok(_) => inf(format!(
"Entering AUR package directory to install new version"
)),
Err(_) => err_unrec(format!(
"Couldn't enter AUR package directory to install new version"
)),
}
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")),
}
let makepkg_result = std::process::Command::new("makepkg")
.arg("-si")
.status()
.expect("Couldn't call makepkg");
match makepkg_result.code() {
Some(0) => succ(format!("New AUR package version installed")),
Some(_) => err_unrec(format!("Couldn't install new AUR package version")),
None => err_unrec(format!("Couldn't install new AUR package version")),
};
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;
pub fn ver() {
println!("");
inf(format!("ame - v2.3.2"));
inf(format!("ame - v2.4.0"));
println!("");
inf(format!("Contributors:"));
println!("- axtlos <axtlos@salyut.one>");

Loading…
Cancel
Save