refactor: create and use optional_fill!() macro to reduce repetition

src-tauri/src/package.rs

@@ -132,25 +132,25 @@ tauri_reexport! {
             self.state.read().unwrap().installed.clone()
         }
 
-        pub fn install_package(self: &Self, id: String) -> Result<(), String> {
+        pub fn install_package(self: &Self, id: String) -> Result<(), Cow<'static, str>> {
             {
                 let mut state = self.state.write().map_err(|e| e.to_string())?;
                 if !self.get_available_packages().iter().any(|p| p.id == id) {
-                    return Err("Package not found".to_string());
+                    return Err("Package not found".into());
                 }
                 if state.installed.contains(&id) {
-                    return Err("Package already installed".to_string());
+                    return Err("Package already installed".into());
                 }
                 state.installed.push(id);
             }
             self.save()
         }
 
-        pub fn uninstall_package(self: &Self, id: String) -> Result<(), String> {
+        pub fn uninstall_package(self: &Self, id: String) -> Result<(), Cow<'static, str>> {
             {
                 let mut state = self.state.write().map_err(|e| e.to_string())?;
                 if !state.installed.contains(&id) {
-                    return Err("Package not installed".to_string());
+                    return Err("Package not installed".into());
                 }
                 state.installed.retain(|p| p != &id);
             }

src-tauri/src/script/ast.rs

@@ -109,7 +109,7 @@ impl Value<'_> {
             Self::Num(n) => *n != 0.0,
             Self::Str(s) => match s {
                 Cow::Borrowed(s) => !s.is_empty(),
-                Cow::Owned(s) => s.len() != 0,
+                Cow::Owned(s) => !s.is_empty(),
             },
             Self::Nil => false,
             Self::Fn { .. } => true,

src-tauri/src/trigger.rs

@@ -1,4 +1,4 @@
-use super::util::tauri_reexport;
+use super::util::{optional_fill, tauri_reexport};
 use serde::{Deserialize, Serialize};
 use std::{borrow::Cow, collections::HashMap, fmt::Write, fs::{self, File}, io::{BufReader, BufWriter}, path::PathBuf, sync::{Arc, RwLock}};
 use uuid::Uuid;
@@ -189,7 +189,7 @@ tauri_reexport! {
         ) -> Result<Trigger, String> {
             let now = chrono::Utc::now().to_rfc3339();
             let trigger = Trigger {
-                id: uuid::Uuid::new_v4().to_string(),
+                id: Uuid::new_v4().to_string(),
                 trigger_text,
                 replacement,
                 enabled: true,
@@ -224,12 +224,7 @@ tauri_reexport! {
                     .find(|t| t.id == id)
                     .ok_or_else(|| "Trigger not found".to_string())?;
 
-                if let Some(v) = trigger_text { trigger.trigger_text = v; }
-                if let Some(v) = replacement { trigger.replacement = v; }
-                if let Some(v) = category { trigger.category = v; }
-                if let Some(v) = args_mode { trigger.args_mode = v; }
-                if let Some(v) = enabled { trigger.enabled = v; }
-                if let Some(v) = vars { trigger.vars = v; }
+                optional_fill!(trigger, trigger_text, replacement, category, args_mode, enabled, vars);
 
                 trigger.updated_at = chrono::Utc::now().to_rfc3339();
                 Ok(trigger.clone())
@@ -244,9 +239,9 @@ tauri_reexport! {
             self.global_vars.read().unwrap().clone()
         }
 
-        pub fn add_global_var(self: &Self, name: String, script: String) -> Result<GlobalVar, String> {
+        pub fn add_global_var(self: &Self, name: String, script: String) -> Result<GlobalVar, Cow<'static, str>> {
             let global_var = GlobalVar {
-                id: uuid::Uuid::new_v4().to_string(),
+                id: Uuid::new_v4(),
                 name,
                 script,
                 enabled: true,
@@ -261,28 +256,24 @@ tauri_reexport! {
 
         pub fn update_global_var(
             self: &Self,
-            id: String,
+            id: Uuid,
             name: Option<String>,
             script: Option<String>,
             enabled: Option<bool>
-        ) -> Result<GlobalVar, String> {
-            {
-                let mut global_vars = self.global_vars.write().map_err(|e| e.to_string())?;
-                let gv = global_vars
-                    .iter_mut()
-                    .find(|g| g.id == id)
-                    .ok_or_else(|| "Global variable not found".to_string())?;
+        ) -> Result<GlobalVar, Cow<'static, str>> {
+            let mut global_vars = self.global_vars.write().map_err(|e| e.to_string())?;
+            let gv = global_vars
+                .iter_mut()
+                .find(|g| g.id == id)
+                .ok_or(Cow::Borrowed("Global variable not found"))?;
 
-                if let Some(v) = name { gv.name = v; }
-                if let Some(v) = script { gv.script = v; }
-                if let Some(v) = enabled { gv.enabled = v; }
+            optional_fill!(gv, name, script, enabled);
 
-                Ok(gv.clone())
-            }
-            .and_then(|gv| {
-                self.save_global_vars()?;
-                Ok(gv)
-            })
+            let result = Ok(gv.clone());
+
+            self.save_global_vars()?;
+
+            result
         }
     }
 }

src-tauri/src/util.rs

@@ -1,3 +1,12 @@
+#[macro_export]
+macro_rules! optional_fill {
+    ($target:ident, $($identifier:ident),+) => {$(
+        if let Some($identifier) = $identifier { $target.$identifier = $identifier; }
+    )+};
+}
+
+pub(super) use optional_fill;
+
 #[macro_export]
 macro_rules! tauri_reexport {
     (