wip: add anyhow results to store trait

Author: lzldev

Cargo.toml

@@ -13,6 +13,7 @@ categories = ["command-line-utilities"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+anyhow = "1.0.102"
 json = "0.12.4"
 rusqlite = { version = "0.39.0", features = ["bundled"] }
 seahorse = "2.1.0"

src/actions.rs

@@ -2,8 +2,8 @@ use std::path::Path;
 
 use seahorse::{ActionError, ActionResult, Context};
 
-use crate::config::{get_config_path, get_db_path};
-use crate::error::invalid;
+use crate::config::get_db_path;
+use crate::error::{invalid, to_action_error};
 use crate::storage::sqlite::SQLiteStore;
 use crate::storage::{self, Store, StoreValue};
 
@@ -20,10 +20,10 @@ pub fn init_action(_c: &Context) -> ActionResult {
 	Ok(())
 }
 
-pub fn list_action(c: &Context) -> ActionResult {
+pub fn list_action(_c: &Context) -> ActionResult {
 	let store = storage::load_storage();
 
-	for (key, value) in store.all().iter() {
+	for (key, value) in store.all().map_err(to_action_error)?.iter() {
 		println!("{}\t{}", key, value);
 	}
 
@@ -33,9 +33,9 @@ pub fn list_action(c: &Context) -> ActionResult {
 pub fn clear_action(_c: &Context) -> ActionResult {
 	let mut store = storage::load_storage();
 
-	store.clear();
+	let count = store.clear().map_err(to_action_error)?;
 
-	println!("cleared config file at '{:?}'", get_config_path());
+	println!("removed {} keys from store", count);
 
 	Ok(())
 }
@@ -53,7 +53,7 @@ pub fn get_action(c: &Context) -> ActionResult {
 
 	let store = storage::load_storage();
 
-	let value = store.get(key);
+	let value = store.get(key).map_err(to_action_error)?;
 
 	match value {
 		Some(v) => {
@@ -89,7 +89,7 @@ pub fn set_action(c: &Context) -> ActionResult {
 	let mut store = storage::load_storage();
 
 	let value = StoreValue::Value(value_str.to_owned());
-	store.set(key, value.clone());
+	store.set(key, value.clone()).map_err(to_action_error)?;
 
 	println!("'{}' -> '{}'", key, value);
 
@@ -103,7 +103,7 @@ pub fn remove_action(c: &Context) -> ActionResult {
 
 	let mut store = storage::load_storage();
 
-	match store.remove(key) {
+	match store.remove(key).map_err(to_action_error)? {
 		Some(value) => println!("{}\t{}", key, value),
 		None => {
 			println!("key '{}' was not found", key);

src/error.rs

@@ -9,3 +9,9 @@ pub fn invalid(cause: &str) -> ActionError {
 		),
 	}
 }
+
+pub fn to_action_error(err: anyhow::Error) -> ActionError {
+	return ActionError {
+		message: err.to_string(),
+	};
+}

src/storage/json.rs

@@ -1,3 +1,5 @@
+use anyhow::Result;
+
 use std::fs::{read_to_string, File};
 use std::io;
 use std::io::Write;
@@ -59,45 +61,50 @@ impl JSONStore {
 }
 
 impl Store for JSONStore {
-	fn all(&self) -> Vec<(String, StoreValue)> {
-		self
-			.store
-			.entries()
-			.map(|(key, value)| (key.to_owned(), value.into()))
-			.collect()
+	fn all(&self) -> Result<Vec<(String, StoreValue)>> {
+		Ok(
+			self
+				.store
+				.entries()
+				.map(|(key, value)| (key.to_owned(), value.into()))
+				.collect(),
+		)
 	}
 
-	fn get(&self, key: &str) -> Option<StoreValue> {
+	fn get(&self, key: &str) -> Result<Option<StoreValue>> {
 		if !self.store.has_key(key) {
-			return None;
+			return Ok(None);
 		}
 
-		Some(self.store[key].clone().into())
+		Ok(Some(self.store[key].clone().into()))
 	}
 
-	fn set(&mut self, key: &str, value: StoreValue) -> StoreValue {
+	fn set(&mut self, key: &str, value: StoreValue) -> Result<StoreValue> {
 		self.store.insert(key, value.clone()).unwrap();
 
 		self.save_store().unwrap();
 
-		value
+		Ok(value)
 	}
 
-	fn remove(&mut self, key: &str) -> Option<StoreValue> {
+	fn remove(&mut self, key: &str) -> Result<Option<StoreValue>> {
 		if !self.store.has_key(key) {
-			return None;
+			return Ok(None);
 		}
 
 		let value = self.store.remove(key);
 
 		self.save_store().unwrap();
 
-		return Some(value.into());
+		return Ok(Some(value.into()));
 	}
 
-	fn clear(&mut self) {
+	fn clear(&mut self) -> Result<usize> {
+		let len = self.store.len();
 		self.store.clear();
 
 		self.save_store().unwrap();
+
+		return Ok(len);
 	}
 }

src/storage/mod.rs

@@ -1,3 +1,5 @@
+use anyhow::Result;
+
 pub mod json;
 pub mod sqlite;
 mod value;
@@ -7,13 +9,13 @@ pub use value::StoreValue;
 use crate::config::get_db_path;
 
 pub trait Store {
-	fn all(&self) -> Vec<(String, StoreValue)>;
+	fn all(&self) -> Result<Vec<(String, StoreValue)>>;
 
-	fn get(&self, key: &str) -> Option<StoreValue>;
-	fn set(&mut self, key: &str, value: StoreValue) -> StoreValue;
-	fn remove(&mut self, key: &str) -> Option<StoreValue>;
+	fn get(&self, key: &str) -> Result<Option<StoreValue>>;
+	fn set(&mut self, key: &str, value: StoreValue) -> Result<StoreValue>;
+	fn remove(&mut self, key: &str) -> Result<Option<StoreValue>>;
 
-	fn clear(&mut self);
+	fn clear(&mut self) -> Result<usize>;
 }
 
 //TODO: Change STORE Based on config.

src/storage/sqlite/mod.rs

@@ -1,3 +1,4 @@
+use anyhow::{anyhow, Result};
 use std::path::Path;
 
 use rusqlite::OptionalExtension as _;
@@ -17,78 +18,70 @@ impl SQLiteStore {
 			.execute_batch(include_str!("schema.sql"))
 			.expect("To Create DB");
 
-		return Self { connection: conn };
+		Self { connection: conn }
 	}
 }
 
 impl Store for SQLiteStore {
-	fn all(&self) -> Vec<(String, super::StoreValue)> {
-		let mut stmt = self.connection.prepare("SELECT key,value from KV").unwrap();
+	fn all(&self) -> Result<Vec<(String, super::StoreValue)>> {
+		let mut stmt = self.connection.prepare("SELECT key,value from KV")?;
 
 		let values = stmt
-			.query_map([], |row| {
-				let key: String = row.get(0)?;
-				let value = StoreValue::Value(row.get::<_, String>(1)?);
+			.query_map([], |row| Ok((row.get(0)?, StoreValue::Value(row.get(1)?))))?
+			.collect::<Result<Vec<_>, _>>()?;
 
-				return Ok((key, value));
-			})
-			.unwrap()
-			.collect::<Result<Vec<_>, _>>()
-			.unwrap();
-
-		return values;
+		Ok(values)
 	}
 
-	fn get(&self, key: &str) -> Option<super::StoreValue> {
+	fn get(&self, key: &str) -> Result<Option<super::StoreValue>> {
 		let stmt = self
 			.connection
 			.query_row(
 				"SELECT key,value from KV where key = ?1 LIMIT 1",
 				[key],
-				|row| Ok(StoreValue::Value(row.get(1).unwrap())),
+				|row| Ok(StoreValue::Value(row.get(1)?)),
 			)
-			.optional()
-			.unwrap();
+			.optional()?;
 
-		return stmt;
+		Ok(stmt)
 	}
 
-	fn set(&mut self, key: &str, value: super::StoreValue) -> super::StoreValue {
+	fn set(&mut self, key: &str, value: StoreValue) -> Result<StoreValue> {
 		let StoreValue::Value(value) = value else {
-			panic!("Invalid value passed into SQLiteStore GET [{}]", value)
+			return Err(anyhow!(
+				"Invalid value passed into SQLiteStore GET [{}]",
+				value
+			));
 		};
 
-		self
-			.connection
-			.execute(
-				"INSERT INTO KV VALUES(NULL,?1,?2) ON CONFLICT(key) DO UPDATE SET value = ?2 WHERE key = ?1",
-				[key, &value],
-			)
-			.unwrap();
+		self.connection.execute(
+			"INSERT INTO KV VALUES(NULL,?1,?2) ON CONFLICT(key) DO UPDATE SET value = ?2 WHERE key = ?1",
+			[key, &value],
+		)?;
 
-		return StoreValue::Value(value);
+		Ok(StoreValue::Value(value))
 	}
 
-	fn remove(&mut self, key: &str) -> Option<super::StoreValue> {
-		let value = self.get(key);
+	fn remove(&mut self, key: &str) -> Result<Option<StoreValue>> {
+		let value = self.get(key)?;
 
 		let Some(value) = value else {
-			return None;
+			return Ok(None);
 		};
 
 		let stmt = self
 			.connection
-			.execute("DELETE FROM KV where key = ?1", [key])
-			.unwrap();
+			.execute("DELETE FROM KV where key = ?1", [key])?;
 
 		if stmt == 0 {
 			panic!("Deleted 0 Rows when trying to delete Value from Store")
 		}
 
-		Some(value)
+		Ok(Some(value))
 	}
 
-	fn clear(&mut self) {
-		self.connection.execute("DELETE FROM KV", []).unwrap();
+	fn clear(&mut self) -> Result<usize> {
+		let deleted = self.connection.execute("DELETE FROM KV", [])?;
+		Ok(deleted)
 	}
 }