feat: storage trait

- storage trait
- json storage implementation

Author: lzldev

src/actions.rs

@@ -1,41 +1,40 @@
-use std::fs::File;
-use std::io::Write;
 use std::path::Path;
 
-use json::JsonValue;
 use seahorse::{ActionError, ActionResult, Context};
 
 use crate::config::get_config_path;
 use crate::error::invalid;
-use crate::json_object::{get_json_object_or_create, set_json_object};
+use crate::storage::json::CfsJSONStore;
+use crate::storage::{CfsStorage, CfsValue};
 
-pub fn init_action(c: &Context) -> ActionResult {
+pub fn init_action(_c: &Context) -> ActionResult {
 	let config_path = get_config_path();
 	let path = Path::new(&config_path);
 
 	if path.exists() {
 		println!("config file already exists");
-	} else {
-		clear_action(c)?;
 	}
 
+	CfsJSONStore::with_force_create(true);
+
 	Ok(())
 }
 
 pub fn list_action(c: &Context) -> ActionResult {
-	let conf = get_json_object_or_create(c.bool_flag("force-create"));
+	let store = CfsJSONStore::with_force_create(c.bool_flag("force-create"));
 
-	for (key, value) in conf.entries() {
+	for (key, value) in store.all().iter() {
 		println!("{}\t{}", key, value);
 	}
 
 	Ok(())
 }
 
 pub fn clear_action(_c: &Context) -> ActionResult {
-	let mut file = File::create(get_config_path()).unwrap();
+	let mut store = CfsJSONStore::new();
+
+	store.clear();
 
-	write!(file, "{}", "{}").expect("couldn't overwrite config file");
 	println!("cleared config file at '{:?}'", get_config_path());
 
 	Ok(())
@@ -46,24 +45,29 @@ pub fn get_action(c: &Context) -> ActionResult {
 		return Err(invalid("command"));
 	}
 
-	let conf = get_json_object_or_create(c.bool_flag("force-create"));
-	let key = c.args.get(0);
+	let key = c.args.get(0).to_owned();
 
 	let Some(key) = key else {
 		return Err(invalid("key"));
 	};
 
-	if conf.has_key(&key) {
-		println!("{}", conf[key]);
-		return Ok(());
-	}
-
-	if c.bool_flag("ignore-null") {
-		println!();
-	} else {
-		return Err(ActionError {
-			message: format!("could not find key '{}'", key),
-		});
+	let store = CfsJSONStore::new();
+
+	let value = store.get(key);
+
+	match value {
+		Some(v) => {
+			println!("{}", v)
+		}
+		None => {
+			if c.bool_flag("ignore_null") {
+				println!();
+			} else {
+				return Err(ActionError {
+					message: format!("could not find key '{}'", key),
+				});
+			}
+		}
 	}
 
 	Ok(())
@@ -74,8 +78,6 @@ pub fn set_action(c: &Context) -> ActionResult {
 		return Err(invalid("command"));
 	}
 
-	let mut conf = get_json_object_or_create(c.bool_flag("force-create"));
-
 	let Some(key) = c.args.get(0) else {
 		return Err(invalid("key"));
 	};
@@ -84,39 +86,28 @@ pub fn set_action(c: &Context) -> ActionResult {
 		return Err(invalid("value"));
 	};
 
-	let json_value = JsonValue::from(value_str.as_str());
-	let value = json_value.as_str().unwrap();
+	let mut store = CfsJSONStore::new();
 
-	if conf.has_key(key) {
-		conf.remove(key);
-	}
-
-	conf.insert(key, value).unwrap();
+	let value = CfsValue::Value(value_str.to_owned());
+	store.set(key, value.clone());
 
-	match set_json_object(conf) {
-		Ok(_) => println!("'{}' -> '{}'", key, value),
-		Err(err) => eprintln!("{}", err),
-	}
+	println!("{}\t{}", key, value);
 
 	Ok(())
 }
 
 pub fn remove_action(c: &Context) -> ActionResult {
-	let mut conf = get_json_object_or_create(c.bool_flag("force-create"));
 	let Some(key) = c.args.get(0) else {
 		return Err(invalid("key"));
 	};
 
-	if !conf.has_key(&key) {
-		println!("key '{}' was not found", key);
-		return Ok(());
-	}
-
-	conf.remove(&key);
+	let mut store = CfsJSONStore::new();
 
-	match set_json_object(conf) {
-		Ok(_) => println!("updated config file"),
-		Err(err) => eprintln!("{}", err),
+	match store.remove(key) {
+		Some(value) => println!("{}\t{}", key, value),
+		None => {
+			println!("key '{}' was not found", key);
+		}
 	}
 
 	Ok(())

src/json_object.rs

@@ -9,7 +9,7 @@ mod commands;
 mod config;
 mod error;
 mod flags;
-mod json_object;
+mod storage;
 
 fn main() -> ActionResult {
 	let args: Vec<String> = env::args().collect();
@@ -26,10 +26,12 @@ fn main() -> ActionResult {
 		.command(clear());
 
 	match app.run_with_result(args) {
-		Ok(_) => Ok(()),
+		Ok(_) => (),
 		Err(action_error) => {
 			eprintln!("{}", action_error.message);
 			exit(1)
 		}
-	}
+	};
+
+	Ok(())
 }

src/main.rs

@@ -0,0 +1,103 @@
+use std::fs::{read_to_string, File};
+use std::io;
+use std::io::Write;
+use std::process::exit;
+
+use json::JsonValue;
+
+use crate::config::get_config_path;
+use crate::storage::{CfsStorage, CfsValue};
+
+pub fn init_store(force_create: bool) -> JsonValue {
+	let path = get_config_path();
+
+	if !path.exists() && force_create {
+		let mut file = File::create(get_config_path()).unwrap();
+		write!(file, "{}", "{}").unwrap();
+	} else if !path.exists() {
+		eprintln!("config file does not exist at '{:?}'", &path);
+		exit(1);
+	}
+
+	let json = json::parse(&read_to_string(&path).unwrap()).unwrap();
+
+	if !json.is_object() {
+		eprintln!("config file is not a JSON file ('{:?}')", &path);
+		exit(1);
+	}
+
+	json
+}
+
+#[derive(Clone, Debug)]
+pub struct CfsJSONStore {
+	store: JsonValue,
+}
+
+impl CfsJSONStore {
+	pub fn new() -> Self {
+		return Self {
+			store: init_store(false),
+		};
+	}
+
+	pub fn with_force_create(force_create: bool) -> Self {
+		return Self {
+			store: init_store(force_create),
+		};
+	}
+
+	fn save_store(&mut self) -> Result<(), io::Error> {
+		let mut file = File::create(get_config_path())?;
+
+		let json_string = json::stringify_pretty(self.store.clone(), 2);
+
+		write!(file, "{}", json_string)?;
+
+		Ok(())
+	}
+}
+
+impl CfsStorage for CfsJSONStore {
+	fn all(&self) -> Vec<(String, CfsValue)> {
+		self
+			.store
+			.entries()
+			.map(|(key, value)| (key.to_owned(), value.into()))
+			.collect()
+	}
+
+	fn get(&self, key: &str) -> Option<CfsValue> {
+		if !self.store.has_key(key) {
+			return None;
+		}
+
+		Some(self.store[key].clone().into())
+	}
+
+	fn set(&mut self, key: &str, value: CfsValue) -> CfsValue {
+		self.store.insert(key, value.clone()).unwrap();
+
+		self.save_store().unwrap();
+
+		value
+	}
+
+	fn remove(&mut self, key: &str) -> Option<CfsValue> {
+		if !self.store.has_key(key) {
+			return None;
+		}
+
+		let value = self.store.remove(key);
+
+		self.save_store().unwrap();
+
+		return Some(value.into());
+	}
+
+	fn clear(&mut self) {
+		self.store.clear();
+
+		self.save_store().unwrap();
+	}
+}

src/storage/json.rs

@@ -0,0 +1,14 @@
+pub mod json;
+mod value;
+
+pub use value::CfsValue;
+
+pub trait CfsStorage {
+	fn all(&self) -> Vec<(String, CfsValue)>;
+
+	fn get(&self, key: &str) -> Option<CfsValue>;
+	fn set(&mut self, key: &str, value: CfsValue) -> CfsValue;
+	fn remove(&mut self, key: &str) -> Option<CfsValue>;
+
+	fn clear(&mut self);
+}