A2: engine half of files changed on disk and Local History v1

- Disk conflicts per buffer (changed / removed), reported in buffer.get
  as diskConflict; diskConflictResolved when settled.
- Every watcher event only means "look again": delete + create (git
  checkout, atomic saves) reloads instead of losing the buffer; a file that
  disappears keeps its buffer as unsaved.
- file.save checks mtime + hash and fails with disk_changed instead of
  overwriting a newer file (overwrite: true after asking); saveAll lists
  such buffers under diskChanged. New file.reload and file.readDisk.
- Local History store in the data dir (content-addressed SHA-256 blobs,
  index.jsonl, 14 days / 200 MB, pruned on open); snapshots on save,
  before reloads, on deletion, before lsp.rename and file-changing git
  commands. Commands history.list / history.read / history.revert.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
danny 2026-11-08 12:09:16 +01:00
parent 7f309dbc4e
commit dfe2f19ca5
17 changed files with 1953 additions and 116 deletions

View file

@ -1,7 +1,8 @@
//! Open buffers: the engine's copy of every file the user is editing. //! Open buffers: the engine's copy of every file the user is editing.
use std::collections::{BTreeMap, BTreeSet}; use std::collections::BTreeMap;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
use std::time::SystemTime;
use lutra_text::{Buffer, LineEnding}; use lutra_text::{Buffer, LineEnding};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
@ -31,6 +32,36 @@ impl OpenBuffer {
} }
} }
/// How a buffer's file differs from what Lutra last read or wrote.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub enum DiskConflict {
/// Another program wrote a different text while the buffer had unsaved
/// changes.
Changed,
/// The file disappeared (deleted, renamed away, or a checkout removed
/// it).
Removed,
}
/// The modification time and length of a file, compared before a save to
/// skip reading a file nobody touched.
pub type DiskStamp = (SystemTime, u64);
/// What a buffer's file held when Lutra last read or wrote it.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Written {
/// [`crate::journal::hex_hash`] of the text.
pub hash: String,
/// Whether the file has a byte order mark.
pub bom: bool,
/// The file's stamp right after, `None` when it could not be read.
pub stamp: Option<DiskStamp>,
/// The Local History holds this text (Lutra saved or reloaded it), so
/// the next save need not snapshot the file it overwrites.
pub in_history: bool,
}
/// The open buffers by id. /// The open buffers by id.
#[derive(Debug, Default)] #[derive(Debug, Default)]
pub struct Buffers { pub struct Buffers {
@ -42,12 +73,17 @@ pub struct Buffers {
/// unsaved changes ([`crate::Event::FileChangedOnDisk`]). The user has to /// unsaved changes ([`crate::Event::FileChangedOnDisk`]). The user has to
/// decide, so `file.saveAll {skipConflicts}` leaves them alone until an /// decide, so `file.saveAll {skipConflicts}` leaves them alone until an
/// explicit save or a reload settles it. /// explicit save or a reload settles it.
conflicts: BTreeSet<BufferId>, conflicts: BTreeMap<BufferId, DiskConflict>,
/// What each buffer's file held when Lutra last read or wrote it: the /// What each buffer's file held when Lutra last read or wrote it. A
/// hash ([`crate::journal::hex_hash`]) of the text and the byte order /// change on disk that matches it (our own save reported late, a touch)
/// mark. A change on disk that matches it (our own save reported late, a /// is not a conflict, and a save over a file that no longer matches it
/// touch) is not a conflict. /// asks first (`file.save` fails with `disk_changed`).
written: BTreeMap<BufferId, (String, bool)>, written: BTreeMap<BufferId, Written>,
/// Buffers that were clean when their file disappeared, with their
/// version then. Such a buffer is dirty only because the file is gone;
/// if the file comes back before the user edits it, it reloads like a
/// clean buffer.
clean_when_removed: BTreeMap<BufferId, u64>,
} }
impl Buffers { impl Buffers {
@ -73,24 +109,50 @@ impl Buffers {
pub fn remove(&mut self, id: BufferId) -> Option<OpenBuffer> { pub fn remove(&mut self, id: BufferId) -> Option<OpenBuffer> {
self.conflicts.remove(&id); self.conflicts.remove(&id);
self.written.remove(&id); self.written.remove(&id);
self.clean_when_removed.remove(&id);
self.by_id.remove(&id) self.by_id.remove(&id)
} }
/// Marks buffer `id` as in conflict with its file on disk. /// Marks buffer `id` as in conflict with its file on disk.
pub fn mark_conflict(&mut self, id: BufferId) { pub fn mark_conflict(&mut self, id: BufferId, kind: DiskConflict) {
if self.by_id.contains_key(&id) { if self.by_id.contains_key(&id) {
self.conflicts.insert(id); self.conflicts.insert(id, kind);
} }
} }
/// Clears the disk conflict of buffer `id` (saved or reloaded). /// Clears the disk conflict of buffer `id` (saved or reloaded).
pub fn clear_conflict(&mut self, id: BufferId) { ///
self.conflicts.remove(&id); /// # Returns
/// Whether it was in conflict.
pub fn clear_conflict(&mut self, id: BufferId) -> bool {
self.clean_when_removed.remove(&id);
self.conflicts.remove(&id).is_some()
}
/// Records that buffer `id` was clean at `version` when its file
/// disappeared.
pub fn note_clean_removal(&mut self, id: BufferId, version: u64) {
if self.by_id.contains_key(&id) {
self.clean_when_removed.insert(id, version);
}
}
/// Whether buffer `id` is dirty only because its file disappeared: it
/// was clean then and has not been edited since.
pub fn dirty_only_by_removal(&self, id: BufferId) -> bool {
self.by_id
.get(&id)
.is_some_and(|open| self.clean_when_removed.get(&id) == Some(&open.version))
} }
/// Whether buffer `id` is in conflict with its file on disk. /// Whether buffer `id` is in conflict with its file on disk.
pub fn has_conflict(&self, id: BufferId) -> bool { pub fn has_conflict(&self, id: BufferId) -> bool {
self.conflicts.contains(&id) self.conflicts.contains_key(&id)
}
/// The disk conflict of buffer `id`, if any.
pub fn conflict(&self, id: BufferId) -> Option<DiskConflict> {
self.conflicts.get(&id).copied()
} }
/// Remembers what buffer `id`'s file holds after Lutra read or wrote it. /// Remembers what buffer `id`'s file holds after Lutra read or wrote it.
@ -98,18 +160,47 @@ impl Buffers {
/// # Parameters /// # Parameters
/// - `hash`: [`crate::journal::hex_hash`] of the text. /// - `hash`: [`crate::journal::hex_hash`] of the text.
/// - `bom`: whether the file has a byte order mark. /// - `bom`: whether the file has a byte order mark.
pub fn note_written(&mut self, id: BufferId, hash: String, bom: bool) { /// - `stamp`: the file's stamp right after ([`crate::workspace::stamp`]).
pub fn note_written(
&mut self,
id: BufferId,
hash: String,
bom: bool,
stamp: Option<DiskStamp>,
) {
if self.by_id.contains_key(&id) { if self.by_id.contains_key(&id) {
self.written.insert(id, (hash, bom)); self.written.insert(
id,
Written {
hash,
bom,
stamp,
in_history: false,
},
);
} }
} }
/// Records that the Local History holds the text last noted with
/// [`Buffers::note_written`] for buffer `id`.
pub fn mark_in_history(&mut self, id: BufferId) {
if let Some(w) = self.written.get_mut(&id) {
w.in_history = true;
}
}
/// What Lutra last read or wrote for buffer `id`; `None` for a buffer
/// restored from the recovery journal before any save.
pub fn written(&self, id: BufferId) -> Option<&Written> {
self.written.get(&id)
}
/// Whether the file content `hash`/`bom` is what Lutra last read or /// Whether the file content `hash`/`bom` is what Lutra last read or
/// wrote for buffer `id`. /// wrote for buffer `id`.
pub fn is_own_write(&self, id: BufferId, hash: &str, bom: bool) -> bool { pub fn is_own_write(&self, id: BufferId, hash: &str, bom: bool) -> bool {
self.written self.written
.get(&id) .get(&id)
.is_some_and(|(h, b)| h == hash && *b == bom) .is_some_and(|w| w.hash == hash && w.bom == bom)
} }
/// The id of the buffer for the project-relative `path`, if open. /// The id of the buffer for the project-relative `path`, if open.
@ -148,6 +239,7 @@ impl Buffers {
pub fn clear(&mut self) { pub fn clear(&mut self) {
self.conflicts.clear(); self.conflicts.clear();
self.written.clear(); self.written.clear();
self.clean_when_removed.clear();
self.by_id.clear(); self.by_id.clear();
} }
} }

View file

@ -40,6 +40,7 @@ pub fn describe(state: &State, command: &str, id: BufferId) -> Result<Value, Eng
"version": open.version, "version": open.version,
"dirty": open.dirty(), "dirty": open.dirty(),
"lineEnding": LineEndingName::from(open.buffer.line_ending()), "lineEnding": LineEndingName::from(open.buffer.line_ending()),
"diskConflict": state.buffers.conflict(id),
})) }))
} }
@ -61,7 +62,7 @@ impl Command for Get {
label: "Get Buffer", label: "Get Buffer",
menu_path: None, menu_path: None,
default_shortcut: None, default_shortcut: None,
params: "{ id: number }; returns { id, path, text, version, dirty, lineEnding }", params: "{ id: number }; returns { id, path, text, version, dirty, lineEnding, diskConflict: null|changed|removed }",
} }
} }

View file

@ -1,4 +1,5 @@
//! File commands: `file.open`, `file.save`, `file.saveAll`. //! File commands: `file.open`, `file.save`, `file.saveAll`, `file.reload`,
//! `file.readDisk`.
//! //!
//! `file.saveAll {skipConflicts: true}` is the engine half of "save every //! `file.saveAll {skipConflicts: true}` is the engine half of "save every
//! dirty buffer and wait" (M3.10): autosave and anything that must see the //! dirty buffer and wait" (M3.10): autosave and anything that must see the
@ -7,6 +8,18 @@
//! instead of adding a command, so there is one save-all with one result //! instead of adding a command, so there is one save-all with one result
//! shape; the flag only adds the rule that a buffer in conflict with its file //! shape; the flag only adds the rule that a buffer in conflict with its file
//! on disk is skipped, because only the user can settle that. //! on disk is skipped, because only the user can settle that.
//!
//! # Files changed on disk (C10 A2)
//! A save never silently overwrites a newer file: before writing, the file's
//! stamp (modification time and length) is compared with the one Lutra
//! recorded when it last read or wrote the file; when it differs, the file
//! is read and its hash compared. A different text fails `file.save` with
//! `disk_changed` until the caller repeats it with `overwrite: true` (after
//! asking the user), and `file.saveAll` leaves such a buffer unsaved and
//! lists it under `diskChanged`. A file that is gone is simply written again
//! (the user kept the buffer). `file.reload` is "discard mine", and
//! `file.readDisk` gives the disk side of a comparison. Saves and reloads
//! take Local History snapshots ([`crate::history`]).
use serde::Deserialize; use serde::Deserialize;
use serde_json::{Value, json}; use serde_json::{Value, json};
@ -14,8 +27,9 @@ use serde_json::{Value, json};
use super::buffer::describe; use super::buffer::describe;
use super::params::{absolute, parse, project_path}; use super::params::{absolute, parse, project_path};
use crate::buffers::{BufferId, OpenBuffer}; use crate::buffers::{BufferId, OpenBuffer};
use crate::history::{self, Reason};
use crate::journal; use crate::journal;
use crate::workspace::{path_string, vfs_error}; use crate::workspace::{path_string, settle_conflict, stamp, vfs_error};
use crate::{Command, CommandSpec, EngineError, Event, Outcome, State}; use crate::{Command, CommandSpec, EngineError, Event, Outcome, State};
/// Params of `file.open`. /// Params of `file.open`.
@ -38,7 +52,7 @@ impl Command for Open {
label: "Open File", label: "Open File",
menu_path: None, menu_path: None,
default_shortcut: None, default_shortcut: None,
params: "{ path: string (project-relative or absolute inside the project) }; returns { id, path, text, version, dirty, lineEnding: lf|crlf|cr }; emits bufferOpened for a new buffer, bufferFocused for one already open", params: "{ path: string (project-relative or absolute inside the project) }; returns { id, path, text, version, dirty, lineEnding: lf|crlf|cr, diskConflict: null|changed|removed }; emits bufferOpened for a new buffer, bufferFocused for one already open",
} }
} }
@ -55,19 +69,7 @@ impl Command for Open {
state.emit(Event::BufferFocused { id: existing }); state.emit(Event::BufferFocused { id: existing });
return Ok(Outcome::value(value)); return Ok(Outcome::value(value));
} }
let abs = absolute(state, id, &rel)?; let new_id = open_buffer(state, id, &rel)?;
let file = lutra_vfs::read_text(&abs).map_err(vfs_error)?;
let buffer = OpenBuffer {
buffer: lutra_text::Buffer::new(&file.text),
path: rel.clone(),
version: 1,
saved_version: 1,
bom: file.bom,
};
let new_id = state.buffers.insert(buffer);
state
.buffers
.note_written(new_id, journal::hex_hash(file.text.as_bytes()), file.bom);
state.emit(Event::BufferOpened { state.emit(Event::BufferOpened {
id: new_id, id: new_id,
path: path_string(&rel), path: path_string(&rel),
@ -76,26 +78,104 @@ impl Command for Open {
} }
} }
/// Writes buffer `id` to its file, keeping its line ending and byte order /// Reads the file at the project-relative `rel` into a new buffer and
/// mark, marks it clean, clears a disk conflict (saving is the user's answer /// records what was read, without any event.
/// to it) and remembers what was written, so the watcher's report of this
/// write is not taken for an outside change.
/// ///
/// # Errors /// # Errors
/// [`EngineError::Failed`] for an unknown buffer or a failed write. /// [`EngineError::Failed`] when the file cannot be read as text.
fn save(state: &mut State, command: &str, id: BufferId) -> Result<u64, EngineError> { pub(super) fn open_buffer(
state: &mut State,
command: &str,
rel: &std::path::Path,
) -> Result<BufferId, EngineError> {
let abs = absolute(state, command, rel)?;
let before = stamp(&abs);
let file = lutra_vfs::read_text(&abs).map_err(vfs_error)?;
let buffer = OpenBuffer {
buffer: lutra_text::Buffer::new(&file.text),
path: rel.to_path_buf(),
version: 1,
saved_version: 1,
bom: file.bom,
};
let new_id = state.buffers.insert(buffer);
state.buffers.note_written(
new_id,
journal::hex_hash(file.text.as_bytes()),
file.bom,
before,
);
Ok(new_id)
}
/// Whether another program changed the file of buffer `id` at `abs`
/// since Lutra last read or wrote it. Not when the stamp is unchanged, the
/// text is the same (a touch), the file is gone, or the buffer has no
/// record (restored from the recovery journal). A file that exists but
/// cannot be read as text counts as changed.
fn newer_on_disk(state: &State, id: BufferId, abs: &std::path::Path) -> bool {
let Some(written) = state.buffers.written(id) else {
return false;
};
let Some(now) = stamp(abs) else {
return false;
};
if written.stamp == Some(now) {
return false;
}
match lutra_vfs::read_text(abs) {
Ok(file) => {
journal::hex_hash(file.text.as_bytes()) != written.hash || file.bom != written.bom
}
Err(lutra_vfs::VfsError::NotFound { .. }) => false,
Err(_) => true,
}
}
/// Writes buffer `id` to its file, keeping its line ending and byte order
/// mark, marks it clean, settles a disk conflict (saving is the user's
/// answer to it), remembers what was written, so the watcher's report of
/// this write is not taken for an outside change, and records Local
/// History snapshots: the file's previous text when the history does not
/// have it yet ([`Reason::BeforeSave`]), then the saved text
/// ([`Reason::Save`]).
///
/// # Parameters
/// - `overwrite`: write even if another program changed the file since
/// Lutra last read or wrote it.
///
/// # Errors
/// [`EngineError::DiskChanged`] when the file is newer and `overwrite` is
/// false; [`EngineError::Failed`] for an unknown buffer or a failed write.
fn save(
state: &mut State,
command: &str,
id: BufferId,
overwrite: bool,
) -> Result<u64, EngineError> {
let open = state
.buffers
.get(id)
.ok_or_else(|| EngineError::Failed(format!("no buffer {id}")))?;
let rel = open.path.clone();
let abs = absolute(state, command, &rel)?;
if !overwrite && newer_on_disk(state, id, &abs) {
return Err(EngineError::DiskChanged(path_string(&rel)));
}
snapshot_before_save(state, id, &rel, &abs, overwrite);
let open = state let open = state
.buffers .buffers
.get(id) .get(id)
.ok_or_else(|| EngineError::Failed(format!("no buffer {id}")))?; .ok_or_else(|| EngineError::Failed(format!("no buffer {id}")))?;
let abs = absolute(state, command, &open.path)?;
let text = open.buffer.save_text(); let text = open.buffer.save_text();
let bom = open.bom; let bom = open.bom;
lutra_vfs::write_text(&abs, &text, bom).map_err(vfs_error)?; lutra_vfs::write_text(&abs, &text, bom).map_err(vfs_error)?;
state state
.buffers .buffers
.note_written(id, journal::hex_hash(text.as_bytes()), bom); .note_written(id, journal::hex_hash(text.as_bytes()), bom, stamp(&abs));
state.buffers.clear_conflict(id); settle_conflict(state, id);
history::snapshot(state, &rel, &text, bom, Reason::Save);
state.buffers.mark_in_history(id);
let open = state let open = state
.buffers .buffers
.get_mut(id) .get_mut(id)
@ -103,17 +183,41 @@ fn save(state: &mut State, command: &str, id: BufferId) -> Result<u64, EngineErr
let was_dirty = open.dirty(); let was_dirty = open.dirty();
open.saved_version = open.version; open.saved_version = open.version;
let version = open.version; let version = open.version;
let path = open.path.clone();
journal::forget(state, id); journal::forget(state, id);
if was_dirty { if was_dirty {
state.emit(Event::DirtyChanged { id, dirty: false }); state.emit(Event::DirtyChanged { id, dirty: false });
} }
super::deploy::saved(state, &path.to_string_lossy().replace('\\', "/")); super::deploy::saved(state, &path_string(&rel));
Ok(version) Ok(version)
} }
/// Writes buffer `id` to disk like `file.save`, for other commands (such as /// Puts the text a save is about to overwrite into the Local History
/// `deploy.upload`, which saves before it uploads). /// unless the history already holds it: Lutra saved it or reloaded it
/// ([`crate::buffers::Buffers::mark_in_history`]) and the save is not an
/// overwrite of a newer file. So only the first save of a file opened this
/// session, or an overwrite, reads the file once more. Best effort, like
/// every snapshot.
fn snapshot_before_save(
state: &mut State,
id: BufferId,
rel: &std::path::Path,
abs: &std::path::Path,
overwrite: bool,
) {
if state.history.is_none() {
return;
}
if !overwrite && state.buffers.written(id).is_some_and(|w| w.in_history) {
return;
}
let Ok(file) = lutra_vfs::read_text(abs) else {
return;
};
history::snapshot(state, rel, &file.text, file.bom, Reason::BeforeSave);
}
/// Writes buffer `id` to disk like `file.save` (without `overwrite`), for
/// other commands (such as `deploy.upload`, which saves before it uploads).
/// ///
/// # Errors /// # Errors
/// Like `file.save`. /// Like `file.save`.
@ -122,7 +226,7 @@ pub(super) fn save_buffer(
command: &str, command: &str,
id: BufferId, id: BufferId,
) -> Result<u64, EngineError> { ) -> Result<u64, EngineError> {
save(state, command, id) save(state, command, id, false)
} }
/// Params of `file.save`. /// Params of `file.save`.
@ -131,6 +235,10 @@ pub(super) fn save_buffer(
struct SaveParams { struct SaveParams {
/// Buffer id. /// Buffer id.
id: BufferId, id: BufferId,
/// Write even if another program changed the file since Lutra last
/// read or wrote it (the user agreed to overwrite it).
#[serde(default)]
overwrite: bool,
} }
/// `file.save`: writes one buffer to disk. /// `file.save`: writes one buffer to disk.
@ -143,7 +251,7 @@ impl Command for Save {
label: "Save", label: "Save",
menu_path: Some("File/Save"), menu_path: Some("File/Save"),
default_shortcut: Some("Mod+S"), default_shortcut: Some("Mod+S"),
params: "{ id: number }; returns { id, version }", params: "{ id: number, overwrite?: boolean (write even though another program changed the file) }; returns { id, version }; fails with disk_changed when the file on disk changed since Lutra last read or wrote it and overwrite is not set",
} }
} }
@ -153,7 +261,7 @@ impl Command for Save {
fn run(&self, state: &mut State, params: Value) -> Result<Outcome, EngineError> { fn run(&self, state: &mut State, params: Value) -> Result<Outcome, EngineError> {
let p: SaveParams = parse(self.spec().id, params)?; let p: SaveParams = parse(self.spec().id, params)?;
let version = save(state, self.spec().id, p.id)?; let version = save(state, self.spec().id, p.id, p.overwrite)?;
Ok(Outcome::value(json!({ "id": p.id, "version": version }))) Ok(Outcome::value(json!({ "id": p.id, "version": version })))
} }
} }
@ -171,7 +279,9 @@ struct SaveAllParams {
/// `file.saveAll`: writes every dirty buffer. A failure doesn't stop the /// `file.saveAll`: writes every dirty buffer. A failure doesn't stop the
/// others; failures are listed in the result. With `skipConflicts` a dirty /// others; failures are listed in the result. With `skipConflicts` a dirty
/// buffer whose file changed or disappeared on disk is not written and is /// buffer whose file changed or disappeared on disk is not written and is
/// listed under `skipped`. /// listed under `skipped`. A buffer whose file another program changed is
/// never written by it and is listed under `diskChanged` (save it alone,
/// with `overwrite`, after asking).
pub struct SaveAll; pub struct SaveAll;
impl Command for SaveAll { impl Command for SaveAll {
@ -181,7 +291,7 @@ impl Command for SaveAll {
label: "Save All", label: "Save All",
menu_path: Some("File/Save All"), menu_path: Some("File/Save All"),
default_shortcut: Some("Mod+Alt+S"), default_shortcut: Some("Mod+Alt+S"),
params: "{ skipConflicts?: boolean (leave buffers whose file changed on disk unsaved) }; returns { saved: [id], failed: [{ id, path, message }], skipped: [id] }", params: "{ skipConflicts?: boolean (leave buffers whose file changed on disk unsaved) }; returns { saved: [id], failed: [{ id, path, message }], skipped: [id], diskChanged: [id] (files another program changed; not written) }",
} }
} }
@ -194,13 +304,15 @@ impl Command for SaveAll {
let mut saved = Vec::new(); let mut saved = Vec::new();
let mut failed = Vec::new(); let mut failed = Vec::new();
let mut skipped = Vec::new(); let mut skipped = Vec::new();
let mut disk_changed = Vec::new();
for id in state.buffers.dirty_ids() { for id in state.buffers.dirty_ids() {
if p.skip_conflicts && state.buffers.has_conflict(id) { if p.skip_conflicts && state.buffers.has_conflict(id) {
skipped.push(id); skipped.push(id);
continue; continue;
} }
match save(state, self.spec().id, id) { match save(state, self.spec().id, id, false) {
Ok(_) => saved.push(id), Ok(_) => saved.push(id),
Err(EngineError::DiskChanged(_)) => disk_changed.push(id),
Err(e) => { Err(e) => {
let path = state let path = state
.buffers .buffers
@ -211,13 +323,118 @@ impl Command for SaveAll {
} }
} }
} }
Ok(Outcome::value(json!({
"saved": saved,
"failed": failed,
"skipped": skipped,
"diskChanged": disk_changed,
})))
}
}
/// Params naming one buffer.
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct IdParams {
/// Buffer id.
id: BufferId,
}
/// `file.reload`: replaces a buffer's text with its file's ("Reload,
/// discard mine"). The discarded text goes into the Local History first.
pub struct Reload;
impl Command for Reload {
fn spec(&self) -> &CommandSpec {
&CommandSpec {
id: "file.reload",
label: "Reload from Disk",
menu_path: None,
default_shortcut: None,
params: "{ id: number }; replaces the buffer's text with the file's, discarding unsaved changes (they are kept in the Local History); returns { id, version, dirty: false }; failed when the file is gone or not text",
}
}
fn enabled(&self, state: &State) -> bool {
state.has_project()
}
fn run(&self, state: &mut State, params: Value) -> Result<Outcome, EngineError> {
let command = self.spec().id;
let p: IdParams = parse(command, params)?;
let open = state
.buffers
.get(p.id)
.ok_or_else(|| EngineError::Failed(format!("{command}: no buffer {}", p.id)))?;
let abs = absolute(state, command, &open.path)?;
let before = stamp(&abs);
let file = lutra_vfs::read_text(&abs).map_err(vfs_error)?;
crate::workspace::take_disk_text(state, p.id, file, before);
let version = state.buffers.get(p.id).map(|b| b.version).unwrap_or(0);
Ok(Outcome::value( Ok(Outcome::value(
json!({ "saved": saved, "failed": failed, "skipped": skipped }), json!({ "id": p.id, "version": version, "dirty": false }),
)) ))
} }
} }
/// Params of `file.readDisk`.
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct ReadDiskParams {
/// Project-relative or absolute path of the file.
path: String,
}
/// `file.readDisk`: the text of a file as it is on disk now, whatever its
/// buffer holds; the left side of "Compare" in the disk-conflict banner.
/// Answers like `git.show`, so the diff viewer reads both alike.
pub struct ReadDisk;
impl Command for ReadDisk {
fn spec(&self) -> &CommandSpec {
&CommandSpec {
id: "file.readDisk",
label: "Read File from Disk",
menu_path: None,
default_shortcut: None,
params: "{ path: string (project-relative or absolute inside the project) }; returns { text: string | null (null when the file does not exist), binary, tooLarge }",
}
}
fn enabled(&self, state: &State) -> bool {
state.has_project()
}
fn run(&self, state: &mut State, params: Value) -> Result<Outcome, EngineError> {
let command = self.spec().id;
let p: ReadDiskParams = parse(command, params)?;
let rel = project_path(state, command, &p.path)?;
let abs = absolute(state, command, &rel)?;
let value = match lutra_vfs::read_text(&abs) {
Ok(file) => json!({ "text": file.text, "binary": false, "tooLarge": false }),
Err(lutra_vfs::VfsError::NotFound { .. }) => {
json!({ "text": null, "binary": false, "tooLarge": false })
}
Err(lutra_vfs::VfsError::TooLarge { .. }) => {
json!({ "text": null, "binary": false, "tooLarge": true })
}
Err(
lutra_vfs::VfsError::InvalidUtf8 { .. }
| lutra_vfs::VfsError::UnsupportedEncoding { .. },
) => json!({ "text": null, "binary": true, "tooLarge": false }),
Err(e) => return Err(vfs_error(e)),
};
Ok(Outcome::value(value))
}
}
/// The ids of the commands this module registers, checked against the /// The ids of the commands this module registers, checked against the
/// registry by the engine's listing test. Add a new command's id here. /// registry by the engine's listing test. Add a new command's id here.
#[cfg(test)] #[cfg(test)]
pub(crate) const COMMAND_IDS: &[&str] = &["file.open", "file.save", "file.saveAll"]; pub(crate) const COMMAND_IDS: &[&str] = &[
"file.open",
"file.readDisk",
"file.reload",
"file.save",
"file.saveAll",
];

View file

@ -300,7 +300,9 @@ pub(super) fn start_then(
start(state, command, Op::Custom { mutates, run }, Some(then)) start(state, command, Op::Custom { mutates, run }, Some(then))
} }
/// Runs `op` on a new thread and returns the pending outcome. /// Runs `op` on a new thread and returns the pending outcome. A command
/// that changes files first snapshots the open buffers into the Local
/// History ([`crate::history::before_git`]).
/// ///
/// # Errors /// # Errors
/// [`EngineError::Disabled`] without a project, [`EngineError::Failed`] /// [`EngineError::Disabled`] without a project, [`EngineError::Failed`]
@ -311,6 +313,7 @@ fn start(
op: Op, op: Op,
then: Option<ThenFn>, then: Option<ThenFn>,
) -> Result<Outcome, EngineError> { ) -> Result<Outcome, EngineError> {
crate::history::before_git(state, command);
let project = state let project = state
.project .project
.as_ref() .as_ref()

View file

@ -156,12 +156,15 @@ fn engine_error(command: &str, error: VcsError) -> EngineError {
} }
} }
/// Runs `op` on a new thread and returns the pending outcome. /// Runs `op` on a new thread and returns the pending outcome. A pull
/// first snapshots the open buffers into the Local History
/// ([`crate::history::before_git`]).
/// ///
/// # Errors /// # Errors
/// [`EngineError::Disabled`] without a project (except for clone), /// [`EngineError::Disabled`] without a project (except for clone),
/// [`EngineError::Failed`] while another network call runs. /// [`EngineError::Failed`] while another network call runs.
fn start(state: &mut State, command: &'static str, op: Op) -> Result<Outcome, EngineError> { fn start(state: &mut State, command: &'static str, op: Op) -> Result<Outcome, EngineError> {
crate::history::before_git(state, command);
let project = state let project = state
.project .project
.as_ref() .as_ref()

View file

@ -0,0 +1,191 @@
//! Local History commands (C10 A2): `history.list`, `history.read`,
//! `history.revert`. The store and when snapshots are taken:
//! [`crate::history`].
//!
//! `history.read` answers like `git.show`, so the diff viewer compares a
//! snapshot with the working copy as it compares a ref. `history.revert`
//! changes the file's buffer through `buffer.edit` (opening the file
//! first if needed): the buffer becomes dirty and the editor can undo it;
//! nothing is written to disk until the user saves.
use serde::Deserialize;
use serde_json::{Value, json};
use super::params::{parse, project_path};
use crate::history::{self, Reason};
use crate::workspace::path_string;
use crate::{Command, CommandSpec, EngineError, Event, Outcome, Registry, State};
/// Registers the history commands.
///
/// # Errors
/// [`EngineError::Internal`] if an id is taken.
pub fn register(registry: &mut Registry) -> Result<(), EngineError> {
registry.register(Box::new(List))?;
registry.register(Box::new(Read))?;
registry.register(Box::new(Revert))?;
Ok(())
}
/// The history of the open project.
///
/// # Errors
/// [`EngineError::Failed`] when the project has none (no persistence, or it
/// failed to open; the warning said why).
fn store<'a>(state: &'a State, command: &str) -> Result<&'a history::History, EngineError> {
state.history.as_ref().ok_or_else(|| {
EngineError::Failed(format!(
"{command}: Local History is not available for this project"
))
})
}
/// Params of `history.list`.
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct ListParams {
/// Project-relative or absolute path of the file.
path: String,
}
/// `history.list`: the snapshots of a file, newest first.
pub struct List;
impl Command for List {
fn spec(&self) -> &CommandSpec {
&CommandSpec {
id: "history.list",
label: "List Local History",
menu_path: None,
default_shortcut: None,
params: "{ path: string }; returns { path, entries: [{ id, time (ms since the Unix epoch), reason: save|beforeSave|externalChange|beforeReload|deleted|refactoring|git|beforeRevert, size (bytes) }] } newest first; failed when the project has no Local History",
}
}
fn enabled(&self, state: &State) -> bool {
state.has_project()
}
fn run(&self, state: &mut State, params: Value) -> Result<Outcome, EngineError> {
let command = self.spec().id;
let p: ListParams = parse(command, params)?;
let rel = path_string(&project_path(state, command, &p.path)?);
let entries: Vec<Value> = store(state, command)?
.list(&rel)
.into_iter()
.map(|s| json!({ "id": s.id, "time": s.time, "reason": s.reason, "size": s.size }))
.collect();
Ok(Outcome::value(json!({ "path": rel, "entries": entries })))
}
}
/// Params naming one snapshot.
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct EntryParams {
/// Project-relative or absolute path of the file.
path: String,
/// The snapshot's id from `history.list`.
id: u64,
}
/// The text of snapshot `id` of the project-relative `rel`.
///
/// # Errors
/// [`EngineError::Failed`] for an unknown snapshot or an unreadable text.
fn snapshot_text(state: &State, command: &str, rel: &str, id: u64) -> Result<String, EngineError> {
let store = store(state, command)?;
let snapshot = store.get(rel, id).ok_or_else(|| {
EngineError::Failed(format!("{command}: {rel} has no Local History entry {id}"))
})?;
store
.text(snapshot)
.map_err(|e| EngineError::Failed(format!("{command}: {e}")))
}
/// `history.read`: the text of one snapshot.
pub struct Read;
impl Command for Read {
fn spec(&self) -> &CommandSpec {
&CommandSpec {
id: "history.read",
label: "Read Local History Entry",
menu_path: None,
default_shortcut: None,
params: "{ path: string, id: number (from history.list) }; returns { text, binary: false, tooLarge: false } like git.show; failed for an unknown or damaged entry",
}
}
fn enabled(&self, state: &State) -> bool {
state.has_project()
}
fn run(&self, state: &mut State, params: Value) -> Result<Outcome, EngineError> {
let command = self.spec().id;
let p: EntryParams = parse(command, params)?;
let rel = path_string(&project_path(state, command, &p.path)?);
let text = snapshot_text(state, command, &rel, p.id)?;
Ok(Outcome::value(
json!({ "text": text, "binary": false, "tooLarge": false }),
))
}
}
/// `history.revert`: puts a snapshot's text into the file's buffer.
pub struct Revert;
impl Command for Revert {
fn spec(&self) -> &CommandSpec {
&CommandSpec {
id: "history.revert",
label: "Revert to Local History Entry",
menu_path: None,
default_shortcut: None,
params: "{ path: string, id: number (from history.list) }; replaces the text of the file's buffer (opened first if needed, emitting bufferOpened) with the entry's through buffer.edit, so it is undoable and unsaved; the text it replaces is kept as a beforeRevert entry; returns { id (buffer), version, dirty }",
}
}
fn enabled(&self, state: &State) -> bool {
state.has_project()
}
fn run(&self, state: &mut State, params: Value) -> Result<Outcome, EngineError> {
let command = self.spec().id;
let p: EntryParams = parse(command, params)?;
let rel_path = project_path(state, command, &p.path)?;
let rel = path_string(&rel_path);
let text = snapshot_text(state, command, &rel, p.id)?;
let id = match state.buffers.find(&rel_path) {
Some(id) => id,
None => {
let id = super::file::open_buffer(state, command, &rel_path)?;
state.emit(Event::BufferOpened {
id,
path: rel.clone(),
});
id
}
};
history::snapshot_buffer(state, id, Reason::BeforeRevert);
let open = state
.buffers
.get(id)
.ok_or_else(|| EngineError::Failed(format!("{command}: no buffer {id}")))?;
let (base, len) = (open.version, open.buffer.len_utf16());
let out = super::buffer::Edit.run(
state,
json!({
"id": id,
"baseVersion": base,
"edits": [{ "from": 0, "to": len, "insert": text }],
}),
)?;
Ok(out)
}
}
/// The ids of the commands this module registers, checked against the
/// registry by the engine's listing test. Add a new command's id here.
#[cfg(test)]
pub(crate) const COMMAND_IDS: &[&str] = &["history.list", "history.read", "history.revert"];

View file

@ -11,7 +11,8 @@
//! sent; a buffer the user changed meanwhile refuses the edit (the ranges //! sent; a buffer the user changed meanwhile refuses the edit (the ranges
//! would be stale). //! would be stale).
//! //!
//! Then closed files are written, each atomically through the VFS. If a //! Before anything changes, every document's text goes into the Local
//! History (`crate::history`). Then closed files are written, each atomically through the VFS. If a
//! write fails, the files written so far are restored to their old content //! write fails, the files written so far are restored to their old content
//! (best effort; a failed restore is reported in the error) and no buffer //! (best effort; a failed restore is reported in the error) and no buffer
//! is touched. Only after every file is written are the open buffers changed, //! is touched. Only after every file is written are the open buffers changed,
@ -109,6 +110,7 @@ pub fn apply(
versions: &BTreeMap<BufferId, u64>, versions: &BTreeMap<BufferId, u64>,
) -> Result<Applied, EngineError> { ) -> Result<Applied, EngineError> {
let plan = plan(state, root, edit, versions)?; let plan = plan(state, root, edit, versions)?;
snapshot(state, &plan);
let mut applied = Applied::default(); let mut applied = Applied::default();
let mut written: Vec<(PathBuf, &str, bool)> = Vec::new(); let mut written: Vec<(PathBuf, &str, bool)> = Vec::new();
for (rel, planned, count) in &plan { for (rel, planned, count) in &plan {
@ -159,6 +161,21 @@ pub fn apply(
Ok(applied) Ok(applied)
} }
/// Puts the text of every document the edit is about to change into the
/// Local History ([`crate::history::Reason::Refactoring`]), once the whole
/// edit has been checked.
fn snapshot(state: &mut State, plan: &[(PathBuf, Planned, usize)]) {
use crate::history::{self, Reason};
for (rel, planned, _) in plan {
match planned {
Planned::Buffer { id, .. } => history::snapshot_buffer(state, *id, Reason::Refactoring),
Planned::Disk { old, bom, .. } => {
history::snapshot(state, rel, old, *bom, Reason::Refactoring);
}
}
}
}
/// Writes the old contents back into files written by a failed edit. /// Writes the old contents back into files written by a failed edit.
/// ///
/// # Returns /// # Returns

View file

@ -15,6 +15,7 @@ pub mod git_merge;
pub mod git_remote; pub mod git_remote;
pub mod git_stash; pub mod git_stash;
pub mod goto; pub mod goto;
mod history;
mod layout; mod layout;
mod lsp_assist; mod lsp_assist;
mod lsp_diagnostics; mod lsp_diagnostics;
@ -46,6 +47,8 @@ pub fn register_builtins(registry: &mut Registry) -> Result<(), EngineError> {
registry.register(Box::new(file::Open))?; registry.register(Box::new(file::Open))?;
registry.register(Box::new(file::Save))?; registry.register(Box::new(file::Save))?;
registry.register(Box::new(file::SaveAll))?; registry.register(Box::new(file::SaveAll))?;
registry.register(Box::new(file::Reload))?;
registry.register(Box::new(file::ReadDisk))?;
registry.register(Box::new(buffer::Get))?; registry.register(Box::new(buffer::Get))?;
registry.register(Box::new(buffer::Edit))?; registry.register(Box::new(buffer::Edit))?;
registry.register(Box::new(buffer::Close))?; registry.register(Box::new(buffer::Close))?;
@ -90,6 +93,7 @@ pub fn register_builtins(registry: &mut Registry) -> Result<(), EngineError> {
git_ignore::register(registry)?; git_ignore::register(registry)?;
deploy::register(registry)?; deploy::register(registry)?;
layout::register(registry)?; layout::register(registry)?;
history::register(registry)?;
Ok(()) Ok(())
} }
@ -114,6 +118,7 @@ pub(crate) const BUILTIN_COMMAND_IDS: &[&[&str]] = &[
git_stash::COMMAND_IDS, git_stash::COMMAND_IDS,
goto::COMMAND_IDS, goto::COMMAND_IDS,
layout::COMMAND_IDS, layout::COMMAND_IDS,
history::COMMAND_IDS,
lsp_assist::COMMAND_IDS, lsp_assist::COMMAND_IDS,
lsp_diagnostics::COMMAND_IDS, lsp_diagnostics::COMMAND_IDS,
lsp_nav::COMMAND_IDS, lsp_nav::COMMAND_IDS,

View file

@ -57,6 +57,7 @@ pub fn close_project(state: &mut State, force: bool) -> Result<(), EngineError>
state.emit(Event::BufferClosed { id }); state.emit(Event::BufferClosed { id });
} }
state.journal = None; state.journal = None;
state.history = None;
state.project = None; state.project = None;
crate::cmd::goto::close(state); crate::cmd::goto::close(state);
state.emit(Event::ProjectClosed); state.emit(Event::ProjectClosed);
@ -100,6 +101,7 @@ impl Command for Open {
.as_ref() .as_ref()
.map(|c| Journal::new(&c.data_dir, &root)); .map(|c| Journal::new(&c.data_dir, &root));
state.project = Some(workspace); state.project = Some(workspace);
crate::history::open(state);
let mut name = String::new(); let mut name = String::new();
for event in events { for event in events {
if let Event::ProjectOpened { name: n, .. } = &event { if let Event::ProjectOpened { name: n, .. } = &event {

View file

@ -37,6 +37,11 @@ pub enum EngineError {
/// discard them. /// discard them.
#[error("{0} has unsaved changes")] #[error("{0} has unsaved changes")]
UnsavedChanges(String), UnsavedChanges(String),
/// A save would overwrite a file that another program changed since
/// Lutra last read or wrote it. Repeat it with `overwrite` after the
/// user agreed.
#[error("{0} changed on disk since it was last loaded or saved")]
DiskChanged(String),
/// The command ran and failed, e.g. a file could not be read. /// The command ran and failed, e.g. a file could not be read.
#[error("{0}")] #[error("{0}")]
Failed(String), Failed(String),
@ -55,6 +60,7 @@ impl EngineError {
Self::InvalidParams { .. } => "invalid_params", Self::InvalidParams { .. } => "invalid_params",
Self::StaleVersion { .. } => "stale_version", Self::StaleVersion { .. } => "stale_version",
Self::UnsavedChanges(_) => "unsaved_changes", Self::UnsavedChanges(_) => "unsaved_changes",
Self::DiskChanged(_) => "disk_changed",
Self::Failed(_) => "failed", Self::Failed(_) => "failed",
Self::Internal(_) => "internal", Self::Internal(_) => "internal",
} }

View file

@ -83,6 +83,13 @@ pub enum Event {
/// The file was removed or renamed away. /// The file was removed or renamed away.
removed: bool, removed: bool,
}, },
/// A buffer's disk conflict ([`Event::FileChangedOnDisk`]) is settled:
/// it was saved or reloaded, or its file came back with the buffer's
/// text. Clients drop the banner.
DiskConflictResolved {
/// The open buffer.
id: u64,
},
/// File watching stopped; the project keeps working without it. /// File watching stopped; the project keeps working without it.
WatchFailed { WatchFailed {
/// Why. /// Why.

View file

@ -0,0 +1,717 @@
//! Local History (C10 A2): snapshots of file texts taken by the engine, so
//! a save, an outside change, a refactoring or a git operation can always be
//! undone from Lutra, also for files git does not track.
//!
//! # Layout
//! `<data_dir>/history/<project-id>/`, the project id being the FNV-1a hash
//! of the canonical project root as in [`crate::journal`]. Never inside the
//! project: a data directory below the project root disables the history.
//! - `blobs/<h0h1>/<hash>`: the text of a snapshot, as written to disk
//! (line endings kept, without the byte order mark), named by its SHA-256
//! in hex. Content-addressed, so equal texts are stored once.
//! - `index.jsonl`: one [`Snapshot`] per line, oldest first. New snapshots
//! are appended; pruning rewrites the file atomically.
//!
//! # When snapshots are taken
//! See [`Reason`]. A snapshot whose text equals the newest snapshot of the
//! same path is not added, so repeated saves of the same text (autosave)
//! cost nothing. Texts over [`MAX_SNAPSHOT_BYTES`] are not kept.
//!
//! # Retention (owner decision D29)
//! Snapshots older than [`KEEP`] are dropped, and while the blobs of a
//! project take more than [`MAX_BYTES`] the oldest snapshots go first. Both
//! run when the project opens ([`History::open`], which also deletes blob
//! files no snapshot refers to), and the size cap again whenever a new
//! snapshot pushes the total over it.
//!
//! # Untrusted input
//! The index is read with a size cap ([`MAX_INDEX_BYTES`], at most
//! [`MAX_SNAPSHOTS`] lines); malformed lines and lines whose hash is not 64
//! hex digits are skipped. A blob is checked against its hash when read.
//! Failures never stop a save or a reload: the engine reports them once as
//! a warning ([`KEY_FAILED`]) and carries on without that snapshot.
use std::collections::{BTreeMap, BTreeSet};
use std::io::Write;
use std::path::{Path, PathBuf};
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use serde::{Deserialize, Serialize};
use crate::buffers::BufferId;
use crate::workspace::path_string;
use crate::{NotificationLevel, State};
/// How long snapshots are kept (D29: 14 days).
pub const KEEP: Duration = Duration::from_secs(14 * 24 * 60 * 60);
/// Most bytes the blobs of one project may take (D29: 200 MB).
pub const MAX_BYTES: u64 = 200 * 1024 * 1024;
/// Largest text kept as a snapshot.
pub const MAX_SNAPSHOT_BYTES: usize = 16 * 1024 * 1024;
/// Largest index file read.
pub const MAX_INDEX_BYTES: u64 = 64 * 1024 * 1024;
/// Most snapshots kept per project; the oldest go first beyond it.
pub const MAX_SNAPSHOTS: usize = 100_000;
/// Most blob files looked at when deleting unreferenced ones.
const MAX_BLOB_SCAN: usize = 200_000;
/// File name of the index.
const INDEX: &str = "index.jsonl";
/// Directory of the blobs.
const BLOBS: &str = "blobs";
/// Catalog key of the warning for a history that cannot be read or written.
pub const KEY_FAILED: &str = "notification.history.failed";
/// Why a snapshot was taken.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum Reason {
/// The text Lutra saved (`file.save`, `file.saveAll`, autosave).
Save,
/// The file's text on disk before Lutra's first save over it.
BeforeSave,
/// A new text another program wrote, as Lutra read it.
ExternalChange,
/// The buffer's text before a reload from disk replaced it.
BeforeReload,
/// The buffer's text when its file disappeared from disk.
Deleted,
/// The text before a refactoring (`lsp.rename`) changed it.
Refactoring,
/// The text before a git operation that changes files (checkout,
/// stash, merge, pull, revert chunk).
Git,
/// The buffer's text before `history.revert` replaced it.
BeforeRevert,
}
/// One snapshot as stored in the index.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Snapshot {
/// Unique within the project's history, increasing.
pub id: u64,
/// When it was taken, in milliseconds since the Unix epoch.
pub time: u64,
/// Project-relative path with `/` separators.
pub path: String,
/// SHA-256 of the text in hex: the blob's name.
pub hash: String,
/// Size of the text in bytes.
pub size: u64,
/// Why it was taken.
pub reason: Reason,
/// The file has a UTF-8 byte order mark.
pub bom: bool,
}
/// The Local History of the open project.
#[derive(Debug)]
pub struct History {
/// `<data_dir>/history/<project-id>`; created on the first snapshot.
dir: PathBuf,
/// Snapshots, oldest first.
snapshots: Vec<Snapshot>,
/// Size of each blob that a snapshot refers to.
blobs: BTreeMap<String, u64>,
/// The id the next snapshot gets.
next_id: u64,
/// Most bytes the blobs may take: [`MAX_BYTES`], smaller in tests.
max_bytes: u64,
}
/// Milliseconds since the Unix epoch; 0 before it.
pub fn millis(time: SystemTime) -> u64 {
time.duration_since(UNIX_EPOCH)
.map(|d| u64::try_from(d.as_millis()).unwrap_or(u64::MAX))
.unwrap_or(0)
}
/// SHA-256 of `bytes` in lowercase hex.
pub fn sha256_hex(bytes: &[u8]) -> String {
lutra_lsp::toolchain::download::Hash::of_bytes(bytes).to_hex()
}
/// Whether `hash` is 64 lowercase hex digits, so it can name a blob file.
fn valid_hash(hash: &str) -> bool {
hash.len() == 64
&& hash
.bytes()
.all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b))
}
impl History {
/// Opens the history of the project at the canonical `root` below
/// `data_dir`, reads its index and prunes it for `now` (see the module
/// docs).
///
/// # Errors
/// A message when the history directory would lie inside the project,
/// or the index exists but cannot be read.
pub fn open(data_dir: &Path, root: &Path, now: SystemTime) -> Result<Self, String> {
let dir = data_dir
.join("history")
.join(crate::journal::hex_hash(root.to_string_lossy().as_bytes()));
if dir.starts_with(root) {
return Err(format!(
"the data directory {} lies inside the project; Local History is off",
data_dir.display()
));
}
let mut history = Self {
dir,
snapshots: Vec::new(),
blobs: BTreeMap::new(),
next_id: 1,
max_bytes: MAX_BYTES,
};
history.load()?;
let dropped = history.prune(now);
if dropped > 0 {
history.rewrite_index()?;
}
history.delete_unreferenced();
Ok(history)
}
/// Lowers the size cap, for tests that should not write 200 MB.
#[cfg(test)]
fn set_max_bytes(&mut self, max: u64) {
self.max_bytes = max;
}
/// The history directory.
pub fn dir(&self) -> &Path {
&self.dir
}
/// Bytes the referenced blobs take.
pub fn total_bytes(&self) -> u64 {
self.blobs.values().sum()
}
/// Reads the index, skipping malformed lines.
fn load(&mut self) -> Result<(), String> {
let file = self.dir.join(INDEX);
let bytes = match lutra_vfs::read_bytes(&file, MAX_INDEX_BYTES) {
Ok(bytes) => bytes,
Err(lutra_vfs::VfsError::NotFound { .. }) => return Ok(()),
Err(e) => return Err(format!("cannot read {}: {e}", file.display())),
};
let text = String::from_utf8_lossy(&bytes);
for line in text.lines().filter(|l| !l.trim().is_empty()) {
let Ok(snapshot) = serde_json::from_str::<Snapshot>(line) else {
continue;
};
if !valid_hash(&snapshot.hash) || snapshot.path.is_empty() {
continue;
}
self.next_id = self.next_id.max(snapshot.id.saturating_add(1));
self.blobs.insert(snapshot.hash.clone(), snapshot.size);
self.snapshots.push(snapshot);
}
self.snapshots.sort_by_key(|s| (s.time, s.id));
Ok(())
}
/// Drops snapshots older than [`KEEP`] at `now`, then the oldest ones
/// while the blobs take more than the cap ([`MAX_BYTES`]) or there are more than
/// [`MAX_SNAPSHOTS`], and deletes the blobs no snapshot refers to any
/// more.
///
/// # Returns
/// How many snapshots were dropped.
fn prune(&mut self, now: SystemTime) -> usize {
let cutoff = millis(now.checked_sub(KEEP).unwrap_or(UNIX_EPOCH));
let before = self.snapshots.len();
let mut keep: Vec<Snapshot> = std::mem::take(&mut self.snapshots)
.into_iter()
.filter(|s| s.time >= cutoff)
.collect();
let mut sizes: BTreeMap<String, u64> = BTreeMap::new();
let mut refs: BTreeMap<String, usize> = BTreeMap::new();
for s in &keep {
sizes.insert(s.hash.clone(), s.size);
*refs.entry(s.hash.clone()).or_default() += 1;
}
let mut total: u64 = sizes.values().sum();
let mut first = 0;
while first < keep.len()
&& (total > self.max_bytes || keep.len().saturating_sub(first) > MAX_SNAPSHOTS)
{
if let Some(s) = keep.get(first) {
let left = refs.get_mut(&s.hash).map(|n| {
*n = n.saturating_sub(1);
*n
});
if left == Some(0) {
refs.remove(&s.hash);
total = total.saturating_sub(sizes.remove(&s.hash).unwrap_or(0));
}
}
first += 1;
}
keep.drain(..first);
let gone: Vec<String> = self
.blobs
.keys()
.filter(|h| !sizes.contains_key(*h))
.cloned()
.collect();
for hash in &gone {
let _ = std::fs::remove_file(self.blob_path(hash));
}
self.snapshots = keep;
self.blobs = sizes;
before.saturating_sub(self.snapshots.len())
}
/// Deletes blob files no snapshot refers to (left by a crash between
/// writing a blob and its index line, or by an older pruning). Best
/// effort: a file that cannot be deleted is tried again next time.
fn delete_unreferenced(&self) {
let Ok(shards) = std::fs::read_dir(self.dir.join(BLOBS)) else {
return;
};
let mut seen = 0usize;
for shard in shards.flatten() {
let Ok(files) = std::fs::read_dir(shard.path()) else {
continue;
};
for file in files.flatten() {
seen += 1;
if seen > MAX_BLOB_SCAN {
return;
}
let name = file.file_name().to_string_lossy().into_owned();
if !self.blobs.contains_key(&name) {
let _ = std::fs::remove_file(file.path());
}
}
}
}
/// Writes the whole index again, atomically.
fn rewrite_index(&self) -> Result<(), String> {
let mut out = String::new();
for s in &self.snapshots {
let line = serde_json::to_string(s).map_err(|e| e.to_string())?;
out.push_str(&line);
out.push('\n');
}
std::fs::create_dir_all(&self.dir)
.map_err(|e| format!("cannot create {}: {e}", self.dir.display()))?;
lutra_vfs::write_atomic(&self.dir.join(INDEX), out.as_bytes())
.map_err(|e| format!("cannot write the Local History index: {e}"))
}
/// The file of the blob `hash`.
fn blob_path(&self, hash: &str) -> PathBuf {
let shard = hash.get(..2).unwrap_or("00");
self.dir.join(BLOBS).join(shard).join(hash)
}
/// The newest snapshot of `path`.
pub fn latest(&self, path: &str) -> Option<&Snapshot> {
self.snapshots.iter().rev().find(|s| s.path == path)
}
/// Adds a snapshot of `text` for `path` at `now`, unless it equals the
/// newest snapshot of that path or is larger than
/// [`MAX_SNAPSHOT_BYTES`].
///
/// # Returns
/// The new snapshot's id, `None` when nothing was added.
///
/// # Errors
/// A message when the blob or the index line cannot be written.
pub fn record(
&mut self,
path: &str,
text: &str,
bom: bool,
reason: Reason,
now: SystemTime,
) -> Result<Option<u64>, String> {
if text.len() > MAX_SNAPSHOT_BYTES {
return Ok(None);
}
let hash = sha256_hex(text.as_bytes());
if self
.latest(path)
.is_some_and(|s| s.hash == hash && s.bom == bom)
{
return Ok(None);
}
let blob = self.blob_path(&hash);
if !blob.is_file() {
if let Some(parent) = blob.parent() {
std::fs::create_dir_all(parent)
.map_err(|e| format!("cannot create {}: {e}", parent.display()))?;
}
lutra_vfs::write_atomic(&blob, text.as_bytes())
.map_err(|e| format!("cannot write a Local History snapshot: {e}"))?;
}
let snapshot = Snapshot {
id: self.next_id,
time: millis(now),
path: path.to_string(),
hash: hash.clone(),
size: u64::try_from(text.len()).unwrap_or(u64::MAX),
reason,
bom,
};
let line = serde_json::to_string(&snapshot).map_err(|e| e.to_string())?;
let mut index = std::fs::OpenOptions::new()
.create(true)
.append(true)
.open(self.dir.join(INDEX))
.map_err(|e| format!("cannot open the Local History index: {e}"))?;
index
.write_all(format!("{line}\n").as_bytes())
.map_err(|e| format!("cannot write the Local History index: {e}"))?;
self.next_id = self.next_id.saturating_add(1);
let id = snapshot.id;
self.blobs.insert(hash, snapshot.size);
self.snapshots.push(snapshot);
if self.total_bytes() > self.max_bytes || self.snapshots.len() > MAX_SNAPSHOTS {
self.prune(now);
self.rewrite_index()?;
}
Ok(Some(id))
}
/// The snapshots of `path`, newest first.
pub fn list(&self, path: &str) -> Vec<&Snapshot> {
self.snapshots
.iter()
.rev()
.filter(|s| s.path == path)
.collect()
}
/// The snapshot `id` of `path`.
pub fn get(&self, path: &str, id: u64) -> Option<&Snapshot> {
self.snapshots.iter().find(|s| s.id == id && s.path == path)
}
/// The text of snapshot `snapshot`, checked against its hash.
///
/// # Errors
/// A message when the blob is missing, too large, not UTF-8 or does not
/// match its hash.
pub fn text(&self, snapshot: &Snapshot) -> Result<String, String> {
let blob = self.blob_path(&snapshot.hash);
let limit = u64::try_from(MAX_SNAPSHOT_BYTES).unwrap_or(u64::MAX);
let bytes = lutra_vfs::read_bytes(&blob, limit)
.map_err(|e| format!("the snapshot's text cannot be read: {e}"))?;
if sha256_hex(&bytes) != snapshot.hash {
return Err("the snapshot's text is damaged".into());
}
String::from_utf8(bytes).map_err(|_| "the snapshot's text is not UTF-8".into())
}
}
/// Opens the history of the open project into `state.history` (on
/// `project.open`). Without persistence there is none; a failure is
/// reported as a warning and leaves the history off for this project.
pub fn open(state: &mut State) {
state.history = None;
let (Some(config), Some(project)) = (state.config.as_ref(), state.project.as_ref()) else {
return;
};
let root = project.project.root().to_path_buf();
match History::open(&config.data_dir, &root, SystemTime::now()) {
Ok(history) => state.history = Some(history),
Err(message) => warn(state, message),
}
}
/// Reports a history failure as a warning notification.
fn warn(state: &mut State, message: String) {
let mut params = serde_json::Map::new();
params.insert("reason".into(), serde_json::Value::String(message.clone()));
state.notify(
NotificationLevel::Warning,
Some(KEY_FAILED),
Some(format!("Local History: {message}")),
Some(params),
);
}
/// Takes a snapshot of `text` for the project-relative `path`. Best
/// effort: without a history nothing happens, and a failure is reported as
/// a warning instead of failing the caller, because a save or a reload must
/// not stop for the history.
pub fn snapshot(state: &mut State, path: &Path, text: &str, bom: bool, reason: Reason) {
let Some(history) = state.history.as_mut() else {
return;
};
if let Err(message) = history.record(&path_string(path), text, bom, reason, SystemTime::now()) {
warn(state, message);
}
}
/// Takes a [`Reason::ExternalChange`] snapshot of `text`, unless the
/// newest such snapshot of `path` already holds it (the watcher recorded the
/// text when it saw it, and "Reload" reads it again).
pub fn snapshot_external(state: &mut State, path: &Path, text: &str, bom: bool) {
let Some(history) = state.history.as_ref() else {
return;
};
let shown = path_string(path);
let hash = sha256_hex(text.as_bytes());
if history
.list(&shown)
.into_iter()
.find(|s| s.reason == Reason::ExternalChange)
.is_some_and(|s| s.hash == hash && s.bom == bom)
{
return;
}
snapshot(state, path, text, bom, Reason::ExternalChange);
}
/// Takes a snapshot of buffer `id`'s text as it would be saved.
pub fn snapshot_buffer(state: &mut State, id: BufferId, reason: Reason) {
let Some(open) = state.buffers.get(id) else {
return;
};
let (path, text, bom) = (open.path.clone(), open.buffer.save_text(), open.bom);
snapshot(state, &path, &text, bom, reason);
}
/// The git commands that change files in the work tree; [`before_git`]
/// snapshots the open buffers before each.
pub const FILE_CHANGING_GIT: &[&str] = &[
"git.checkout",
"git.createBranch",
"git.merge",
"git.mergeAbort",
"git.stash",
"git.stashApply",
"git.revertChunk",
"git.pull",
];
/// Snapshots every open buffer before the git command `command` runs, if
/// it changes files ([`FILE_CHANGING_GIT`]). Files that are not open are
/// left to git: checkout, merge and pull refuse to overwrite local changes,
/// and stash keeps them.
pub fn before_git(state: &mut State, command: &str) {
if !FILE_CHANGING_GIT.contains(&command) || state.history.is_none() {
return;
}
let ids: BTreeSet<BufferId> = state.buffers.ids().into_iter().collect();
for id in ids {
snapshot_buffer(state, id, Reason::Git);
}
}
#[cfg(test)]
mod tests {
use super::*;
fn at(ms: u64) -> SystemTime {
UNIX_EPOCH + Duration::from_millis(ms)
}
const DAY: u64 = 24 * 60 * 60 * 1000;
fn open(data: &Path, root: &Path, now: SystemTime) -> History {
History::open(data, root, now).unwrap()
}
#[test]
fn snapshots_are_deduplicated_and_listed_newest_first() {
let data = tempfile::tempdir().unwrap();
let root = tempfile::tempdir().unwrap();
let mut h = open(data.path(), root.path(), at(100 * DAY));
let now = at(100 * DAY);
assert_eq!(
h.record("a.php", "one", false, Reason::Save, now).unwrap(),
Some(1)
);
assert_eq!(
h.record("a.php", "one", false, Reason::Save, now).unwrap(),
None
);
assert_eq!(
h.record("a.php", "two", false, Reason::Save, now).unwrap(),
Some(2)
);
assert_eq!(
h.record("b.php", "one", false, Reason::Save, now).unwrap(),
Some(3)
);
let ids: Vec<u64> = h.list("a.php").iter().map(|s| s.id).collect();
assert_eq!(ids, vec![2, 1]);
assert_eq!(h.total_bytes(), 6, "\"one\" is stored once");
let blobs = walk(&h.dir().join(BLOBS));
assert_eq!(blobs.len(), 2);
let first = h.get("a.php", 1).unwrap().clone();
assert_eq!(h.text(&first).unwrap(), "one");
assert!(h.get("b.php", 1).is_none(), "ids belong to their path");
}
fn walk(dir: &Path) -> Vec<PathBuf> {
let mut out = Vec::new();
for shard in std::fs::read_dir(dir).into_iter().flatten().flatten() {
for f in std::fs::read_dir(shard.path()).unwrap().flatten() {
out.push(f.path());
}
}
out
}
#[test]
fn the_index_survives_a_restart_and_ids_keep_increasing() {
let data = tempfile::tempdir().unwrap();
let root = tempfile::tempdir().unwrap();
let now = at(100 * DAY);
let mut h = open(data.path(), root.path(), now);
h.record("a.php", "one\r\n", true, Reason::Save, now)
.unwrap();
h.record("a.php", "two", false, Reason::ExternalChange, now)
.unwrap();
let mut again = open(data.path(), root.path(), now);
let list: Vec<(u64, Reason, bool)> = again
.list("a.php")
.iter()
.map(|s| (s.id, s.reason, s.bom))
.collect();
assert_eq!(
list,
vec![(2, Reason::ExternalChange, false), (1, Reason::Save, true)]
);
let first = again.get("a.php", 1).unwrap().clone();
assert_eq!(again.text(&first).unwrap(), "one\r\n", "line endings kept");
assert_eq!(
again
.record("a.php", "three", false, Reason::Save, now)
.unwrap(),
Some(3)
);
}
#[test]
fn old_snapshots_are_pruned_on_open_with_their_blobs() {
let data = tempfile::tempdir().unwrap();
let root = tempfile::tempdir().unwrap();
let mut h = open(data.path(), root.path(), at(0));
h.record("a.php", "old", false, Reason::Save, at(DAY))
.unwrap();
h.record("a.php", "new", false, Reason::Save, at(10 * DAY))
.unwrap();
let dir = h.dir().to_path_buf();
let h = open(data.path(), root.path(), at(16 * DAY));
let texts: Vec<String> = h.list("a.php").iter().map(|s| h.text(s).unwrap()).collect();
assert_eq!(texts, vec!["new".to_string()]);
assert_eq!(walk(&dir.join(BLOBS)).len(), 1, "the old blob is deleted");
let index = std::fs::read_to_string(dir.join(INDEX)).unwrap();
assert_eq!(index.lines().count(), 1, "the index is rewritten");
}
#[test]
fn the_size_cap_drops_the_oldest_snapshots_first() {
let data = tempfile::tempdir().unwrap();
let root = tempfile::tempdir().unwrap();
let now = at(100 * DAY);
let mut h = open(data.path(), root.path(), now);
h.set_max_bytes(1000);
for c in ['a', 'b', 'c', 'd', 'e'] {
h.record(
"big.txt",
&c.to_string().repeat(300),
false,
Reason::Save,
now,
)
.unwrap();
}
assert!(h.total_bytes() <= 1000);
let kept: Vec<u64> = h.list("big.txt").iter().map(|s| s.id).collect();
assert_eq!(kept, vec![5, 4, 3], "the two oldest went first");
assert_eq!(walk(&h.dir().join(BLOBS)).len(), 3);
let index = std::fs::read_to_string(h.dir().join(INDEX)).unwrap();
assert_eq!(index.lines().count(), 3);
}
#[test]
fn oversized_texts_are_not_kept() {
let data = tempfile::tempdir().unwrap();
let root = tempfile::tempdir().unwrap();
let now = at(100 * DAY);
let mut h = open(data.path(), root.path(), now);
let text = "x".repeat(MAX_SNAPSHOT_BYTES + 1);
assert_eq!(
h.record("a", &text, false, Reason::Save, now).unwrap(),
None
);
assert!(h.list("a").is_empty());
}
#[test]
fn a_damaged_index_or_blob_never_fails_the_open() {
let data = tempfile::tempdir().unwrap();
let root = tempfile::tempdir().unwrap();
let now = at(100 * DAY);
let mut h = open(data.path(), root.path(), now);
h.record("a.php", "good", false, Reason::Save, now).unwrap();
h.record("a.php", "other", false, Reason::Save, now)
.unwrap();
let dir = h.dir().to_path_buf();
let mut index = std::fs::read_to_string(dir.join(INDEX)).unwrap();
index.push_str("{not json\n");
index.push_str(&format!(
"{{\"id\":9,\"time\":{},\"path\":\"x\",\"hash\":\"../../evil\",\"size\":1,\"reason\":\"save\",\"bom\":false}}\n",
100 * DAY
));
std::fs::write(dir.join(INDEX), index).unwrap();
let other = h.list("a.php")[0].clone();
std::fs::write(h.blob_path(&other.hash), "tampered").unwrap();
let h = open(data.path(), root.path(), now);
assert_eq!(h.list("a.php").len(), 2);
assert!(
h.list("x").is_empty(),
"a hash that is no file name is skipped"
);
assert_eq!(
h.text(&other).unwrap_err(),
"the snapshot's text is damaged"
);
let good = h.list("a.php")[1].clone();
assert_eq!(h.text(&good).unwrap(), "good");
}
#[test]
fn unreferenced_blobs_are_deleted_on_open() {
let data = tempfile::tempdir().unwrap();
let root = tempfile::tempdir().unwrap();
let now = at(100 * DAY);
let mut h = open(data.path(), root.path(), now);
h.record("a.php", "kept", false, Reason::Save, now).unwrap();
let stray = h.blob_path(&sha256_hex(b"stray"));
std::fs::create_dir_all(stray.parent().unwrap()).unwrap();
std::fs::write(&stray, "stray").unwrap();
let h = open(data.path(), root.path(), now);
assert!(!stray.exists());
assert_eq!(walk(&h.dir().join(BLOBS)).len(), 1);
}
#[test]
fn a_data_dir_inside_the_project_is_refused() {
let root = tempfile::tempdir().unwrap();
let data = root.path().join(".lutra-data");
let err = History::open(&data, root.path(), at(0)).unwrap_err();
assert!(err.contains("inside the project"), "{err}");
assert!(!data.exists(), "nothing is written into the project");
}
}

View file

@ -1,7 +1,7 @@
//! Engine of Lutra (layer L4). //! Engine of Lutra (layer L4).
//! //!
//! Owns the command registry, the workspace state, the panic guard around every //! Owns the command registry, the workspace state, the panic guard around every
//! entry point and the crash-recovery journal. Every user-visible action is a //! entry point, the crash-recovery journal and the Local History. Every user-visible action is a
//! [`Command`]; menus, the palette, shortcuts, the CLI, the control channel and //! [`Command`]; menus, the palette, shortcuts, the CLI, the control channel and
//! MCP all reach it through [`Engine::execute`]. //! MCP all reach it through [`Engine::execute`].
@ -12,6 +12,7 @@ mod engine;
mod error; mod error;
mod event; mod event;
pub mod guard; pub mod guard;
pub mod history;
pub mod journal; pub mod journal;
pub mod lsp; pub mod lsp;
mod registry; mod registry;
@ -20,7 +21,7 @@ mod state;
pub mod theme; pub mod theme;
pub mod workspace; pub mod workspace;
pub use buffers::{BufferId, LineEndingName, OpenBuffer}; pub use buffers::{BufferId, DiskConflict, LineEndingName, OpenBuffer};
pub use command::{Answered, Command, CommandInfo, CommandSpec, Effect, Outcome, Pending, Reply}; pub use command::{Answered, Command, CommandInfo, CommandSpec, Effect, Outcome, Pending, Reply};
pub use engine::{Engine, EngineConfig, run_waiting}; pub use engine::{Engine, EngineConfig, run_waiting};
pub use error::{EngineError, ErrorPayload}; pub use error::{EngineError, ErrorPayload};

View file

@ -34,6 +34,9 @@ pub struct State {
/// The crash-recovery journal of the open project; `None` without a /// The crash-recovery journal of the open project; `None` without a
/// project or without persistence. /// project or without persistence.
pub journal: Option<Journal>, pub journal: Option<Journal>,
/// The Local History of the open project ([`crate::history`]); `None`
/// without a project, without persistence, or when it failed to open.
pub history: Option<crate::history::History>,
/// Ids of the engine's own commands, which UI commands may not take. /// Ids of the engine's own commands, which UI commands may not take.
pub engine_commands: BTreeSet<&'static str>, pub engine_commands: BTreeSet<&'static str>,
/// UI commands the frontend registered (`ui.registerCommands`), by id. /// UI commands the frontend registered (`ui.registerCommands`), by id.

View file

@ -28,7 +28,8 @@ use std::sync::mpsc::{Receiver, TryRecvError};
use lutra_text::Buffer; use lutra_text::Buffer;
use lutra_vfs::{Project, VfsError, VfsEvent, Watcher}; use lutra_vfs::{Project, VfsError, VfsEvent, Watcher};
use crate::buffers::BufferId; use crate::buffers::{BufferId, DiskConflict, DiskStamp};
use crate::history::{self, Reason};
use crate::{EngineError, Event, State}; use crate::{EngineError, Event, State};
/// Directories watched besides the root with native notifications. /// Directories watched besides the root with native notifications.
@ -245,9 +246,15 @@ fn is_ignore_file(path: &Path) -> bool {
/// index ([`crate::cmd::goto::note_disk_changes`]), queues /// index ([`crate::cmd::goto::note_disk_changes`]), queues
/// [`Event::TreeChanged`] for affected directories (also for the directory /// [`Event::TreeChanged`] for affected directories (also for the directory
/// of an edited ignore file, whose entries may change their `ignored` /// of an edited ignore file, whose entries may change their `ignored`
/// flag), reloads clean buffers /// flag), and brings every open buffer whose file was touched in line with
/// whose file changed, and queues [`Event::FileChangedOnDisk`] for dirty /// the disk ([`check_buffer`]).
/// buffers and for buffers whose file disappeared. ///
/// Every event for a path (created, modified, removed, either side of a
/// rename) only says "look again": what counts is whether the file exists
/// now. So a delete followed by a create (a git checkout, an editor that
/// saves by replacing the file) reloads the buffer instead of reporting it
/// removed, and a rename away is a removal of the old path; the buffer is
/// never lost.
pub fn pump(state: &mut State) { pub fn pump(state: &mut State) {
let Some(workspace) = state.project.as_mut() else { let Some(workspace) = state.project.as_mut() else {
return; return;
@ -263,25 +270,29 @@ pub fn pump(state: &mut State) {
dirs.push(dir); dirs.push(dir);
} }
}; };
let mut modified = Vec::new(); let mut touched: Vec<PathBuf> = Vec::new();
let mut gone = Vec::new(); let mut touch = |path: PathBuf| {
if !touched.contains(&path) {
touched.push(path);
}
};
for change in changes { for change in changes {
match change { match change {
VfsEvent::Created { path, .. } => add_dir(&path), VfsEvent::Created { path, .. } | VfsEvent::Removed { path } => {
VfsEvent::Removed { path } => {
add_dir(&path); add_dir(&path);
gone.push(path); touch(path);
} }
VfsEvent::Renamed { from, to } => { VfsEvent::Renamed { from, to } => {
add_dir(&from); add_dir(&from);
add_dir(&to); add_dir(&to);
gone.push(from); touch(from);
touch(to);
} }
VfsEvent::Modified { path } => { VfsEvent::Modified { path } => {
if is_ignore_file(&path) { if is_ignore_file(&path) {
add_dir(&path); add_dir(&path);
} }
modified.push(path); touch(path);
} }
VfsEvent::Failed(_) => {} VfsEvent::Failed(_) => {}
} }
@ -291,19 +302,9 @@ pub fn pump(state: &mut State) {
dir: path_string(&dir), dir: path_string(&dir),
}); });
} }
for path in gone { for path in touched {
if let Some(id) = state.buffers.find(&path) { if let Some(id) = state.buffers.find(&path) {
state.buffers.mark_conflict(id); check_buffer(state, id, &root.join(&path));
state.emit(Event::FileChangedOnDisk {
path: path_string(&path),
id,
removed: true,
});
}
}
for path in modified {
if let Some(id) = state.buffers.find(&path) {
reload(state, id, &root.join(&path));
} }
} }
if let Some(message) = failure { if let Some(message) = failure {
@ -311,41 +312,120 @@ pub fn pump(state: &mut State) {
} }
} }
/// Brings buffer `id` in line with its file after the file changed: a clean /// The stamp of the file at `abs`: its modification time and length.
/// buffer takes the new text (unless it already matches, as after our own /// `None` when it cannot be read.
/// save), a dirty one keeps its text and the client is told, and the buffer pub fn stamp(abs: &Path) -> Option<DiskStamp> {
/// is marked as in conflict ([`crate::buffers::Buffers::mark_conflict`]). let meta = std::fs::metadata(abs).ok()?;
/// A dirty buffer whose file holds exactly what Lutra last wrote is left Some((meta.modified().ok()?, meta.len()))
/// alone: that is our own save reported after the user typed again (an }
/// autosave followed by a keystroke). A file that cannot be read is reported
/// Brings buffer `id` in line with its file at `abs` after something
/// touched it: [`file_gone`] when no file is there any more, else
/// [`reload`].
pub fn check_buffer(state: &mut State, id: BufferId, abs: &Path) {
if abs.is_file() {
reload(state, id, abs);
} else {
file_gone(state, id);
}
}
/// Clears the disk conflict of buffer `id` and, if it had one, queues
/// [`Event::DiskConflictResolved`] so clients drop their banner.
pub fn settle_conflict(state: &mut State, id: BufferId) {
if state.buffers.clear_conflict(id) {
state.emit(Event::DiskConflictResolved { id });
}
}
/// Handles the disappearance of buffer `id`'s file: the buffer keeps its
/// text and becomes dirty (so closing it asks, and the recovery journal
/// keeps it), its text goes into the Local History ([`Reason::Deleted`]),
/// it is marked [`DiskConflict::Removed`] and the client is told with
/// [`Event::FileChangedOnDisk`] `{removed: true}`. Reported once until the
/// file comes back or the buffer is saved.
fn file_gone(state: &mut State, id: BufferId) {
if state.buffers.conflict(id) == Some(DiskConflict::Removed) {
return;
}
history::snapshot_buffer(state, id, Reason::Deleted);
let Some(open) = state.buffers.get_mut(id) else {
return;
};
let was_dirty = open.dirty();
let version = open.version;
if !was_dirty {
open.saved_version = 0;
}
let path = path_string(&open.path);
state.buffers.mark_conflict(id, DiskConflict::Removed);
if !was_dirty {
state.buffers.note_clean_removal(id, version);
}
if !was_dirty {
state.emit(Event::DirtyChanged { id, dirty: true });
crate::journal::mark_edited(state, id, std::time::Instant::now());
}
state.emit(Event::FileChangedOnDisk {
path,
id,
removed: true,
});
}
/// Brings buffer `id` in line with its file after the file changed:
/// - A file that holds exactly the buffer's text (and byte order mark)
/// makes the buffer clean and settles its conflict: our own save
/// reported late, a touch, or a file that came back.
/// - A clean buffer takes the new text ([`take_disk_text`]); the old text
/// and the new one go into the Local History first. So does a buffer that
/// is dirty only because its file was gone for a while
/// ([`crate::buffers::Buffers::dirty_only_by_removal`]).
/// - A dirty buffer keeps its text; the new file text goes into the Local
/// History ([`Reason::ExternalChange`]), the buffer is marked
/// [`DiskConflict::Changed`] and the client is told once. A dirty buffer
/// whose file holds exactly what Lutra last wrote is left alone: that is
/// our own save reported after the user typed again (an autosave followed
/// by a keystroke).
///
/// A file that cannot be read (gone meanwhile, no longer text) is reported
/// like a removed one. /// like a removed one.
fn reload(state: &mut State, id: BufferId, abs: &Path) { fn reload(state: &mut State, id: BufferId, abs: &Path) {
let Some(open) = state.buffers.get(id) else { let Some(open) = state.buffers.get(id) else {
return; return;
}; };
let path = path_string(&open.path); let path = path_string(&open.path);
let dirty = open.dirty(); let rel = open.path.clone();
let file = match lutra_vfs::read_text(abs) { let Ok(file) = lutra_vfs::read_text(abs) else {
Ok(file) => file, file_gone(state, id);
Err(_) => {
state.buffers.mark_conflict(id);
state.emit(Event::FileChangedOnDisk {
path,
id,
removed: true,
});
return; return;
}
}; };
if dirty { let Some(open) = state.buffers.get(id) else {
if state.buffers.is_own_write( return;
id, };
&crate::journal::hex_hash(file.text.as_bytes()), let hash = crate::journal::hex_hash(file.text.as_bytes());
file.bom, if file.text == open.buffer.save_text() && file.bom == open.bom {
) { let was_dirty = open.dirty();
if let Some(open) = state.buffers.get_mut(id) {
open.saved_version = open.version;
}
state.buffers.note_written(id, hash, file.bom, stamp(abs));
settle_conflict(state, id);
if was_dirty {
crate::journal::forget(state, id);
state.emit(Event::DirtyChanged { id, dirty: false });
}
return; return;
} }
state.buffers.mark_conflict(id); if open.dirty() && !state.buffers.dirty_only_by_removal(id) {
if state.buffers.is_own_write(id, &hash, file.bom) {
return;
}
history::snapshot_external(state, &rel, &file.text, file.bom);
if state.buffers.conflict(id) == Some(DiskConflict::Changed) {
return;
}
state.buffers.mark_conflict(id, DiskConflict::Changed);
state.emit(Event::FileChangedOnDisk { state.emit(Event::FileChangedOnDisk {
path, path,
id, id,
@ -353,25 +433,50 @@ fn reload(state: &mut State, id: BufferId, abs: &Path) {
}); });
return; return;
} }
take_disk_text(state, id, file, stamp(abs));
}
/// Replaces buffer `id`'s text with `file` as read from disk and makes it
/// clean: the old text goes into the Local History
/// ([`Reason::BeforeReload`]) and so does the new one
/// ([`Reason::ExternalChange`]); the conflict is settled, the recovery
/// entry dropped and [`Event::BufferChanged`] (plus
/// [`Event::DirtyChanged`] for a dirty buffer) queued. Clients move the
/// editor onto the new text with a minimal change, so the caret and the
/// scroll position stay where the text around them did not change.
///
/// # Parameters
/// - `stamp`: the file's [`stamp`] when it was read.
pub fn take_disk_text(
state: &mut State,
id: BufferId,
file: lutra_vfs::TextFile,
stamp: Option<DiskStamp>,
) {
let Some(open) = state.buffers.get(id) else { let Some(open) = state.buffers.get(id) else {
return; return;
}; };
if file.text == open.buffer.save_text() && file.bom == open.bom { let rel = open.path.clone();
state.buffers.clear_conflict(id); history::snapshot_buffer(state, id, Reason::BeforeReload);
return; history::snapshot_external(state, &rel, &file.text, file.bom);
}
let Some(open) = state.buffers.get_mut(id) else { let Some(open) = state.buffers.get_mut(id) else {
return; return;
}; };
let hash = crate::journal::hex_hash(file.text.as_bytes()); let hash = crate::journal::hex_hash(file.text.as_bytes());
let was_dirty = open.dirty();
open.buffer = Buffer::new(&file.text); open.buffer = Buffer::new(&file.text);
open.bom = file.bom; open.bom = file.bom;
open.version = open.version.saturating_add(1); open.version = open.version.saturating_add(1);
open.saved_version = open.version; open.saved_version = open.version;
let version = open.version; let version = open.version;
state.buffers.clear_conflict(id); state.buffers.note_written(id, hash, file.bom, stamp);
state.buffers.note_written(id, hash, file.bom); state.buffers.mark_in_history(id);
settle_conflict(state, id);
crate::journal::forget(state, id);
state.emit(Event::BufferChanged { id, version }); state.emit(Event::BufferChanged { id, version });
if was_dirty {
state.emit(Event::DirtyChanged { id, dirty: false });
}
} }
/// A project-relative path as sent to clients: `/` separators, `""` for the /// A project-relative path as sent to clients: `/` separators, `""` for the

View file

@ -0,0 +1,260 @@
//! Local History (C10 A2) through the engine: snapshots on save, reload,
//! deletion and revert, stored in the data directory, never in the project.
#![allow(
clippy::unwrap_used,
clippy::expect_used,
clippy::panic,
clippy::indexing_slicing
)]
use std::fs;
use std::time::{Duration, Instant};
use lutra_engine::{Engine, EngineConfig, Event, Outcome};
use serde_json::{Value, json};
use tempfile::TempDir;
/// A project folder, a data directory and an engine with that project open.
struct Fixture {
project: TempDir,
data: TempDir,
_config: TempDir,
engine: Engine,
}
fn fixture(files: &[(&str, &str)]) -> Fixture {
let project = tempfile::tempdir().unwrap();
for (path, text) in files {
fs::write(project.path().join(path), text).unwrap();
}
let data = tempfile::tempdir().unwrap();
let config = tempfile::tempdir().unwrap();
let mut engine = Engine::with_config(EngineConfig {
config_dir: config.path().to_path_buf(),
data_dir: data.path().to_path_buf(),
})
.unwrap();
engine
.execute("project.open", json!({"path": project.path()}))
.unwrap();
Fixture {
project,
data,
_config: config,
engine,
}
}
fn run(engine: &mut Engine, command: &str, params: Value) -> Outcome {
engine
.execute(command, params)
.unwrap_or_else(|e| panic!("{command} failed: {e}"))
}
fn open(engine: &mut Engine, path: &str) -> u64 {
run(engine, "file.open", json!({"path": path})).value["id"]
.as_u64()
.unwrap()
}
fn replace(engine: &mut Engine, id: u64, text: &str) {
let now = run(engine, "buffer.get", json!({"id": id})).value;
let len = now["text"].as_str().unwrap().encode_utf16().count();
run(
engine,
"buffer.edit",
json!({"id": id, "baseVersion": now["version"], "edits": [{"from": 0, "to": len, "insert": text}]}),
);
}
/// `(reason, text)` of every entry of `path`, newest first.
fn entries(engine: &mut Engine, path: &str) -> Vec<(String, String)> {
let list = run(engine, "history.list", json!({"path": path})).value;
list["entries"]
.as_array()
.unwrap()
.iter()
.map(|e| {
let text =
run(engine, "history.read", json!({"path": path, "id": e["id"]})).value["text"]
.as_str()
.unwrap()
.to_string();
(e["reason"].as_str().unwrap().to_string(), text)
})
.collect()
}
fn pair(reason: &str, text: &str) -> (String, String) {
(reason.to_string(), text.to_string())
}
fn wait_for(engine: &mut Engine, pred: impl Fn(&Event) -> bool) {
let deadline = Instant::now() + Duration::from_secs(5);
while Instant::now() < deadline {
if engine.pump_vfs().unwrap().iter().any(&pred) {
return;
}
std::thread::sleep(Duration::from_millis(25));
}
panic!("event not seen within 5 s");
}
#[test]
fn saves_keep_the_original_and_every_saved_text() {
let mut f = fixture(&[("a.php", "original")]);
let id = open(&mut f.engine, "a.php");
replace(&mut f.engine, id, "first");
run(&mut f.engine, "file.save", json!({"id": id}));
run(&mut f.engine, "file.save", json!({"id": id}));
replace(&mut f.engine, id, "second");
run(&mut f.engine, "file.saveAll", json!({}));
assert_eq!(
entries(&mut f.engine, "a.php"),
vec![
pair("save", "second"),
pair("save", "first"),
pair("beforeSave", "original"),
],
"a save of an unchanged text adds nothing"
);
let list = run(&mut f.engine, "history.list", json!({"path": "a.php"})).value;
let entry = &list["entries"][0];
assert!(entry["time"].as_u64().unwrap() > 0);
assert_eq!(entry["size"], 6);
}
#[test]
fn the_history_lives_in_the_data_dir_and_survives_a_reopen() {
let mut f = fixture(&[("a.php", "one")]);
let id = open(&mut f.engine, "a.php");
replace(&mut f.engine, id, "two");
run(&mut f.engine, "file.save", json!({"id": id}));
let names: Vec<String> = fs::read_dir(f.project.path())
.unwrap()
.map(|e| e.unwrap().file_name().to_string_lossy().into_owned())
.collect();
assert_eq!(
names,
vec!["a.php".to_string()],
"nothing inside the project"
);
assert!(f.data.path().join("history").is_dir());
run(
&mut f.engine,
"project.open",
json!({"path": f.project.path()}),
);
assert_eq!(entries(&mut f.engine, "a.php").len(), 2);
}
#[test]
fn reloads_and_deletions_keep_the_buffers_text() {
let mut f = fixture(&[("a.php", "mine")]);
let id = open(&mut f.engine, "a.php");
replace(&mut f.engine, id, "unsaved");
fs::write(f.project.path().join("a.php"), "theirs").unwrap();
wait_for(&mut f.engine, |e| {
matches!(e, Event::FileChangedOnDisk { removed: false, .. })
});
run(&mut f.engine, "file.reload", json!({"id": id}));
assert_eq!(
entries(&mut f.engine, "a.php"),
vec![
pair("beforeReload", "unsaved"),
pair("externalChange", "theirs")
]
);
fs::remove_file(f.project.path().join("a.php")).unwrap();
wait_for(&mut f.engine, |e| {
matches!(e, Event::FileChangedOnDisk { removed: true, .. })
});
assert_eq!(
entries(&mut f.engine, "a.php")[0],
pair("deleted", "theirs")
);
}
#[test]
fn revert_edits_the_buffer_and_keeps_what_it_replaced() {
let mut f = fixture(&[("a.php", "one")]);
let id = open(&mut f.engine, "a.php");
replace(&mut f.engine, id, "two");
run(&mut f.engine, "file.save", json!({"id": id}));
replace(&mut f.engine, id, "three, unsaved");
let list = run(&mut f.engine, "history.list", json!({"path": "a.php"})).value;
let original = list["entries"][1]["id"].clone();
let out = run(
&mut f.engine,
"history.revert",
json!({"path": "a.php", "id": original}),
);
assert_eq!(out.value["id"], id);
assert_eq!(out.value["dirty"], true, "an ordinary, unsaved edit");
assert!(
out.events
.iter()
.any(|e| matches!(e, Event::BufferChanged { id: got, .. } if *got == id))
);
let now = run(&mut f.engine, "buffer.get", json!({"id": id})).value;
assert_eq!(now["text"], "one");
assert_eq!(
fs::read_to_string(f.project.path().join("a.php")).unwrap(),
"two"
);
assert_eq!(
entries(&mut f.engine, "a.php")[0],
pair("beforeRevert", "three, unsaved")
);
}
#[test]
fn revert_opens_a_closed_file() {
let mut f = fixture(&[("a.php", "one")]);
let id = open(&mut f.engine, "a.php");
replace(&mut f.engine, id, "two");
run(&mut f.engine, "file.save", json!({"id": id}));
run(&mut f.engine, "buffer.close", json!({"id": id}));
let list = run(&mut f.engine, "history.list", json!({"path": "a.php"})).value;
let out = run(
&mut f.engine,
"history.revert",
json!({"path": "a.php", "id": list["entries"][1]["id"]}),
);
let new_id = out.value["id"].as_u64().unwrap();
assert!(
out.events
.iter()
.any(|e| matches!(e, Event::BufferOpened { id, .. } if *id == new_id))
);
let now = run(&mut f.engine, "buffer.get", json!({"id": new_id})).value;
assert_eq!(now["text"], "one");
}
#[test]
fn unknown_entries_and_projects_without_history_fail_clearly() {
let mut f = fixture(&[("a.php", "one")]);
let err = f
.engine
.execute("history.read", json!({"path": "a.php", "id": 99}))
.unwrap_err();
assert_eq!(err.code(), "failed");
assert!(
err.to_string().contains("no Local History entry 99"),
"{err}"
);
assert_eq!(
run(&mut f.engine, "history.list", json!({"path": "a.php"})).value["entries"],
json!([])
);
let dir = tempfile::tempdir().unwrap();
let mut bare = Engine::new().unwrap();
bare.execute("project.open", json!({"path": dir.path()}))
.unwrap();
let err = bare
.execute("history.list", json!({"path": "a.php"}))
.unwrap_err();
assert!(err.to_string().contains("not available"), "{err}");
}

View file

@ -267,7 +267,7 @@ fn save_all_saves_every_dirty_buffer() {
let out = run(&mut engine, "file.saveAll", Value::Null); let out = run(&mut engine, "file.saveAll", Value::Null);
assert_eq!( assert_eq!(
out.value, out.value,
json!({"saved": [a, b], "failed": [], "skipped": []}) json!({"saved": [a, b], "failed": [], "skipped": [], "diskChanged": []})
); );
assert_eq!(fs::read_to_string(dir.path().join("b.php")).unwrap(), ">b"); assert_eq!(fs::read_to_string(dir.path().join("b.php")).unwrap(), ">b");
} }
@ -603,7 +603,7 @@ fn save_all_can_skip_buffers_in_conflict_with_the_disk() {
let out = run(&mut engine, "file.saveAll", json!({"skipConflicts": true})); let out = run(&mut engine, "file.saveAll", json!({"skipConflicts": true}));
assert_eq!( assert_eq!(
out.value, out.value,
json!({"saved": [mine], "failed": [], "skipped": [other]}) json!({"saved": [mine], "failed": [], "skipped": [other], "diskChanged": []})
); );
assert_eq!( assert_eq!(
fs::read_to_string(dir.path().join("other.php")).unwrap(), fs::read_to_string(dir.path().join("other.php")).unwrap(),
@ -614,7 +614,19 @@ fn save_all_can_skip_buffers_in_conflict_with_the_disk() {
"xone" "xone"
); );
run(&mut engine, "file.save", json!({"id": other})); let err = engine
.execute("file.save", json!({"id": other}))
.unwrap_err();
assert_eq!(
err.code(),
"disk_changed",
"a newer file is never overwritten silently"
);
run(
&mut engine,
"file.save",
json!({"id": other, "overwrite": true}),
);
assert_eq!( assert_eq!(
fs::read_to_string(dir.path().join("other.php")).unwrap(), fs::read_to_string(dir.path().join("other.php")).unwrap(),
"xone" "xone"
@ -682,3 +694,198 @@ fn typing_right_after_a_save_is_not_a_conflict() {
let out = run(&mut engine, "file.saveAll", json!({"skipConflicts": true})); let out = run(&mut engine, "file.saveAll", json!({"skipConflicts": true}));
assert_eq!(out.value["saved"], json!([id])); assert_eq!(out.value["saved"], json!([id]));
} }
fn edit(engine: &mut Engine, id: u64, base: u64, at: u64, insert: &str) {
run(
engine,
"buffer.edit",
json!({"id": id, "baseVersion": base, "edits": [{"from": at, "to": at, "insert": insert}]}),
);
}
#[test]
fn reload_discards_mine_and_settles_the_conflict() {
let (dir, mut engine, _) = open_project(&[("a.php", b"one")]);
let (id, _) = open_file(&mut engine, "a.php");
edit(&mut engine, id, 1, 0, "mine ");
fs::write(dir.path().join("a.php"), "theirs").unwrap();
wait_for(
&mut engine,
|e| matches!(e, Event::FileChangedOnDisk { id: got, removed: false, .. } if *got == id),
);
assert_eq!(
run(&mut engine, "buffer.get", json!({"id": id})).value["diskConflict"],
"changed"
);
let out = run(&mut engine, "file.reload", json!({"id": id}));
assert_eq!(out.value["dirty"], false);
assert!(
out.events
.iter()
.any(|e| matches!(e, Event::DiskConflictResolved { id: got } if *got == id))
);
assert!(
out.events
.iter()
.any(|e| matches!(e, Event::DirtyChanged { id: got, dirty: false } if *got == id))
);
let now = run(&mut engine, "buffer.get", json!({"id": id})).value;
assert_eq!(now["text"], "theirs");
assert_eq!(now["diskConflict"], Value::Null);
}
#[test]
fn a_save_over_a_newer_file_asks_even_before_the_watcher_saw_it() {
let (dir, mut engine, _) = open_project(&[("a.php", b"one"), ("b.php", b"one")]);
let (a, _) = open_file(&mut engine, "a.php");
let (b, _) = open_file(&mut engine, "b.php");
edit(&mut engine, a, 1, 0, "x");
edit(&mut engine, b, 1, 0, "x");
std::thread::sleep(Duration::from_millis(30));
fs::write(dir.path().join("a.php"), "theirs, longer").unwrap();
let err = engine.execute("file.save", json!({"id": a})).unwrap_err();
assert_eq!(err.code(), "disk_changed");
assert_eq!(
fs::read_to_string(dir.path().join("a.php")).unwrap(),
"theirs, longer"
);
let out = run(&mut engine, "file.saveAll", json!({}));
assert_eq!(out.value["saved"], json!([b]));
assert_eq!(out.value["diskChanged"], json!([a]));
run(
&mut engine,
"file.save",
json!({"id": a, "overwrite": true}),
);
assert_eq!(
fs::read_to_string(dir.path().join("a.php")).unwrap(),
"xone"
);
}
#[test]
fn a_touched_file_with_the_same_text_saves_without_asking() {
let (dir, mut engine, _) = open_project(&[("a.php", b"one")]);
let (id, _) = open_file(&mut engine, "a.php");
edit(&mut engine, id, 1, 0, "x");
std::thread::sleep(Duration::from_millis(30));
fs::write(dir.path().join("a.php"), "one").unwrap();
run(&mut engine, "file.save", json!({"id": id}));
assert_eq!(
fs::read_to_string(dir.path().join("a.php")).unwrap(),
"xone"
);
}
#[test]
fn a_deleted_file_keeps_its_buffer_as_unsaved_until_it_comes_back() {
let (dir, mut engine, _) = open_project(&[("a.php", b"one")]);
let (id, _) = open_file(&mut engine, "a.php");
fs::remove_file(dir.path().join("a.php")).unwrap();
let events = wait_for(
&mut engine,
|e| matches!(e, Event::FileChangedOnDisk { id: got, removed: true, .. } if *got == id),
);
assert!(
events
.iter()
.any(|e| matches!(e, Event::DirtyChanged { id: got, dirty: true } if *got == id))
);
let now = run(&mut engine, "buffer.get", json!({"id": id})).value;
assert_eq!(now["text"], "one");
assert_eq!(now["dirty"], true);
assert_eq!(now["diskConflict"], "removed");
assert_eq!(
engine
.execute("buffer.close", json!({"id": id}))
.unwrap_err()
.code(),
"unsaved_changes",
"closing asks"
);
fs::write(dir.path().join("a.php"), "back, but different").unwrap();
wait_for(
&mut engine,
|e| matches!(e, Event::DiskConflictResolved { id: got } if *got == id),
);
let now = run(&mut engine, "buffer.get", json!({"id": id})).value;
assert_eq!(
now["text"], "back, but different",
"a buffer dirty only because its file was gone reloads like a clean one"
);
assert_eq!(now["dirty"], false);
}
#[test]
fn keep_as_unsaved_then_save_recreates_the_file() {
let (dir, mut engine, _) = open_project(&[("a.php", b"one")]);
let (id, _) = open_file(&mut engine, "a.php");
edit(&mut engine, id, 1, 0, "x");
fs::remove_file(dir.path().join("a.php")).unwrap();
wait_for(
&mut engine,
|e| matches!(e, Event::FileChangedOnDisk { id: got, removed: true, .. } if *got == id),
);
let out = run(&mut engine, "file.save", json!({"id": id}));
assert!(
out.events
.iter()
.any(|e| matches!(e, Event::DiskConflictResolved { id: got } if *got == id))
);
assert_eq!(
fs::read_to_string(dir.path().join("a.php")).unwrap(),
"xone"
);
}
#[test]
fn a_file_replaced_by_delete_and_create_reloads_instead_of_being_lost() {
let (dir, mut engine, _) = open_project(&[("a.php", b"one"), ("b.php", b"one")]);
let (clean, _) = open_file(&mut engine, "a.php");
let (dirty, _) = open_file(&mut engine, "b.php");
edit(&mut engine, dirty, 1, 0, "mine ");
for name in ["a.php", "b.php"] {
fs::remove_file(dir.path().join(name)).unwrap();
fs::write(dir.path().join(name), "checked out").unwrap();
}
let mut seen = wait_for(
&mut engine,
|e| matches!(e, Event::BufferChanged { id, .. } if *id == clean),
);
if !seen
.iter()
.any(|e| matches!(e, Event::FileChangedOnDisk { id, removed: false, .. } if *id == dirty))
{
seen.extend(wait_for(
&mut engine,
|e| matches!(e, Event::FileChangedOnDisk { id, removed: false, .. } if *id == dirty),
));
}
let a = run(&mut engine, "buffer.get", json!({"id": clean})).value;
assert_eq!(a["text"], "checked out");
assert_eq!(a["dirty"], false);
let b = run(&mut engine, "buffer.get", json!({"id": dirty})).value;
assert_eq!(
b["text"], "mine one",
"the dirty buffer keeps the user's text"
);
assert_eq!(b["diskConflict"], "changed");
}
#[test]
fn read_disk_answers_like_git_show() {
let (_dir, mut engine, _) =
open_project(&[("a.php", b"on disk"), ("bin.dat", b"\xff\xfe\x00x")]);
let (id, _) = open_file(&mut engine, "a.php");
edit(&mut engine, id, 1, 0, "mine ");
let out = run(&mut engine, "file.readDisk", json!({"path": "a.php"}));
assert_eq!(
out.value,
json!({"text": "on disk", "binary": false, "tooLarge": false})
);
let out = run(&mut engine, "file.readDisk", json!({"path": "gone.php"}));
assert_eq!(out.value["text"], Value::Null);
let out = run(&mut engine, "file.readDisk", json!({"path": "bin.dat"}));
assert_eq!(out.value["binary"], true);
}