* Properly named dblb API and docs

dblib/src/lib.rs

@@ -1,6 +1,7 @@
 use std::error::Error;
 use std::fs::File;
 use std::io::BufReader;
+use std::io::BufWriter;
 use std::io::prelude::*;
 
 use serde::{Serialize, Deserialize};
@@ -20,58 +21,75 @@ fn dev_urandom() -> std::io::Result<String> {
 }
 
 
+#[derive(Clone, Serialize, Deserialize)]
+pub struct ApiKey {
+    // Owner of the key
+    name: String,
+    // The secret value of the key itself
+    key: String,
+}
 #[derive(Serialize, Deserialize)]
 pub struct DB {
-    keys: Vec<String>
+    keys: Vec<ApiKey>
 }
 
 
 impl DB {
-    pub fn new_entry(filename: String) -> Result<String, Box<dyn Error>> {
+    pub fn new_entry(filename: String, name: String) -> Result<String, Box<dyn Error>> {
+        //! Create a new API key entry in the data-store given by <filename>
+        //! Key value is generated via /dev/urandom on unix systems
         let file = File::open(filename.as_str())?;
         let reader = BufReader::new(file);
 
         let mut data: DB = serde_json::from_reader(reader)?;
         // Generate some new key data
-        let key = dev_urandom(); // create a new key
+        let key = dev_urandom().unwrap(); // create a new key
-        // Add that new key to the json file 
+        let entry = ApiKey { key: key.clone(), name };
-        match key {
-            Ok(key) => {
-                data.keys.push(key.clone());
 
-                let file = File::open(filename)?;
+        // Finally write back the data to the structure and disk
-                serde_json::to_writer(file, &data)?;
+        data.keys.push(entry);
+        let file = File::open(filename.as_str())?;
+        let writer = BufWriter::new(file);
+        serde_json::to_writer(writer, &data)?;
 
-                return Ok(key)
+        Ok(key)
-            },
-            Err(e) => {
-                panic!()
-            }
-        }
     }
 
-    pub fn remove_entry(filename: String, key: String) -> Result<(), Box<dyn Error>> {
+    pub fn remove_entry(filename: String, name: String) -> Result<bool, Box<dyn Error>> {
+        //! Removes the API key entry based on the given name 
         let file = File::open(filename.as_str())?;
         let reader = BufReader::new(file);
 
         let mut data: DB  = serde_json::from_reader(reader)?;
-        let idx = data.keys.iter().position(|item| key == key);
+        let idx = data.keys.iter().position(|item| item.name == name);
         if let Some(idx) = idx {
             data.keys.remove(idx);
+            Ok(true)
+        } else {
+            Ok(false)
+        }
     }
 
-        Ok(())
+    pub fn get_entry(filename: String, name: String) -> Result<Option<String>, Box<dyn Error>> {
-    }
+        //! Get the API key based on name
-
-    pub fn get_entry(filename: String, key: String) -> Result<Option<String>, Box<dyn Error>> {
         let file = File::open(filename.as_str())?;
         let reader = BufReader::new(file);
 
         let data: DB = serde_json::from_reader(reader)?;
         // WARNING: extreme autism
-        match data.keys.iter().find(|item| item.clone() == &key) {
+        match data.keys.iter().find(|item| item.name == name) {
-            Some(item) => Ok(Some(item.clone())),
+            Some(item) => Ok(Some(item.key.clone())),
             None => Ok(None)
         }
     }
+
+    pub fn new_store(filename: String) -> Result<(), Box<dyn Error>> {
+        //!  Generate a new empty data store with the given filename
+        //! NOTE: The filename must include the extension(programmatically)
+        let file = File::create(filename)?;
+        let empty = DB { keys: vec![] };
+        let writer = BufWriter::new(file);
+        serde_json::to_writer(writer, &empty)?;
+        Ok(())
+    }
 }