510 lines
19 KiB
Rust
510 lines
19 KiB
Rust
//! Config-registry acceptance (docs/config-registry-framing.md).
|
|
//!
|
|
//! The registry's own semantics are unit-tested in
|
|
//! `src/config_registry.rs` (value/scope/epoch/listener behavior) and
|
|
//! `src/lua_bindings/config.rs` (the Lua boundary). This suite covers
|
|
//! only what those cannot reach: the three adopters wired into a real
|
|
//! `EditorState`, the owner-defines source-location contract observed
|
|
//! after actual chunk load, and `M-x describe-setting` rendering
|
|
//! through the real minibuffer.
|
|
//!
|
|
//! Framing acceptance items covered here: 9, 19, 26, 27, 28, 29, 30, 33.
|
|
//!
|
|
//! Pairing is exercised by DISPATCHING keys, never
|
|
//! `pmacs.command.invoke` — pair.lua reacts to `buffer.after-edit`
|
|
//! with a typed-edit record that only real dispatch produces, so an
|
|
//! invoke-driven test would pass vacuously against a broken gate.
|
|
|
|
use std::path::PathBuf;
|
|
use std::sync::atomic::{AtomicUsize, Ordering};
|
|
|
|
use crossterm::event::{KeyCode, KeyEvent, KeyEventKind, KeyEventState, KeyModifiers};
|
|
use pmacs::editor::EditorState;
|
|
use pmacs::lua_bindings::StateDir;
|
|
use pmacs::protocol::FrontendId;
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Harness (mirrors tests/auto_pair_acceptance.rs)
|
|
// ---------------------------------------------------------------------------
|
|
|
|
fn exec(s: &EditorState, src: &str) {
|
|
s.lua_host.lua().load(src.to_string()).exec().unwrap();
|
|
}
|
|
|
|
fn eval<T: mlua::FromLuaMulti>(s: &EditorState, src: &str) -> T {
|
|
s.lua_host.lua().load(src.to_string()).eval().unwrap()
|
|
}
|
|
|
|
fn fresh_state_dir() -> PathBuf {
|
|
static SEQ: AtomicUsize = AtomicUsize::new(0);
|
|
let dir = std::env::temp_dir().join(format!(
|
|
"pmacs-configreg-{}-{}",
|
|
std::process::id(),
|
|
SEQ.fetch_add(1, Ordering::Relaxed)
|
|
));
|
|
std::fs::create_dir_all(&dir).unwrap();
|
|
dir
|
|
}
|
|
|
|
fn editor(state_dir: &std::path::Path) -> EditorState {
|
|
let s = EditorState::new();
|
|
s.lua_host.lua().remove_app_data::<StateDir>();
|
|
s.lua_host
|
|
.lua()
|
|
.set_app_data(StateDir(state_dir.to_path_buf()));
|
|
// Language DETECTION must work; server SPAWNING must not (rust and
|
|
// python carry default configs and the after-load hook would spawn
|
|
// real servers).
|
|
exec(&s, "pmacs.lsp.config = {}");
|
|
s
|
|
}
|
|
|
|
fn write_file(dir: &std::path::Path, name: &str, body: &str) -> String {
|
|
let p = dir.join(name);
|
|
std::fs::write(&p, body).unwrap();
|
|
p.display().to_string()
|
|
}
|
|
|
|
fn key(code: KeyCode, mods: KeyModifiers) -> KeyEvent {
|
|
KeyEvent {
|
|
code,
|
|
modifiers: mods,
|
|
kind: KeyEventKind::Press,
|
|
state: KeyEventState::NONE,
|
|
}
|
|
}
|
|
|
|
fn type_str(s: &mut EditorState, text: &str) {
|
|
for ch in text.chars() {
|
|
s.dispatch_key(
|
|
FrontendId::LOCAL,
|
|
key(KeyCode::Char(ch), KeyModifiers::NONE),
|
|
);
|
|
}
|
|
}
|
|
|
|
fn press(s: &mut EditorState, code: KeyCode) {
|
|
s.dispatch_key(FrontendId::LOCAL, key(code, KeyModifiers::NONE));
|
|
}
|
|
|
|
fn active_text(s: &EditorState) -> String {
|
|
let b: mlua::String = eval(
|
|
s,
|
|
"local b = pmacs.window.buffer(); return b:slice(0, b:len())",
|
|
);
|
|
String::from_utf8_lossy(&b.as_bytes()).into_owned()
|
|
}
|
|
|
|
/// `show_help_text` ends by switching the window to `*help*`, so after
|
|
/// a describe command the active buffer IS the help buffer. Asserting
|
|
/// through the active buffer also proves the switch happened, which a
|
|
/// direct by-name lookup would silently tolerate skipping.
|
|
fn help_text(s: &EditorState) -> String {
|
|
let name: String = eval(s, "return pmacs.window.buffer():name()");
|
|
assert_eq!(name, "*help*", "the describe command must display *help*");
|
|
active_text(s)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Item 26 / 9 — owner-defines, observed after real chunk load
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn builtin_defines_succeed_at_chunk_load_and_report_their_owning_module() {
|
|
let s = editor(&fresh_state_dir());
|
|
|
|
// Item 26: the define calls at the top of pair.lua / editops.lua /
|
|
// autosave.lua ran during EditorState::new, which is only possible
|
|
// if pmacs.config was populated before the first runtime chunk.
|
|
for name in [
|
|
"editing.auto-pair",
|
|
"editing.trim-on-save",
|
|
"autosave.interval-ms",
|
|
] {
|
|
let known: bool = eval(
|
|
&s,
|
|
&format!("return pmacs.config.describe({name:?}) ~= nil"),
|
|
);
|
|
assert!(known, "{name} must be defined by its owning module");
|
|
}
|
|
|
|
// Item 9: each definition's SourceLocation points at the module
|
|
// that owns the setting, not at a shared helper. This is exactly
|
|
// what a centralized define table in a config.lua would have
|
|
// broken (framing Q#CR14).
|
|
let pair_src: String = eval(
|
|
&s,
|
|
"return pmacs.config.describe('editing.auto-pair').source",
|
|
);
|
|
assert!(
|
|
pair_src.contains("pair.lua"),
|
|
"editing.auto-pair must report pair.lua as its source, got {pair_src:?}"
|
|
);
|
|
let trim_src: String = eval(
|
|
&s,
|
|
"return pmacs.config.describe('editing.trim-on-save').source",
|
|
);
|
|
assert!(
|
|
trim_src.contains("editops.lua"),
|
|
"editing.trim-on-save must report editops.lua, got {trim_src:?}"
|
|
);
|
|
let auto_src: String = eval(
|
|
&s,
|
|
"return pmacs.config.describe('autosave.interval-ms').source",
|
|
);
|
|
assert!(
|
|
auto_src.contains("autosave.lua"),
|
|
"autosave.interval-ms must report autosave.lua, got {auto_src:?}"
|
|
);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Item 29 — the flagship: per-buffer auto-pair, the feature this arc exists for
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn auto_pair_off_buffer_locally_suppresses_only_that_buffer() {
|
|
let dir = fresh_state_dir();
|
|
let mut s = editor(&dir);
|
|
let a = write_file(&dir, "a.rs", "");
|
|
let b = write_file(&dir, "b.rs", "");
|
|
|
|
// Two buffers of the SAME language — so a language-keyed
|
|
// implementation could not pass this test. The handle is stashed in
|
|
// a Lua global because buffer handles are userdata, not ids.
|
|
exec(&s, &format!("BUF_A = pmacs.buffer.find_or_open({a:?})"));
|
|
exec(&s, &format!("pmacs.buffer.find_or_open({b:?})"));
|
|
|
|
// Turn pairing off in buffer A only.
|
|
exec(
|
|
&s,
|
|
"pmacs.config.set_local(BUF_A, 'editing.auto-pair', false)",
|
|
);
|
|
|
|
// B (untouched) still pairs.
|
|
exec(&s, "pmacs.editor.goto_byte(0)");
|
|
type_str(&mut s, "(");
|
|
assert_eq!(
|
|
active_text(&s),
|
|
"()",
|
|
"a buffer with no local override still pairs"
|
|
);
|
|
|
|
// A (overridden) does not.
|
|
exec(&s, &format!("pmacs.buffer.find_or_open({a:?})"));
|
|
exec(&s, "pmacs.editor.goto_byte(0)");
|
|
type_str(&mut s, "(");
|
|
assert_eq!(
|
|
active_text(&s),
|
|
"(",
|
|
"the buffer-local override must suppress pairing in THIS buffer"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn auto_pair_off_globally_suppresses_everywhere() {
|
|
let dir = fresh_state_dir();
|
|
let mut s = editor(&dir);
|
|
let a = write_file(&dir, "a.rs", "");
|
|
exec(&s, &format!("pmacs.buffer.find_or_open({a:?})"));
|
|
exec(&s, "pmacs.config.set('editing.auto-pair', false)");
|
|
exec(&s, "pmacs.editor.goto_byte(0)");
|
|
type_str(&mut s, "(");
|
|
assert_eq!(active_text(&s), "(", "a global false suppresses pairing");
|
|
}
|
|
|
|
#[test]
|
|
fn auto_pair_defaults_on_so_the_migration_changed_no_default() {
|
|
let dir = fresh_state_dir();
|
|
let mut s = editor(&dir);
|
|
let a = write_file(&dir, "a.rs", "");
|
|
exec(&s, &format!("pmacs.buffer.find_or_open({a:?})"));
|
|
exec(&s, "pmacs.editor.goto_byte(0)");
|
|
type_str(&mut s, "(");
|
|
assert_eq!(active_text(&s), "()", "pairing is on by default");
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Item 13 — the purge runs on the REAL buffer-death path
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn killing_a_buffer_through_the_real_path_purges_its_locals() {
|
|
// Review round 1, finding 4. Every other test of the purge calls
|
|
// `ConfigRegistry::remove_buffer` directly, so deleting the three
|
|
// lines wired into `after_buffer_removed` would leave them all
|
|
// green. This drives `pmacs.buffer.remove`, which is the production
|
|
// route (`remove_buffer_and_fire` -> `after_buffer_removed`), and
|
|
// fails if that wiring is absent.
|
|
//
|
|
// The assertion reads through the DEAD handle on purpose: BufferIds
|
|
// are never reused (buffer_registry.rs), so a stale id cannot alias
|
|
// a later buffer, and `is_set` against it reports exactly whether
|
|
// the registry still holds that buffer's map.
|
|
let dir = fresh_state_dir();
|
|
let s = editor(&dir);
|
|
let a = write_file(&dir, "a.rs", "");
|
|
exec(&s, &format!("DEAD = pmacs.buffer.find_or_open({a:?})"));
|
|
exec(
|
|
&s,
|
|
"pmacs.config.set_local(DEAD, 'editing.auto-pair', false)",
|
|
);
|
|
assert!(
|
|
eval::<bool>(&s, "return pmacs.config.is_set('editing.auto-pair', DEAD)"),
|
|
"precondition: the buffer-local override is stored"
|
|
);
|
|
|
|
// Switch away first so killing the buffer cannot leave the window
|
|
// pointing at a dead buffer, then remove it through the real path.
|
|
exec(&s, "pmacs.buffer.remove(DEAD)");
|
|
|
|
assert!(
|
|
!eval::<bool>(&s, "return pmacs.config.is_set('editing.auto-pair', DEAD)"),
|
|
"the buffer's locals must be purged when it is removed"
|
|
);
|
|
assert!(
|
|
eval::<bool>(&s, "return pmacs.config.get('editing.auto-pair', DEAD)"),
|
|
"and resolution falls back to the global default"
|
|
);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Items 27 / 28 — the migration wrappers keep their legacy coercion (F4)
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn trim_on_save_wrapper_and_registry_are_interchangeable_both_ways() {
|
|
let s = editor(&fresh_state_dir());
|
|
|
|
// Wrapper write observed by the registry.
|
|
exec(&s, "pmacs.editops.trim_on_save(true)");
|
|
let via_registry: bool = eval(&s, "return pmacs.config.get('editing.trim-on-save')");
|
|
assert!(via_registry, "the wrapper's write must reach the registry");
|
|
|
|
// Registry write observed by the wrapper.
|
|
exec(&s, "pmacs.config.set('editing.trim-on-save', false)");
|
|
let via_wrapper: bool = eval(&s, "return pmacs.editops.trim_on_save()");
|
|
assert!(
|
|
!via_wrapper,
|
|
"the registry's write must be visible through the wrapper"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn trim_on_save_honors_a_buffer_local_override() {
|
|
// Review round 1, finding 2. The save hook resolves against the
|
|
// buffer being saved, so `set_local` is a real per-buffer switch
|
|
// rather than a stored value nothing ever reads.
|
|
let dir = fresh_state_dir();
|
|
let s = editor(&dir);
|
|
let a = write_file(&dir, "a.rs", "");
|
|
exec(&s, &format!("BUF = pmacs.buffer.find_or_open({a:?})"));
|
|
// The content must be INSERTED, not merely present on disk:
|
|
// `save()` no-ops on an unmodified buffer, so a freshly-opened
|
|
// buffer would leave the file byte-identical and this test would
|
|
// pass without the save hook ever running.
|
|
exec(&s, r#"BUF:insert(0, "keep me \n")"#);
|
|
|
|
// Globally on, but off for this buffer: trailing space survives.
|
|
exec(&s, "pmacs.config.set('editing.trim-on-save', true)");
|
|
exec(
|
|
&s,
|
|
"pmacs.config.set_local(BUF, 'editing.trim-on-save', false)",
|
|
);
|
|
exec(&s, "pmacs.command.invoke('buffer.save')");
|
|
assert_eq!(
|
|
std::fs::read_to_string(&a).unwrap(),
|
|
"keep me \n",
|
|
"a buffer-local false must suppress trimming for this buffer"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn trim_on_save_still_falls_back_to_the_global_value() {
|
|
// The other half of finding 2's fix, and its regression guard:
|
|
// now that the hook passes a buffer, a broken fallback would make
|
|
// the global setting silently stop working. A separate editor and
|
|
// file because `save()` no-ops on an unmodified buffer, so the two
|
|
// cases cannot share one save cycle.
|
|
let dir = fresh_state_dir();
|
|
let s = editor(&dir);
|
|
let a = write_file(&dir, "a.rs", "");
|
|
exec(&s, &format!("BUF = pmacs.buffer.find_or_open({a:?})"));
|
|
exec(&s, r#"BUF:insert(0, "trim me \n")"#);
|
|
exec(&s, "pmacs.config.set('editing.trim-on-save', true)");
|
|
exec(&s, "pmacs.command.invoke('buffer.save')");
|
|
assert_eq!(
|
|
std::fs::read_to_string(&a).unwrap(),
|
|
"trim me\n",
|
|
"with no buffer-local override the global setting must still apply"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn trim_on_save_keeps_its_lenient_truthiness() {
|
|
// F4: the registry is strict (a real boolean or nothing), but this
|
|
// legacy setter has always accepted anything that is not literally
|
|
// `false`. A thin wrapper over a strict `set` would raise here.
|
|
let s = editor(&fresh_state_dir());
|
|
exec(&s, "pmacs.editops.trim_on_save('yes')");
|
|
let on: bool = eval(&s, "return pmacs.config.get('editing.trim-on-save')");
|
|
assert!(on, "a non-false argument must still turn trimming on");
|
|
|
|
exec(&s, "pmacs.editops.trim_on_save(false)");
|
|
let off: bool = eval(&s, "return pmacs.config.get('editing.trim-on-save')");
|
|
assert!(!off, "a literal false must still turn it off");
|
|
}
|
|
|
|
#[test]
|
|
fn interval_ms_keeps_flooring_a_fractional_argument() {
|
|
// F4 again: `integer` demands exactness, so the wrapper must floor
|
|
// BEFORE handing the value over. Pre-migration this returned 1500.
|
|
let s = editor(&fresh_state_dir());
|
|
let got: i64 = eval(&s, "return pmacs.autosave.interval_ms(1500.7)");
|
|
assert_eq!(got, 1500, "a fractional interval floors, it does not raise");
|
|
let stored: i64 = eval(&s, "return pmacs.config.get('autosave.interval-ms')");
|
|
assert_eq!(stored, 1500, "and the floored value is what was stored");
|
|
}
|
|
|
|
#[test]
|
|
fn interval_ms_still_raises_below_the_floor() {
|
|
let s = editor(&fresh_state_dir());
|
|
let raised: bool = eval(
|
|
&s,
|
|
"local ok = pcall(pmacs.autosave.interval_ms, 500); return not ok",
|
|
);
|
|
assert!(raised, "sub-floor intervals must still raise");
|
|
let unchanged: i64 = eval(&s, "return pmacs.autosave.interval_ms()");
|
|
assert_eq!(unchanged, 30000, "a rejected set leaves the value alone");
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Item 30 — a direct registry write is what the tick will read
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn interval_change_through_the_registry_is_visible_to_the_cadence_reader() {
|
|
// The tick re-reads `pmacs.config.get("autosave.interval-ms")` every
|
|
// frame rather than a module-local, so a mid-session change through
|
|
// EITHER path applies without a restart. Asserting through the
|
|
// wrapper's getter proves the module-local is really gone: a stale
|
|
// upvalue would still report 30000 here.
|
|
let s = editor(&fresh_state_dir());
|
|
exec(&s, "pmacs.config.set('autosave.interval-ms', 5000)");
|
|
let seen: i64 = eval(&s, "return pmacs.autosave.interval_ms()");
|
|
assert_eq!(
|
|
seen, 5000,
|
|
"a direct registry write must be what the cadence reads"
|
|
);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Item 19 — user config runs after builtins define, so a set in init.lua lands
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn a_set_in_user_config_position_is_observed_by_the_consumer() {
|
|
// EditorState::new does not load user config in test builds, so
|
|
// this drives the same ORDER explicitly: every builtin has defined,
|
|
// and a user-config-shaped `set` now runs against those names and
|
|
// is observed by the adopter that owns each one.
|
|
let dir = fresh_state_dir();
|
|
let mut s = editor(&dir);
|
|
exec(
|
|
&s,
|
|
r#"
|
|
pmacs.config.set("editing.auto-pair", false)
|
|
pmacs.config.set("editing.trim-on-save", true)
|
|
pmacs.config.set("autosave.interval-ms", 9000)
|
|
"#,
|
|
);
|
|
assert!(
|
|
eval::<bool>(&s, "return pmacs.editops.trim_on_save()"),
|
|
"editops observes the user-config write"
|
|
);
|
|
assert_eq!(
|
|
eval::<i64>(&s, "return pmacs.autosave.interval_ms()"),
|
|
9000,
|
|
"autosave observes the user-config write"
|
|
);
|
|
let a = write_file(&dir, "a.rs", "");
|
|
exec(&s, &format!("pmacs.buffer.find_or_open({a:?})"));
|
|
exec(&s, "pmacs.editor.goto_byte(0)");
|
|
type_str(&mut s, "(");
|
|
assert_eq!(
|
|
active_text(&s),
|
|
"(",
|
|
"pair.lua observes the user-config write"
|
|
);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Item 33 — M-x describe-setting renders into *help*
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn describe_setting_renders_into_help_with_the_source_location() {
|
|
let s0 = editor(&fresh_state_dir());
|
|
let mut s = s0;
|
|
exec(&s, "pmacs.command.invoke('editor.describe-setting')");
|
|
type_str(&mut s, "editing.auto-pair");
|
|
press(&mut s, KeyCode::Enter);
|
|
|
|
let text = help_text(&s);
|
|
assert!(
|
|
text.contains("Setting: editing.auto-pair"),
|
|
"*help* must carry the setting header, got {text:?}"
|
|
);
|
|
assert!(
|
|
text.contains("pair.lua"),
|
|
"the rendered source location must name the owning module, got {text:?}"
|
|
);
|
|
assert!(
|
|
text.contains("Type:") && text.contains("boolean"),
|
|
"the type must be rendered, got {text:?}"
|
|
);
|
|
assert!(
|
|
text.contains("Mutability:") && text.contains("live"),
|
|
"mutability must be rendered, got {text:?}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn describe_setting_reports_an_unknown_name_in_the_status_line() {
|
|
// `describe` RAISES NotFound for an undefined name rather than
|
|
// returning nil (define-before-set, Q#CR10), so the command must
|
|
// pcall — without it this dispatch would surface a Lua traceback.
|
|
let s0 = editor(&fresh_state_dir());
|
|
let mut s = s0;
|
|
exec(&s, "pmacs.command.invoke('editor.describe-setting')");
|
|
type_str(&mut s, "editing.no-such-setting");
|
|
press(&mut s, KeyCode::Enter);
|
|
|
|
let status = s.core.borrow().status.clone();
|
|
assert!(
|
|
format!("{status:?}").contains("no such setting"),
|
|
"an unknown name must report cleanly, got {status:?}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn describe_setting_shows_a_buffer_local_override_when_one_exists() {
|
|
let dir = fresh_state_dir();
|
|
let mut s = editor(&dir);
|
|
let a = write_file(&dir, "a.rs", "");
|
|
exec(&s, &format!("pmacs.buffer.find_or_open({a:?})"));
|
|
exec(
|
|
&s,
|
|
"pmacs.config.set_local(pmacs.window.buffer(), 'editing.auto-pair', false)",
|
|
);
|
|
exec(&s, "pmacs.command.invoke('editor.describe-setting')");
|
|
type_str(&mut s, "editing.auto-pair");
|
|
press(&mut s, KeyCode::Enter);
|
|
|
|
let text = help_text(&s);
|
|
assert!(
|
|
text.contains("Buffer-local override:"),
|
|
"an existing buffer-local override must be reported, got {text:?}"
|
|
);
|
|
}
|