pim

buffer.rs (5971B)

---

 use std::collections::HashMap;
 use std::fs::{self, File, OpenOptions};
 use std::io::{self, BufRead, BufReader, Seek, SeekFrom, Write};
 use std::path::PathBuf;
 
 pub struct Buffer {
     file_path: PathBuf,
     swap_path: PathBuf,
     line_offsets: Vec<u64>,
     deltas: HashMap<usize, String>,
     modified: bool,
 }
 
 impl Buffer {
     pub fn new_empty(path: PathBuf) -> Self {
         let swap_path = path.with_extension(format!(
             "{}.swp",
             path.extension().and_then(|e| e.to_str()).unwrap_or("txt")
         ));
         Self {
             file_path: path,
             swap_path,
             line_offsets: vec![0],
             deltas: HashMap::new(),
             modified: false,
         }
     }
 
     pub fn from_path(path: PathBuf, should_recover: bool) -> io::Result<Self> {
         let file = File::open(&path)?;
         let mut reader = BufReader::new(file);
         let mut line_offsets = vec![0];
         let mut offset = 0;
 
         let mut buf = Vec::new();
         while reader.read_until(b'\n', &mut buf)? > 0 {
             offset += buf.len() as u64;
             line_offsets.push(offset);
             buf.clear();
         }
 
         let swap_path = path.with_extension(format!(
             "{}.swp",
             path.extension().and_then(|e| e.to_str()).unwrap_or("txt")
         ));
 
         let mut deltas = HashMap::new();
         let mut modified = false;
         if swap_path.exists() && should_recover {
             let swap_file = File::open(&swap_path)?;
             let swap_reader = BufReader::new(swap_file);
             for line in swap_reader.lines() {
                 let line = line?;
                 if line == "SAVE" {
                     modified = false;
                     continue;
                 }
                 if let Some((idx_str, content)) = line.split_once(':')
                     && let Ok(idx) = idx_str.parse::<usize>()
                 {
                     deltas.insert(idx, content.to_string());
                     modified = true;
                 }
             }
         } else if swap_path.exists() {
             fs::remove_file(&swap_path)?;
         }
 
         Ok(Self {
             file_path: path,
             swap_path,
             line_offsets,
             deltas,
             modified,
         })
     }
 
     pub fn read_line(&self, index: usize) -> io::Result<String> {
         if let Some(delta) = self.deltas.get(&index) {
             return Ok(delta.clone());
         }
 
         if index >= self.line_offsets.len().saturating_sub(1) {
             return Ok(String::new());
         }
 
         let mut file = File::open(&self.file_path)?;
         file.seek(SeekFrom::Start(self.line_offsets[index]))?;
 
         let length = self.line_offsets[index + 1] - self.line_offsets[index];
         let mut buf = vec![0; length as usize];
         io::Read::read_exact(&mut file, &mut buf)?;
 
         Ok(String::from_utf8_lossy(&buf).to_string())
     }
 
     pub fn update_line(&mut self, index: usize, content: String) {
         self.deltas.insert(index, content);
         self.modified = true;
     }
 
     pub fn sync_to_swap(&self) -> io::Result<()> {
         let mut swap_file = OpenOptions::new()
             .create(true)
             .append(true)
             .open(&self.swap_path)?;
 
         for (idx, content) in &self.deltas {
             writeln!(swap_file, "{}:{}", idx, content.replace(['\n', '\r'], ""))?;
         }
         Ok(())
     }
 
     pub fn save(&mut self) -> io::Result<()> {
         let temp_path = self.file_path.with_extension("tmp");
         let mut temp_file = File::create(&temp_path)?;
 
         for i in 0..self.total_lines().max(1) {
             let line = self.read_line(i)?;
             let content = line.replace(['\n', '\r'], "");
             #[allow(clippy::write_with_newline)]
             write!(temp_file, "{}\n", content)?;
         }
 
         fs::rename(temp_path, &self.file_path)?;
 
         let mut swap_file = OpenOptions::new()
             .create(true)
             .append(true)
             .open(&self.swap_path)?;
         writeln!(swap_file, "SAVE")?;
 
         self.modified = false;
         Ok(())
     }
 
     pub fn rollback(&mut self) -> io::Result<()> {
         if !self.swap_path.exists() {
             return Ok(());
         }
 
         let swap_file = File::open(&self.swap_path)?;
         let lines: Vec<String> = BufReader::new(swap_file)
             .lines()
             .collect::<Result<_, _>>()?;
 
         let last_save_idx = lines.iter().rposition(|l| l == "SAVE");
         let target_idx = if let Some(idx) = last_save_idx {
             lines[..idx].iter().rposition(|l| l == "SAVE")
         } else {
             None
         };
 
         let mut new_deltas = HashMap::new();
         let limit = target_idx.map(|i| i + 1).unwrap_or(0);
 
         for line in &lines[..limit] {
             if line == "SAVE" {
                 continue;
             }
             if let Some((idx_str, content)) = line.split_once(':')
                 && let Ok(idx) = idx_str.parse::<usize>()
             {
                 new_deltas.insert(idx, content.to_string());
             }
         }
 
         let mut swap_file = File::create(&self.swap_path)?;
         for line in &lines[..limit] {
             writeln!(swap_file, "{}", line)?;
         }
 
         self.deltas = new_deltas;
         self.modified = false;
         Ok(())
     }
 
     pub fn is_modified(&self) -> bool {
         self.modified
     }
 
     pub fn total_lines(&self) -> usize {
         self.line_offsets
             .len()
             .saturating_sub(1)
             .max(self.deltas.keys().map(|&k| k + 1).max().unwrap_or(0))
     }
 
     pub fn remove_swap_file(&self) -> io::Result<()> {
         if self.swap_path.exists() {
             fs::remove_file(&self.swap_path)?;
         }
         Ok(())
     }
 }