refactor: streamline close behavior persistence

Author: zouyonghe

src-tauri/src/close_behavior.rs

@@ -5,6 +5,8 @@ use std::{fs, io::Write, path::Path};
 pub(crate) const CLOSE_ACTION_TRAY: &str = "tray";
 pub(crate) const CLOSE_ACTION_EXIT: &str = "exit";
 
+type Logger<'a> = dyn Fn(&str) + 'a;
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub(crate) enum CloseAction {
@@ -52,10 +54,7 @@ pub(crate) fn parse_close_action(raw: &str) -> Option<CloseAction> {
     }
 }
 
-fn load_desktop_state<F>(raw: &str, log_subject: &str, log: &F) -> DesktopState
-where
-    F: Fn(&str),
-{
+fn load_desktop_state(raw: &str, log_subject: &str, log: &Logger<'_>) -> DesktopState {
     match serde_json::from_str::<DesktopState>(raw) {
         Ok(state) => state,
         Err(error) => {
@@ -78,28 +77,25 @@ where
     read_cached_close_action_at_path(&state_path, &log)
 }
 
-fn read_cached_close_action_at_path<F>(state_path: &Path, log: &F) -> Option<CloseAction>
-where
-    F: Fn(&str),
-{
+fn read_cached_close_action_at_path(state_path: &Path, log: &Logger<'_>) -> Option<CloseAction> {
     let raw = fs::read_to_string(state_path).ok()?;
     let state = load_desktop_state(&raw, "desktop close behavior state", log);
     state.close_action
 }
 
-fn save_desktop_state(path: &Path, state: &DesktopState) -> Result<(), String> {
+fn atomic_write_json(path: &Path, value: &impl Serialize, what: &str) -> Result<(), String> {
     if let Some(parent_dir) = path.parent() {
         fs::create_dir_all(parent_dir).map_err(|error| {
             format!(
-                "Failed to create close behavior directory {}: {}",
+                "Failed to create {what} directory {}: {}",
                 parent_dir.display(),
                 error
             )
         })?;
     }
 
-    let serialized = serde_json::to_string_pretty(state)
-        .map_err(|error| format!("Failed to serialize close behavior state: {error}"))?;
+    let serialized = serde_json::to_string_pretty(value)
+        .map_err(|error| format!("Failed to serialize {what}: {error}"))?;
     let tmp_name = format!(
         "{}.tmp",
         path.file_name()
@@ -110,7 +106,7 @@ fn save_desktop_state(path: &Path, state: &DesktopState) -> Result<(), String> {
 
     let mut file = fs::File::create(&tmp_path).map_err(|error| {
         format!(
-            "Failed to create temporary close behavior state file {}: {}",
+            "Failed to create temporary {what} file {}: {}",
             tmp_path.display(),
             error
         )
@@ -119,20 +115,24 @@ fn save_desktop_state(path: &Path, state: &DesktopState) -> Result<(), String> {
         .and_then(|_| file.sync_all())
         .map_err(|error| {
             format!(
-                "Failed to write temporary close behavior state file {}: {}",
+                "Failed to write temporary {what} file {}: {}",
                 tmp_path.display(),
                 error
             )
         })?;
     fs::rename(&tmp_path, path).map_err(|error| {
         format!(
-            "Failed to atomically replace close behavior state file {}: {}",
+            "Failed to atomically replace {what} file {}: {}",
             path.display(),
             error
         )
     })
 }
 
+fn save_desktop_state(path: &Path, state: &DesktopState) -> Result<(), String> {
+    atomic_write_json(path, state, "close behavior state")
+}
+
 pub(crate) fn write_cached_close_action<F>(
     action: Option<CloseAction>,
     packaged_root_dir: Option<&Path>,
@@ -150,14 +150,11 @@ where
     write_cached_close_action_at_path(action, &state_path, &log)
 }
 
-fn write_cached_close_action_at_path<F>(
+fn write_cached_close_action_at_path(
     action: Option<CloseAction>,
     state_path: &Path,
-    log: &F,
-) -> Result<(), String>
-where
-    F: Fn(&str),
-{
+    log: &Logger<'_>,
+) -> Result<(), String> {
     let mut state = match fs::read_to_string(state_path) {
         Ok(raw) => load_desktop_state(
             &raw,