Feature/complete rewrite (#87)

* Migration to 0.4 and beginning of the pure component implementation

* Further refactoring

* Fixed errors to start the rework

* Further styling and refactoring

* Further refactoring

* further work

* Further progress towards the rewrite

* Further progress to make the cache object shareable through the views

* Further progress regarding the refactoring

* Disabled caching due to the complete rewrite

* Further work

* Simplified the catalog logic

* Further refactoring

* Re-enabled plugin installation

* Further progress

* Further progress

* Further progress

* Further progress

* Renaming and removal of unneccessary files.

* Progress

* Implemented a proper database trait for better testing

* Fixed tests

* Implemented integration tests for every cache function

* Further refactoring

* Some renaming. Set the foundation for the internal refactoring

* Further refactoring

* Further progress

* removed unneccessary test

* removed print statement

* simplified test

* Implemented installer tests and fixed bugs

* Moved central plugin struct into separate module

* More bug fixes

* More bugfixes

* removed print

* Removed print

* Added delete functionality

* renamed variable

* Further refinement

* Implemented the update all functionality

* Added db refresh functionality

* Fixed plugin deletion bug

Author: mawilms

Cargo.lock

@@ -22,14 +22,17 @@ exclude = [
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-iced = { version = "^0", features = ["tokio", "image"] }
+iced = { version = "^0", features = ["tokio", "image", "pure", "wgpu"] }
 reqwest = { version = "^0", features = ["blocking", "json"] }
+bytes = "^1"
 zip = "^0"
 serde = { version = "^1", features = ["derive"] }
 serde_json = "^1"
 serde-xml-rs = "^0"
 dirs = "^4"
 rusqlite = { version = "^0", features = ["bundled"] }
+r2d2 = "^0"
+r2d2_sqlite = "^0"
 futures = "^0"
 tokio = { version = "^1", features = ["full"]}
 image = "^0"
@@ -39,14 +42,11 @@ globset = "^0"
 chrono = "^0"
 log = { version = "^0", features = ["max_level_debug", "release_max_level_off"] }
 env_logger = "^0"
-uuid = { version = "^0", features = ["v4"] }
+uuid = { version = "^1", features = ["v4"] }
 walkdir = "^2"
 regex = "^1"
 itertools = "^0"
-
-[dev-dependencies]
-mockall = "^0"
-mockall_double = "^0"
+async-trait = "^0"
 
 [build-dependencies]
 embed-resource = "^1"

Cargo.toml

@@ -1,71 +1,108 @@
+//! # Config
+//!
+//! Contains the config logic that is used to determine the storage paths for the `settings` and `plugins` directory.
+//! The `settings` directory contains:
+//! - settings.json -> Contains all settings that is specified by the user in the `settings` view.
+//! - plugins.sqlite3 -> Contains the cache plugins which are installed on the users computer.
+//! - tmp/ -> Temporary directory that contains data which is created while installing new plugins.
+use dirs::{data_dir, home_dir};
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 use std::{
     fs::{self, write, File},
     io::Read,
 };
 
-use crate::gui::views::Paths;
+pub fn initialize_directories() {
+    let storage_dir = get_storage_dir();
 
-#[derive(Default, Debug, Clone)]
-pub struct Config {
-    pub settings: PathBuf,
-    pub plugins_dir: PathBuf,
-    pub db_file_path: PathBuf,
-    pub cache_dir: PathBuf,
-    pub application_settings: SettingsFile,
-}
+    fs::create_dir_all(&get_plugins_dir()).expect("Couldn't create the plugins folder");
+    fs::create_dir_all(&storage_dir).expect("Couldn't create the storage folder");
+    fs::create_dir_all(&storage_dir.join("tmp")).expect("Couldn't create the storage folder");
 
-impl Config {
-    pub fn new(paths: Paths) -> Self {
-        fs::create_dir_all(&paths.plugins).expect("Couldn't create the plugins folder");
-        fs::create_dir_all(&paths.settings).expect("Couldn't create the lembas settings folder");
-        fs::create_dir_all(&paths.cache).expect("Couldn't create the lembas cache folder");
-
-        let path = &paths.settings.join("plugins.sqlite3");
-
-        let mut initial_settings = SettingsFile::default();
-        let settings_file_path = &paths.settings.join("settings.json");
-
-        if settings_file_path.exists() {
-            let mut file = File::open(settings_file_path).unwrap();
-            let mut data = String::new();
-            file.read_to_string(&mut data).unwrap();
-            initial_settings = serde_json::from_str(&data).unwrap();
-        } else {
-            File::create(&settings_file_path).unwrap();
-            initial_settings.backup_enabled = true;
-            initial_settings.feed_url =
-                String::from("http://api.lotrointerface.com/fav/plugincompendium.xml");
-            write(
-                &settings_file_path,
-                serde_json::to_string(&initial_settings).unwrap(),
-            )
-            .unwrap();
-        }
+    let settings_file_path = &storage_dir.join("settings.json");
 
-        Self {
-            settings: paths.settings,
-            plugins_dir: paths.plugins,
-            db_file_path: path.clone(),
-            cache_dir: paths.cache,
-            application_settings: initial_settings,
-        }
+    if !settings_file_path.exists() {
+        create_existing_settings_file(settings_file_path);
     }
+}
 
-    pub fn save_changes(&self) {
-        let settings_file_path = &self.settings.join("settings.json");
+pub fn get_plugins_dir() -> PathBuf {
+    home_dir()
+        .expect("Couldn't find your home directory")
+        .join("Documents")
+        .join("The Lord of the Rings Online")
+        .join("Plugins")
+}
 
-        write(
-            &settings_file_path,
-            serde_json::to_string(&self.application_settings).unwrap(),
-        )
-        .unwrap();
-    }
+pub fn get_plugins_backup_dir() -> PathBuf {
+    home_dir()
+        .expect("Couldn't find your home directory")
+        .join("Documents")
+        .join("The Lord of the Rings Online")
+        .join("Plugins_Backup")
+}
+
+pub fn get_storage_dir() -> PathBuf {
+    data_dir().unwrap().join("lembas")
+}
+
+pub fn get_settings_file_path() -> PathBuf {
+    let storage_dir = get_storage_dir();
+
+    storage_dir.join("settings.json")
+}
+
+pub fn get_database_file_path() -> PathBuf {
+    let storage_dir = get_storage_dir();
+
+    storage_dir.join("plugins.sqlite3")
 }
 
-#[derive(Default, Debug, Clone, Serialize, Deserialize)]
+pub fn get_tmp_dir() -> PathBuf {
+    let storage_dir = get_storage_dir();
+
+    storage_dir.join("tmp")
+}
+
+pub fn save_settings_changes(settings: &SettingsFile) {
+    let settings_file_path = get_settings_file_path();
+
+    write(
+        &settings_file_path,
+        serde_json::to_string(&settings).unwrap(),
+    )
+    .unwrap();
+}
+
+fn create_existing_settings_file(settings_path: &PathBuf) {
+    let initial_settings = SettingsFile::default();
+    File::create(&settings_path).unwrap();
+    write(
+        &settings_path,
+        serde_json::to_string(&initial_settings).unwrap(),
+    )
+    .unwrap();
+}
+
+pub fn read_existing_settings_file() -> SettingsFile {
+    let mut file = File::open(get_settings_file_path()).unwrap();
+    let mut data = String::new();
+    file.read_to_string(&mut data).unwrap();
+    serde_json::from_str(&data).unwrap()
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SettingsFile {
     pub backup_enabled: bool,
     pub feed_url: String,
 }
+
+impl Default for SettingsFile {
+    fn default() -> Self {
+        Self {
+            backup_enabled: true,
+            feed_url: String::from("http://api.lotrointerface.com/fav/plugincompendium.xml"),
+        }
+    }
+}