Skip to main content

rip_settings/
undo.rs

1use crate::error::SettingsError;
2use crate::repository::SettingsRepository;
3use crate::schema::SettingsSchema;
4use chrono::Utc;
5use std::collections::VecDeque;
6use std::sync::RwLock;
7
8/// Records a single field change.
9#[derive(Clone, Debug)]
10pub struct SettingChange {
11    pub field_name: String,
12    pub old_value: serde_json::Value,
13    pub new_value: serde_json::Value,
14    pub timestamp: i64,
15}
16
17/// Manages undo/redo history for setting changes.
18///
19/// Wraps a [`SettingsRepository`] and automatically records changes
20/// when using [`UndoManager::set_field`] instead of [`SettingsRepository::set_field`].
21pub struct UndoManager<T: SettingsSchema + PartialEq> {
22    repository: std::sync::Arc<SettingsRepository<T>>,
23    undo_stack: RwLock<VecDeque<SettingChange>>,
24    redo_stack: RwLock<VecDeque<SettingChange>>,
25    max_history: usize,
26}
27
28impl<T: SettingsSchema + PartialEq> UndoManager<T> {
29    pub fn new(repository: std::sync::Arc<SettingsRepository<T>>, max_history: usize) -> Self {
30        Self {
31            repository,
32            undo_stack: RwLock::new(VecDeque::new()),
33            redo_stack: RwLock::new(VecDeque::new()),
34            max_history,
35        }
36    }
37
38    /// Set a field and automatically record the change for undo.
39    pub fn set_field(&self, name: &str, value: serde_json::Value) -> Result<(), SettingsError> {
40        let old_val = self.repository.get_field(name)?;
41        self.repository.set_field(name, value.clone())?;
42        self.record_change_inner(name, old_val, value);
43        Ok(())
44    }
45
46    /// Record a change for undo support (separate call required when using
47    /// [`SettingsRepository::set_field`] directly).
48    pub fn record_change(
49        &self,
50        field_name: impl Into<String>,
51        old_value: serde_json::Value,
52        new_value: serde_json::Value,
53    ) {
54        self.record_change_inner(field_name, old_value, new_value);
55    }
56
57    fn record_change_inner(
58        &self,
59        field_name: impl Into<String>,
60        old_value: serde_json::Value,
61        new_value: serde_json::Value,
62    ) {
63        let change = SettingChange {
64            field_name: field_name.into(),
65            old_value,
66            new_value,
67            timestamp: Utc::now().timestamp_millis(),
68        };
69
70        let mut undo = self.undo_stack.write().unwrap_or_else(|e| e.into_inner());
71        undo.push_back(change);
72        while undo.len() > self.max_history {
73            undo.pop_front();
74        }
75
76        self.redo_stack
77            .write()
78            .unwrap_or_else(|e| e.into_inner())
79            .clear();
80    }
81
82    /// Undo the last change.
83    pub fn undo(&self) -> Result<bool, SettingsError> {
84        let change = {
85            let mut undo = self.undo_stack.write().unwrap_or_else(|e| e.into_inner());
86            undo.pop_back()
87        };
88
89        let Some(change) = change else {
90            return Ok(false);
91        };
92
93        self.repository
94            .set_field(&change.field_name, change.old_value.clone())?;
95
96        self.redo_stack
97            .write()
98            .unwrap_or_else(|e| e.into_inner())
99            .push_back(change);
100        Ok(true)
101    }
102
103    /// Redo the last undone change.
104    pub fn redo(&self) -> Result<bool, SettingsError> {
105        let change = {
106            let mut redo = self.redo_stack.write().unwrap_or_else(|e| e.into_inner());
107            redo.pop_back()
108        };
109
110        let Some(change) = change else {
111            return Ok(false);
112        };
113
114        self.repository
115            .set_field(&change.field_name, change.new_value.clone())?;
116
117        self.undo_stack
118            .write()
119            .unwrap_or_else(|e| e.into_inner())
120            .push_back(change);
121        Ok(true)
122    }
123
124    #[must_use]
125    pub fn can_undo(&self) -> bool {
126        !self
127            .undo_stack
128            .read()
129            .unwrap_or_else(|e| e.into_inner())
130            .is_empty()
131    }
132
133    #[must_use]
134    pub fn can_redo(&self) -> bool {
135        !self
136            .redo_stack
137            .read()
138            .unwrap_or_else(|e| e.into_inner())
139            .is_empty()
140    }
141
142    pub fn undo_description(&self) -> Option<String> {
143        self.undo_stack
144            .read()
145            .unwrap_or_else(|e| e.into_inner())
146            .back()
147            .map(|c| format!("Undo: {}", c.field_name))
148    }
149
150    pub fn redo_description(&self) -> Option<String> {
151        self.redo_stack
152            .read()
153            .unwrap_or_else(|e| e.into_inner())
154            .back()
155            .map(|c| format!("Redo: {}", c.field_name))
156    }
157
158    /// Clear all undo/redo history.
159    pub fn clear_history(&self) {
160        self.undo_stack
161            .write()
162            .unwrap_or_else(|e| e.into_inner())
163            .clear();
164        self.redo_stack
165            .write()
166            .unwrap_or_else(|e| e.into_inner())
167            .clear();
168    }
169}