Feature/minor improvements (#51)

Minor improvements with trait implementations for the upcoming 0.3 release with a test pipeline

Author: mawilms

.github/FUNDING.yml

@@ -0,0 +1 @@
+ko_fi: mawilms

Cargo.lock

@@ -33,6 +33,7 @@ webbrowser = "^0"
 fs_extra = "^1"
 globset = "^0"
 chrono = "^0"
+async-trait = "^0"
 
 [build-dependencies]
 embed-resource = "^1"

Cargo.toml

@@ -0,0 +1,66 @@
+use crate::core::{Base as BasePlugin, Plugin as DetailsPlugin};
+use async_trait::async_trait;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[async_trait]
+pub trait APIOperations {
+    async fn fetch_plugins() -> Result<HashMap<String, BasePlugin>, APIError>;
+
+    fn fetch_details(title: &str) -> DetailsPlugin;
+}
+
+pub struct APIConnector {}
+
+#[async_trait]
+impl APIOperations for APIConnector {
+    async fn fetch_plugins() -> Result<HashMap<String, BasePlugin>, APIError> {
+        match reqwest::get("https://young-hamlet-23901.herokuapp.com/plugins").await {
+            Ok(response) => match response.json::<HashMap<String, BasePlugin>>().await {
+                Ok(plugins) => Ok(plugins),
+                Err(_) => Err(APIError::FetchError),
+            },
+            Err(_) => Err(APIError::FetchError),
+        }
+    }
+
+    fn fetch_details(title: &str) -> DetailsPlugin {
+        let response = reqwest::blocking::get(format!(
+            "https://young-hamlet-23901.herokuapp.com/plugins/{}",
+            title.to_lowercase()
+        ))
+        .expect("Failed to connect with API")
+        .json::<JSONResponse>()
+        .expect("Failed to parse response");
+
+        DetailsPlugin::new(
+            response.plugin_id,
+            &response.title,
+            "",
+            &response.category,
+            &response.current_version,
+            &response.latest_version,
+            &response.folders,
+            &response.files,
+        )
+    }
+}
+
+#[derive(Default, Serialize, Deserialize, Debug, Clone, Eq, PartialEq, Hash, PartialOrd, Ord)]
+struct JSONResponse {
+    pub plugin_id: i32,
+    pub title: String,
+    #[serde(default)]
+    pub description: String,
+    pub category: String,
+    #[serde(default)]
+    pub current_version: String,
+    pub latest_version: String,
+    pub folders: String,
+    pub files: Vec<String>,
+}
+
+#[derive(Debug, Clone)]
+pub enum APIError {
+    FetchError,
+}

src/core/api_connector.rs

@@ -1,15 +1,19 @@
 use dirs::{cache_dir, data_dir, home_dir};
 use lazy_static::lazy_static;
 use serde::{Deserialize, Serialize};
+use std::path::Path;
 use std::sync::Mutex;
-use std::{fs::OpenOptions, path::Path};
 use std::{
     fs::{self, write, File},
     io::Read,
 };
 
+trait FileConfigurations {
+    fn new() -> Self;
+}
+
 lazy_static! {
-    pub static ref CONFIGURATION: Mutex<Config> = Mutex::new(Config::default());
+    pub static ref CONFIGURATION: Mutex<Config> = Mutex::new(Config::new());
 }
 
 #[derive(Debug, Clone)]
@@ -21,8 +25,8 @@ pub struct Config {
     pub application_settings: SettingsFile,
 }
 
-impl Default for Config {
-    fn default() -> Self {
+impl FileConfigurations for Config {
+    fn new() -> Self {
         let plugins_path = home_dir()
             .expect("Couldn't find your home directory")
             .join("Documents")

src/core/config.rs

@@ -107,7 +107,6 @@ impl Installer {
             .join(&folder_name)
             .exists()
         {
-            // TODO: Check if the options are really doing what I want
             fs::create_dir_all(
                 Path::new(&CONFIGURATION.lock().unwrap().plugins_dir).join(&folder_name),
             )

src/core/installer.rs

@@ -1,11 +1,13 @@
+pub mod api_connector;
 pub mod config;
 pub mod installer;
 pub mod plugin;
 pub mod plugin_parser;
 pub mod synchronizer;
 
+pub use api_connector::APIConnector;
 pub use config::Config;
 pub use installer::Installer;
-pub use plugin::{Base, Plugin, Installed};
+pub use plugin::{Base, Installed, Plugin};
 pub use plugin_parser::PluginParser;
 pub use synchronizer::Synchronizer;

src/core/mod.rs

@@ -1,11 +1,9 @@
+use super::api_connector::APIOperations;
 use super::plugin_parser::Information;
 use crate::core::config::CONFIGURATION;
-use crate::core::{
-    Base as BasePlugin, Installed as InstalledPlugin, Plugin as DetailsPlugin, PluginParser,
-};
+use crate::core::{APIConnector, Installed as InstalledPlugin, PluginParser};
 use globset::Glob;
 use rusqlite::{params, Connection, Statement};
-use serde::{Deserialize, Serialize};
 use std::{collections::HashMap, error::Error, fs::read_dir, path::Path};
 
 pub struct Synchronizer {}
@@ -25,14 +23,15 @@ impl Synchronizer {
         db_plugins: &HashMap<String, InstalledPlugin>,
     ) {
         for (key, element) in local_plugins {
-            let retrieved_plugin = Self::fetch_plugin_details(&element.name);
+            let retrieved_plugin = APIConnector::fetch_details(&element.name);
             if db_plugins.contains_key(key) {
                 let local_plugin = db_plugins.get(key).unwrap();
                 if local_plugin.latest_version != retrieved_plugin.base_plugin.latest_version {
                     Self::update_plugin(
                         &local_plugin.title,
                         &retrieved_plugin.base_plugin.latest_version,
-                    );
+                    )
+                    .unwrap();
                 }
             } else {
                 Self::insert_plugin(&InstalledPlugin::new(
@@ -78,56 +77,6 @@ impl Synchronizer {
         Ok(local_plugins)
     }
 
-    pub async fn fetch_plugins(
-    ) -> Result<HashMap<String, BasePlugin>, crate::core::synchronizer::APIError> {
-        match reqwest::get("https://young-hamlet-23901.herokuapp.com/plugins").await {
-            Ok(response) => match response.json::<HashMap<String, BasePlugin>>().await {
-                Ok(plugins) => Ok(plugins),
-                Err(_) => Err(APIError::FetchError),
-            },
-            Err(_) => Err(APIError::FetchError),
-        }
-    }
-
-    pub fn fetch_plugin_details(title: &str) -> DetailsPlugin {
-        let response = reqwest::blocking::get(format!(
-            "https://young-hamlet-23901.herokuapp.com/plugins/{}",
-            title.to_lowercase()
-        ))
-        .expect("Failed to connect with API")
-        .json::<JSONResponse>()
-        .expect("Failed to parse response");
-
-        DetailsPlugin::new(
-            response.plugin_id,
-            &response.title,
-            "",
-            &response.category,
-            &response.current_version,
-            &response.latest_version,
-            &response.folders,
-            &response.files,
-        )
-    }
-
-    // Used to synchronize the local database with the remote plugin server
-    pub async fn update_local_plugins() -> Result<(), ()> {
-        let fetched_plugins = Self::fetch_plugins().await;
-        let conn = Connection::open(&CONFIGURATION.lock().unwrap().db_file).unwrap();
-
-        if fetched_plugins.is_ok() {
-            for (_, plugin) in fetched_plugins.unwrap() {
-                let installed_plugin = Synchronizer::get_plugin(&plugin.title);
-                if !installed_plugin.is_empty()
-                    && installed_plugin[0].latest_version != plugin.latest_version
-                {
-                    conn.execute("UPDATE plugin SET current_version = ?1, latest_version = ?2 WHERE plugin_id = ?3", params![installed_plugin[0].description, plugin.latest_version, plugin.plugin_id]).unwrap();
-                }
-            }
-        }
-        Ok(())
-    }
-
     // Creates the local database if it doesn't exist.
     pub fn create_plugins_db() {
         let conn = Connection::open(&CONFIGURATION.lock().unwrap().db_file).unwrap();
@@ -228,32 +177,4 @@ impl Synchronizer {
         }
         plugins
     }
-
-    pub fn get_plugin(name: &str) -> Vec<InstalledPlugin> {
-        let conn = Connection::open(&CONFIGURATION.lock().unwrap().db_file).unwrap();
-        let mut stmt = conn
-            .prepare("SELECT plugin_id, title, description, category, current_version, latest_version, folder_name FROM plugin WHERE LOWER(title) = ?1")
-            .unwrap();
-
-        Self::execute_stmt(&mut stmt, &name.to_lowercase())
-    }
-}
-
-#[derive(Default, Serialize, Deserialize, Debug, Clone, Eq, PartialEq, Hash, PartialOrd, Ord)]
-struct JSONResponse {
-    pub plugin_id: i32,
-    pub title: String,
-    #[serde(default)]
-    pub description: String,
-    pub category: String,
-    #[serde(default)]
-    pub current_version: String,
-    pub latest_version: String,
-    pub folders: String,
-    pub files: Vec<String>,
-}
-
-#[derive(Debug, Clone)]
-pub enum APIError {
-    FetchError,
 }

src/core/synchronizer.rs

@@ -1,4 +1,7 @@
-use crate::core::{synchronizer::APIError, Base as BasePlugin, Installer, Synchronizer};
+use crate::core::api_connector::APIOperations;
+use crate::core::{
+    api_connector::APIError, APIConnector, Base as BasePlugin, Installer, Synchronizer,
+};
 use crate::gui::style;
 use iced::{
     button, scrollable, text_input, Align, Button, Column, Command, Container, Element,
@@ -65,7 +68,7 @@ impl Catalog {
                     Command::none()
                 }
                 Message::LoadPlugins => {
-                    Command::perform(Synchronizer::fetch_plugins(), Message::LoadedPlugins)
+                    Command::perform(APIConnector::fetch_plugins(), Message::LoadedPlugins)
                 }
                 Message::LoadedPlugins(fetched_plugins) => {
                     if fetched_plugins.is_ok() {
@@ -111,7 +114,7 @@ impl Catalog {
             },
             Catalog::NoInternet(state) => match message {
                 Message::RetryPressed => {
-                    Command::perform(Synchronizer::fetch_plugins(), Message::LoadedPlugins)
+                    Command::perform(APIConnector::fetch_plugins(), Message::LoadedPlugins)
                 }
                 Message::LoadedPlugins(fetched_plugins) => {
                     if fetched_plugins.is_ok() {
@@ -303,7 +306,7 @@ impl PluginRow {
     pub fn update(&mut self, message: RowMessage) {
         match message {
             RowMessage::InstallPressed(plugin) => {
-                let fetched_plugin = Synchronizer::fetch_plugin_details(&plugin.title);
+                let fetched_plugin = APIConnector::fetch_details(&plugin.title);
                 if Installer::download(&fetched_plugin).is_ok() {
                     self.status = "Downloaded".to_string();
                     if Installer::extract(&fetched_plugin).is_ok() {

src/gui/views/catalog.rs

@@ -257,7 +257,6 @@ impl Lembas {
 
     pub async fn init_application() -> State {
         Synchronizer::create_plugins_db();
-        //Synchronizer::update_local_plugins();
         Synchronizer::synchronize_application();
 
         State::default()