crystal-linux-mirror
/
amethyst
mirror of https://git.getcryst.al/crystal/software/amethyst.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

rework database to use sql

Browse Source
i18n
Amy 3 years ago
parent 840de5ce76
commit 01beec5d0f
No known key found for this signature in database
GPG Key ID: 6672E6DD65BEA50B
8 changed files with 104 additions and 154 deletions
Show Stats Download Patch File Download Diff File

2
.gitignore vendored
Unescape Escape View File

@ -2,3 +2,5 @@ target/
Cargo.lock Cargo.lock
ame ame
.vscode .vscode
aur_pkgs.db
test.sql

3
Cargo.toml
Unescape Escape View File

@ -18,4 +18,5 @@ toml_edit = "*"
toml = "*" toml = "*"
bytes = "*" bytes = "*"
nix = "*" nix = "*"
clap = "*" clap = "*"
sqlite = "*"

0
dump
Unescape Escape View File

16
src/main.rs
Unescape Escape View File

@ -22,7 +22,12 @@ use mods::{
update::update, update::update,
upgrade::upgrade, upgrade::upgrade,
ver::ver, ver::ver,
xargs::* xargs::*,
statpkgs::rebuild,
database::{
add_pkg,
create_database,
},
}; };
use std::{ use std::{
env, env,
@ -43,6 +48,11 @@ fn main() {
exit(1); exit(1);
} }
let file = format!("{}/crystal/ame/aur_pkgs.db", env::var("HOME").unwrap());
if !std::path::Path::new(&file).exists() {
create_database();
}
let oper = &args[0]; let oper = &args[0];
let noconfirm: bool = noconf(&args); let noconfirm: bool = noconf(&args);
@ -54,6 +64,10 @@ fn main() {
"-Sl" | "-Sln" | "insl" => { "-Sl" | "-Sln" | "insl" => {
inssort_from_file(noconfirm, false, &pkgs[0]); // install from file inssort_from_file(noconfirm, false, &pkgs[0]); // install from file
} }
"-B" | "-Bn" | "build" => {
//rebuild(noconfirm); // install as a dependency
add_pkg(noconfirm, &pkgs[0]);
}
"-R" | "-Rn" | "rm" => { "-R" | "-Rn" | "rm" => {
uninstall(noconfirm, pkgs); // uninstall uninstall(noconfirm, pkgs); // uninstall
} }

3
src/mods.rs
Unescape Escape View File

@ -11,4 +11,5 @@ pub mod update;
pub mod upgrade; pub mod upgrade;
pub mod ver; pub mod ver;
pub mod xargs; pub mod xargs;
pub mod purge; pub mod purge;
pub mod statpkgs;

18
src/mods/clone.rs
Unescape Escape View File

@ -134,11 +134,7 @@ pub fn clone(noconfirm: bool, as_dep: bool, pkg: &str) { // clone a package from
match install_result { match install_result {
Ok(_) => { Ok(_) => {
uninstall_make_depend(pkg); uninstall_make_depend(pkg);
let add_pkg_res = add_pkg(false, pkg); 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));
@ -154,11 +150,7 @@ pub fn clone(noconfirm: bool, as_dep: bool, pkg: &str) { // clone a package from
match install_result.code() { match install_result.code() {
Some(0) => { Some(0) => {
uninstall_make_depend(pkg); uninstall_make_depend(pkg);
let add_pkg_res = add_pkg(false, pkg); 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));
@ -179,11 +171,7 @@ pub fn clone(noconfirm: bool, as_dep: bool, pkg: &str) { // clone a package from
match install_result { match install_result {
Ok(_) => { Ok(_) => {
uninstall_make_depend(pkg); uninstall_make_depend(pkg);
let add_pkg_res = add_pkg(false, pkg); 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));

213
src/mods/database.rs
Unescape Escape View File

@ -1,18 +1,11 @@
use crate::{err_unrec, inf}; use crate::{err_unrec, inf};
use std::{fs, io::{Error, Write}, env, path}; use std::{fs, env};
use toml_edit::{value, Document};
use crate::mods::strs::{err_rec};
pub fn get_value(pkg: &str, sear_value: &str) -> String { // Get specific value from database pub fn create_database() {
let homepath = env::var("HOME").unwrap(); let homepath = env::var("HOME").unwrap();
let file = format!("{}/.local/ame/aurPkgs.db", env::var("HOME").unwrap()); let file = format!("{}/crystal/ame/aur_pkgs.db", env::var("HOME").unwrap());
let mut database = String::new(); if !std::path::Path::new(&format!("{}/.local/ame/", env::var("HOME").unwrap())).is_dir() {
match path::Path::new(&file).exists() { let _cdar = fs::create_dir_all(format!("/{}/.local/ame/",homepath));
true => {
database = fs::read_to_string(&file).expect("Can't Open Database");
}
false => {
let _cdar = fs::create_dir_all(format!("/{}/.local/ame/",homepath));
match _cdar { match _cdar {
Ok(_) => { Ok(_) => {
inf(format!("Created path for database (previously missing)")) inf(format!("Created path for database (previously missing)"))
@ -21,152 +14,100 @@ pub fn get_value(pkg: &str, sear_value: &str) -> String { // Get specific value
err_unrec(format!("Couldn't create path for database (~/.local/ame)")) err_unrec(format!("Couldn't create path for database (~/.local/ame)"))
} }
} }
err_rec(String::from("Database wasn't found, creating new one"));
let _dbfile = fs::File::create(&file);
match _dbfile {
Ok(_) => {
inf(format!("Created empty database (previously missing)"))
}
Err(_) => {
err_unrec(format!("Couldn't create database"))
}
}
}
} }
let db_parsed = database.parse::<toml::Value>().expect("Invalid Database"); let connection = sqlite::open(file).unwrap();
connection.execute(
"
CREATE TABLE pkgs (name TEXT, version TEXT);
",
)
.unwrap();
}
pub fn get_value(pkg: &str, sear_value: &str) -> String {
let file = format!("{}/crystal/ame/aur_pkgs.db", env::var("HOME").unwrap());
let connection = sqlite::open(file).unwrap();
let mut return_val = String::new(); let mut return_val = String::new();
for entry in db_parsed.as_table() { match sear_value {
for (key, value) in &*entry { "name" => {
if key.contains(pkg) { let result = connection.iterate(format!("SELECT name FROM pkgs WHERE name = {};",&pkg), |pairs| {
let results = raur::search(format!("{}",key)); for &(column, value) in pairs.iter() {
for res in results { return_val = value.unwrap().to_string();
match sear_value {
"name" => {
return_val = value
.to_string()
.replace("name", "")
.replace("version", "")
.replace(" = ", "")
.replace("\"", "")
.replace(format!("{}", &res[0].version.to_string()).as_str(), "");
}
"version" => {
return_val = value
.to_string()
.replace("name", "")
.replace("version", "")
.replace(" = ", "")
.replace("\"", "")
.replace(format!("{}", &res[0].name.to_string()).as_str(), "");
}
_ => {
err_unrec(format!(""));
}
}
} }
true
} }
} );
} match result {
return return_val; Ok(_) => {}
}
pub fn rem_pkg(pkgs: &Vec<String>) { // Remove packages from database
let homepath = env::var("HOME").unwrap();
let file = format!("{}/.local/ame/aurPkgs.db", env::var("HOME").unwrap());
let mut database = String::new();
match path::Path::new(&file).exists() {
true => {
database = fs::read_to_string(&file).expect("Can't Open Database");
}
false => {
let _cdar = fs::create_dir_all(format!("/{}/.local/ame/",homepath));
match _cdar {
Ok(_) => {
inf(format!("Created path for database (previously missing)"))
}
Err(_) => { Err(_) => {
err_unrec(format!("Couldn't create path for database (~/.local/ame)")) err_unrec(format!("Couldn't get value from database"))
} }
} }
err_rec(String::from("Database wasn't found, creating new one")); },
let _dbfile = fs::File::create(&file); "version" => {
match _dbfile { let result = connection.iterate(format!("SELECT version FROM pkgs WHERE name = {};",&pkg), |pairs| {
Ok(_) => { for &(column, value) in pairs.iter() {
inf(format!("Created empty database (previously missing)")) return_val = value.unwrap().to_string();
} }
true
}
);
match result {
Ok(_) => {}
Err(_) => { Err(_) => {
err_unrec(format!("Couldn't create database")) err_unrec(format!("Couldn't get value from database"))
} }
} }
},
_ => {
return_val = "error".to_string();
} }
} }
return return_val;
}
pub fn rem_pkg(pkgs: &Vec<String>) {
let file = format!("{}/crystal/ame/aur_pkgs.db", env::var("HOME").unwrap());
let connection = sqlite::open(file).unwrap();
let mut update_database = database;
for i in pkgs { for i in pkgs {
if update_database.contains(i) { let result = connection.execute(
let results = raur::search(&i); format!("
for res in &results { DELETE FROM pkgs WHERE name = {};
let database_entry = format!( ", i),
"{} = {{ name = \"{}\", version = \"{}\"}}\n", );
&res[0].name, &res[0].name, &res[0].version match result{
); Ok(_) => {
update_database = format!("{}", update_database.replace(&database_entry, "")); inf(format!("Removed {} from database", i))
}
Err(_) => {
err_unrec(format!("Couldn't remove {} from database", i))
} }
} }
} }
let file_as_path = fs::File::create(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> { // Add package to database pub fn add_pkg(_from_repo: bool, pkg: &str) {
let homepath = env::var("HOME").unwrap(); let file = format!("{}/crystal/ame/aur_pkgs.db", env::var("HOME").unwrap());
let file = format!("{}/.local/ame/aurPkgs.db", env::var("HOME").unwrap()); let connection = sqlite::open(file).unwrap();
let mut database = String::new(); let results = raur::search(&pkg);
match path::Path::new(&file).exists() { let mut package_name = String::new();
true => { let mut package_version = String::new();
database = fs::read_to_string(&file).expect("Can't Open Database"); for res in &results {
} package_name = res[0].name.to_string();
false => { package_version = res[0].version.to_string();
let _cdar = fs::create_dir_all(format!("/{}/.local/ame/",homepath));
match _cdar {
Ok(_) => {
inf(format!("Created path for database (previously missing)"))
}
Err(_) => {
err_unrec(format!("Couldn't create path for database (~/.local/ame)"))
}
}
err_rec(String::from("Database wasn't found, creating new one"));
let _dbfile = fs::File::create(&file);
match _dbfile {
Ok(_) => {
inf(format!("Created empty database (previously missing)"))
}
Err(_) => {
err_unrec(format!("Couldn't create database"))
}
}
}
} }
let mut db_parsed = database.parse::<Document>().expect("Invalid Database"); let result = connection.execute(
let mut file_as_path = fs::File::create(path::Path::new(&file))?; format!("
if from_repo == false { INSERT INTO pkgs (name, version) VALUES (\"{}\", \"{}\");
let results = raur::search(&pkg); ", package_name, package_version),
for res in &results { );
db_parsed[&res[0].name]["name"] = value(&res[0].name); match result{
db_parsed[&res[0].name]["version"] = value(&res[0].version); Ok(_) => {
inf(format!("Added {} to database", package_name))
}
Err(_) => {
err_unrec(format!("Couldn't add {} to database", package_name))
} }
} else {
db_parsed[&pkg]["name"] = value(pkg);
db_parsed[&pkg]["version"] = value(pkg);
} }
file_as_path
.write_all(format!("{}", db_parsed).as_bytes())
.unwrap();
Ok(())
} }

3
src/mods/statpkgs.rs
Unescape Escape View File

@ -0,0 +1,3 @@
pub fn rebuild(noconfirm: bool) {
print!("installing crystal config")
}
Write Preview
Loading…
Cancel
Save