BlueGit

timfa posprint

Files

posprint / src / io / mod.rs

mod.rs

mod.rs 5.5 KiB Download Raw
1use serde::{Deserialize, Serialize};
2
3#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4pub struct PosFile {
5 pub version: u32,
6 pub metadata: PosMetadata,
7 pub body: String,
8}
9
10#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11pub struct PosMetadata {
12 #[serde(skip_serializing_if = "Option::is_none")]
13 pub title: Option<String>,
14 pub page_width_mm: f32,
15 #[serde(skip_serializing_if = "Option::is_none")]
16 pub chars_per_line: Option<u32>,
17 #[serde(skip_serializing_if = "Option::is_none")]
18 pub codepage: Option<String>,
19}
20
21impl Default for PosMetadata {
22 fn default() -> Self {
23 Self {
24 title: None,
25 page_width_mm: 80.0,
26 chars_per_line: None,
27 codepage: Some("CP437".into()),
28 }
29 }
30}
31
32impl PosFile {
33 pub fn new(body: impl Into<String>) -> Self {
34 Self {
35 version: 1,
36 metadata: PosMetadata::default(),
37 body: body.into(),
38 }
39 }
40
41 pub fn to_json_pretty(&self) -> Result<String, serde_json::Error> {
42 serde_json::to_string_pretty(self)
43 }
44
45 pub fn from_json(json: &str) -> Result<Self, serde_json::Error> {
46 serde_json::from_str(json)
47 }
48
49 pub fn save_to_path(&self, path: &std::path::Path) -> Result<(), SaveError> {
50 let json = self.to_json_pretty()?;
51 std::fs::write(path, json)?;
52 Ok(())
53 }
54
55 pub fn load_from_path(path: &std::path::Path) -> Result<Self, LoadError> {
56 let json = std::fs::read_to_string(path)?;
57 let file = PosFile::from_json(&json).map_err(LoadError::Json)?;
58 if file.version != 1 {
59 return Err(LoadError::UnsupportedVersion(file.version));
60 }
61 Ok(file)
62 }
63}
64
65impl PosMetadata {
66 pub fn printable_dots(&self) -> u16 {
67 // Most ESC/POS printers effectively expose Font A widths of:
68 // 32 columns -> 384 dots, 48 columns -> 576 dots.
69 // Keep image/raster width aligned with the text column model.
70 (self.chars_per_line().max(1) * 12) as u16
71 }
72
73 pub fn chars_per_line(&self) -> u32 {
74 self.chars_per_line.unwrap_or_else(|| {
75 if self.page_width_mm <= 58.0 {
76 32
77 } else {
78 48
79 }
80 })
81 }
82}
83
84#[derive(Debug)]
85pub enum SaveError {
86 Json(serde_json::Error),
87 Io(std::io::Error),
88}
89
90impl From<serde_json::Error> for SaveError {
91 fn from(value: serde_json::Error) -> Self {
92 Self::Json(value)
93 }
94}
95
96impl From<std::io::Error> for SaveError {
97 fn from(value: std::io::Error) -> Self {
98 Self::Io(value)
99 }
100}
101
102#[derive(Debug)]
103pub enum LoadError {
104 Io(std::io::Error),
105 Json(serde_json::Error),
106 UnsupportedVersion(u32),
107}
108
109impl From<std::io::Error> for LoadError {
110 fn from(value: std::io::Error) -> Self {
111 Self::Io(value)
112 }
113}
114
115#[cfg(test)]
116mod tests {
117 use super::*;
118
119 #[test]
120 fn roundtrip_json() {
121 let file = PosFile::new("# Test");
122 let json = file.to_json_pretty().unwrap();
123 assert!(!json.contains("default_feed_before_cut"));
124 let loaded = PosFile::from_json(&json).unwrap();
125 assert_eq!(loaded, file);
126 }
127
128 #[test]
129 fn chars_per_line_defaults() {
130 let narrow = PosMetadata {
131 page_width_mm: 58.0,
132 ..Default::default()
133 };
134 assert_eq!(narrow.chars_per_line(), 32);
135 assert_eq!(narrow.printable_dots(), 384);
136 let very_narrow = PosMetadata {
137 page_width_mm: 53.0,
138 ..Default::default()
139 };
140 assert_eq!(very_narrow.chars_per_line(), 32);
141 assert_eq!(very_narrow.printable_dots(), 384);
142 let wide = PosMetadata::default();
143 assert_eq!(wide.chars_per_line(), 48);
144 assert_eq!(wide.printable_dots(), 576);
145 }
146
147 #[test]
148 fn ignores_legacy_preview_mode_field() {
149 let json = r#"{
150 "version": 1,
151 "metadata": {
152 "page_width_mm": 80.0
153 },
154 "body": "hello"
155 }"#;
156 let loaded = PosFile::from_json(json).unwrap();
157 assert_eq!(loaded.body, "hello");
158 assert!(!loaded.to_json_pretty().unwrap().contains("preview_mode"));
159 assert!(
160 !loaded
161 .to_json_pretty()
162 .unwrap()
163 .contains("default_feed_before_cut")
164 );
165 assert!(
166 !loaded
167 .to_json_pretty()
168 .unwrap()
169 .contains("cut_after_print")
170 );
171 }
172
173 #[test]
174 fn ignores_legacy_cut_after_print_field() {
175 let json = r#"{
176 "version": 1,
177 "metadata": {
178 "page_width_mm": 80.0,
179 "cut_after_print": true
180 },
181 "body": "hello"
182 }"#;
183 let loaded = PosFile::from_json(json).unwrap();
184 assert_eq!(loaded.body, "hello");
185 assert!(
186 !loaded
187 .to_json_pretty()
188 .unwrap()
189 .contains("cut_after_print")
190 );
191 }
192
193 #[test]
194 fn save_and_load_file() {
195 let dir = tempfile::tempdir().unwrap();
196 let path = dir.path().join("test.pos");
197 let file = PosFile::new("hello");
198 file.save_to_path(&path).unwrap();
199 let loaded = PosFile::load_from_path(&path).unwrap();
200 assert_eq!(loaded.body, "hello");
201 }
202}