Add files via upload

Author: quadroli

Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "dibz"
+version = "0.1.0"
+authors = ["limisi"]
+edition = "2018"
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+text_io = "0.1.8"
+pickledb = "0.4.1"
+dirs = "3.0.1"

src/analysis.rs

@@ -0,0 +1,43 @@
+pub mod analysis {
+
+    use pickledb::PickleDb;
+    pub fn mean(mydb: &PickleDb, total: u16) -> f64 {
+        let wosh = total as f64;
+        let mash = mydb.total_keys() as f64;
+        wosh / mash
+    }
+
+    pub fn sum(mydb: &PickleDb) -> u16 {
+        let mut val: u16;
+        let mut total: u16 = 0;
+        for kv in mydb.iter() {
+            val = kv.get_value().unwrap();
+            total = val + total;
+        }
+        total
+    }
+
+    pub fn median(mosh: Vec<u16>) {
+        if mosh.len() % 2 != 0 {
+            println!("Median is = {}", mosh[mosh.len() / 2 - 1]);
+        } else if mosh.len() % 2 == 0 {
+            let mido = (mosh[mosh.len() / 2] + mosh[mosh.len() / 2 - 1]) / 2;
+            println!("Median is = {}", mido);
+        }
+    }
+
+    pub fn fill_in(mydb: &PickleDb) -> Vec<u16> {
+        let mut mosh: Vec<u16> = Vec::new();
+        for kv in mydb.iter() {
+            mosh.push(kv.get_value().unwrap());
+        }
+        mosh.sort();
+        mosh
+    }
+
+    pub fn extreme_vals(mosh: Vec<u16>) {
+        println!("Biggest amount is = {}", mosh.iter().max().unwrap());
+        println!();
+        println!("Smallest amount is = {}", mosh.iter().min().unwrap());
+    }
+}

src/internals.rs

@@ -0,0 +1,99 @@
+pub mod internals {
+
+    use pickledb::{PickleDb, PickleDbDumpPolicy, SerializationMethod};
+    use std::path::Path;
+    use text_io::read;
+
+    pub fn lookup(name: &str, mydb: &PickleDb) {
+        match mydb.get::<u16>(name) {
+            Some(v) => {
+                println!("{}'s amount is {}", name, v)
+            }
+            None => {
+                println!("No such entry")
+            }
+        };
+    }
+
+    pub fn remove(name: &str, mydb: &mut PickleDb) {
+        match mydb.rem(name) {
+            Ok(v) => {
+                println!();
+                if v {
+                    println!("{} has been successfully removed", name)
+                } else {
+                    println!("Record does not exist")
+                }
+            }
+            Err(e) => {
+                println!("Error, failed due to: {}", e)
+            }
+        };
+    }
+
+    pub fn update(mydb: &mut PickleDb) {
+        println!();
+        println!("Input name followed by amount");
+        let name: String = read!();
+        let named = capup(&name);
+        let amount: u16 = read!();
+        println!();
+        if mydb.exists(&named[0..named.len()]) {
+            mydb.set(&named[0..named.len()], &amount).unwrap();
+            println!("{} successfully updated", named)
+        } else {
+            mydb.set(&named[0..named.len()], &amount).unwrap();
+            println!("{} successfully added", named)
+        }
+    }
+
+    fn iterate(mydb: &PickleDb) {
+        for kv in mydb.iter() {
+            match kv.get_key() {
+                _ => print!("{}", kv.get_key()),
+            }
+            print!(" ");
+        }
+        println!();
+        println!();
+    }
+
+    pub fn bc_handler(val: &str, mydb: &PickleDb) {
+        println!();
+        println!("These are the available records: ");
+        iterate(mydb);
+        println!("What name do you want to {}?", val);
+    }
+
+    pub fn initdb() -> PickleDb {
+        let mydb: PickleDb;
+        let root = dirs::config_dir().unwrap();
+        let the_way = root.to_str().unwrap();
+        let true_way = the_way.to_owned();
+        let the_path = true_way + "/.mydb";
+        if !Path::new(&the_path[0..the_path.len()]).is_file() {
+            mydb = PickleDb::new(
+                the_path,
+                PickleDbDumpPolicy::AutoDump,
+                SerializationMethod::Cbor,
+            )
+        } else {
+            mydb = PickleDb::load(
+                the_path,
+                PickleDbDumpPolicy::AutoDump,
+                SerializationMethod::Cbor,
+            )
+            .unwrap()
+        }
+        mydb
+    }
+
+    pub fn capup(name: &String) -> String {
+        let (first, suffix) = name.split_at(1);
+        let cap = first.to_uppercase();
+        let downfix = suffix.to_lowercase();
+        let captup: String = cap + &downfix;
+
+        captup
+    }
+}

src/main.rs

@@ -0,0 +1,74 @@
+use text_io::read;
+mod analysis;
+use analysis::analysis::{extreme_vals, fill_in, mean, median, sum};
+mod internals;
+use internals::internals::{bc_handler, capup, initdb, lookup, remove, update};
+
+fn main() {
+    println!("What would you love to do today?");
+    prompt();
+    loop {
+        choices();
+        println!();
+        println!("More operations? (y/n)");
+        let ans: String = read!();
+        if ans == "n" {
+            println!();
+            println!("Goodbye, see you later i hope :)");
+            break;
+        } else if ans == "y" {
+            println!();
+            prompt();
+            continue;
+        } else {
+            println!();
+            println!("Back to the menu we go :)");
+            println!();
+            prompt();
+        }
+    }
+}
+fn prompt() {
+    println!("(a)input/update records     (b)look up a record");
+    println!("   (c)delete records           (d)analysis");
+}
+
+fn choices() {
+    let mut mydb = initdb();
+    let choice: String = read!();
+    let name: String;
+    if choice == "a" {
+        update(&mut mydb);
+    } else if choice == "b" {
+        bc_handler("look up", &mydb);
+        name = read!();
+        println!();
+        let named = capup(&name);
+        lookup(&named[0..named.len()], &mydb);
+    } else if choice == "c" {
+        bc_handler("remove", &mydb);
+        name = read!();
+        let named = capup(&name);
+        remove(&named[0..named.len()], &mut mydb);
+        println!("Current number of records left: {}", mydb.total_keys());
+    } else if choice == "d" && mydb.total_keys() > 1 {
+        let total = sum(&mydb);
+        println!();
+        println!("Total number of records is {}", mydb.total_keys());
+        println!();
+        println!("The total amount is = {}", total);
+        println!();
+        println!("The mean is = {}", mean(&mydb, total));
+        println!();
+        median(fill_in(&mydb));
+        println!();
+        extreme_vals(fill_in(&mydb));
+    } else if choice == "d" && mydb.total_keys() < 2 {
+        println!(":( Not enough records");
+    } else {
+        println!("Invalid input!!!");
+        println!();
+        println!("heh, heh, back to prompt :)");
+        println!();
+    }
+}