1use crate::value::Value;
2use serde::{Deserialize, Serialize};
3use std::fs;
4use std::path::PathBuf;
5
6#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7pub struct Settings {
8 #[serde(default = "default_stack_soft_cap")]
9 pub stack_soft_cap: usize,
10 #[serde(default = "default_rational_digit_cap")]
11 pub rational_digit_cap: usize,
12 #[serde(default = "default_undo_depth")]
13 pub undo_depth: usize,
14}
15
16impl Default for Settings {
17 fn default() -> Self {
18 Self {
19 stack_soft_cap: default_stack_soft_cap(),
20 rational_digit_cap: default_rational_digit_cap(),
21 undo_depth: default_undo_depth(),
22 }
23 }
24}
25
26fn default_stack_soft_cap() -> usize {
27 10_000
28}
29
30fn default_rational_digit_cap() -> usize {
31 10_000
32}
33
34fn default_undo_depth() -> usize {
35 10
36}
37
38#[derive(Debug, Clone, PartialEq, Serialize)]
39pub struct PersistedState {
40 #[serde(default = "default_schema_version")]
41 pub schema_version: u32,
42 #[serde(default, deserialize_with = "deserialize_stack")]
43 pub stack: Vec<Value>,
44 #[serde(default)]
45 pub settings: Settings,
46}
47
48fn default_schema_version() -> u32 {
49 1
50}
51
52impl Default for PersistedState {
53 fn default() -> Self {
54 Self {
55 schema_version: 1,
56 stack: Vec::new(),
57 settings: Settings::default(),
58 }
59 }
60}
61
62impl<'de> Deserialize<'de> for PersistedState {
63 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
64 where
65 D: serde::Deserializer<'de>,
66 {
67 #[derive(Deserialize)]
68 struct Raw {
69 #[serde(default = "default_schema_version")]
70 schema_version: u32,
71 #[serde(default)]
72 stack: Vec<toml::Value>,
73 #[serde(default)]
74 settings: Settings,
75 }
76
77 let raw = Raw::deserialize(deserializer)?;
78 let mut stack = Vec::new();
79 let mut skipped = 0usize;
80 for item in raw.stack {
81 use serde::de::IntoDeserializer;
82 match Value::deserialize(item.into_deserializer()) {
83 Ok(v) => stack.push(v),
84 Err(_) => {
85 skipped += 1;
86 }
87 }
88 }
89 if skipped > 0 {
90 eprintln!(
91 "warning: skipped {} persisted value(s) with unknown kind",
92 skipped
93 );
94 }
95 Ok(PersistedState {
96 schema_version: raw.schema_version,
97 stack,
98 settings: raw.settings,
99 })
100 }
101}
102
103pub fn state_path() -> PathBuf {
104 directories::ProjectDirs::from("", "", "pnc")
105 .map(|p| p.data_dir().join("state.toml"))
106 .unwrap_or_else(|| PathBuf::from("state.toml"))
107}
108
109pub fn load() -> Result<PersistedState, crate::error::PncError> {
110 load_from(&state_path())
111}
112
113pub fn load_from(path: &std::path::Path) -> Result<PersistedState, crate::error::PncError> {
114 if !path.exists() {
115 return Ok(PersistedState::default());
116 }
117 let text = fs::read_to_string(path)?;
118 let state: PersistedState =
119 toml::from_str(&text).map_err(|e| crate::error::PncError::Parse(e.to_string()))?;
120 if state.schema_version > 1 {
121 return Err(crate::error::PncError::UnsupportedSchemaVersion);
122 }
123 Ok(state)
124}
125
126pub fn save(state: &PersistedState) -> Result<(), crate::error::PncError> {
127 save_to(state, &state_path())
128}
129
130pub fn lock_path() -> std::path::PathBuf {
131 state_path().with_file_name("pnc.lock")
132}
133
134pub fn acquire_lock() -> Result<std::fs::File, crate::error::PncError> {
135 let path = lock_path();
136 if let Some(parent) = path.parent() {
137 fs::create_dir_all(parent)?;
138 }
139 let file = fs::OpenOptions::new()
140 .create(true)
141 .write(true)
142 .truncate(false)
143 .open(&path)?;
144 use fs2::FileExt;
145 file.try_lock_exclusive().map_err(|_| {
146 crate::error::PncError::Io(std::io::Error::other("another pnc instance is running"))
147 })?;
148 Ok(file)
149}
150
151pub fn save_to(
152 state: &PersistedState,
153 path: &std::path::Path,
154) -> Result<(), crate::error::PncError> {
155 if let Some(parent) = path.parent() {
156 fs::create_dir_all(parent)?;
157 }
158 let text =
159 toml::to_string_pretty(state).map_err(|e| crate::error::PncError::Parse(e.to_string()))?;
160 if path.exists() {
161 let backup = path.with_extension("bak");
162 let _ = fs::copy(path, &backup);
163 }
164 let parent = path.parent().unwrap_or_else(|| std::path::Path::new("."));
165 fs::create_dir_all(parent)?;
166
167 let mut last_err = None;
171 for _ in 0..2 {
172 let tmp_path = path.with_file_name(format!(
173 "{}.tmp",
174 path.file_name().and_then(|s| s.to_str()).unwrap_or("state.toml")
175 ));
176 let write_result = (|| -> std::io::Result<()> {
177 use std::io::Write;
178 let mut f = fs::OpenOptions::new()
179 .create(true)
180 .write(true)
181 .truncate(true)
182 .open(&tmp_path)?;
183 f.write_all(text.as_bytes())?;
184 f.flush()?;
185 f.sync_all()?;
186 fs::rename(&tmp_path, path)?;
187 Ok(())
188 })();
189 match write_result {
190 Ok(()) => {
191 last_err = None;
192 break;
193 }
194 Err(e) => {
195 let _ = fs::remove_file(&tmp_path);
196 last_err = Some(crate::error::PncError::Io(e));
197 continue;
198 }
199 }
200 }
201 if let Some(e) = last_err {
202 return Err(e);
203 }
204 if let Some(parent) = path.parent() {
206 if let Ok(dir) = fs::File::open(parent) {
207 let _ = dir.sync_all();
208 }
209 }
210 Ok(())
211}