Kyle Isom
95a588b0df
- Added `test_swap_git_editor.cc` to verify proper swap file cleanup during Git editor workflows. Ensures no stale swap files are left after editor closure. - Updated swap handling logic in `Editor.cc` to always remove swap files on buffer closure during normal exit, preventing accumulation of leftover files. - Bumped version to 1.6.5 in `CMakeLists.txt`.
580 lines
13 KiB
C++
580 lines
13 KiB
C++
#include <algorithm>
|
|
#include <cstdio>
|
|
#include <filesystem>
|
|
#include <utility>
|
|
|
|
#include "Editor.h"
|
|
#include "syntax/HighlighterRegistry.h"
|
|
#include "syntax/CppHighlighter.h"
|
|
#include "syntax/NullHighlighter.h"
|
|
|
|
|
|
namespace {
|
|
static std::string
|
|
buffer_bytes_via_views(const Buffer &b)
|
|
{
|
|
const auto &rows = b.Rows();
|
|
std::string out;
|
|
for (std::size_t i = 0; i < rows.size(); i++) {
|
|
auto v = b.GetLineView(i);
|
|
out.append(v.data(), v.size());
|
|
}
|
|
return out;
|
|
}
|
|
|
|
|
|
static void
|
|
apply_pending_line(Editor &ed, const std::size_t line1)
|
|
{
|
|
if (line1 == 0)
|
|
return;
|
|
Buffer *b = ed.CurrentBuffer();
|
|
if (!b)
|
|
return;
|
|
const std::size_t nrows = b->Nrows();
|
|
std::size_t line = line1 > 0 ? line1 - 1 : 0; // 1-based to 0-based
|
|
if (nrows > 0) {
|
|
if (line >= nrows)
|
|
line = nrows - 1;
|
|
} else {
|
|
line = 0;
|
|
}
|
|
b->SetCursor(0, line);
|
|
}
|
|
} // namespace
|
|
|
|
|
|
Editor::Editor()
|
|
{
|
|
swap_ = std::make_unique<kte::SwapManager>();
|
|
}
|
|
|
|
|
|
void
|
|
Editor::SetDimensions(std::size_t rows, std::size_t cols)
|
|
{
|
|
rows_ = rows;
|
|
cols_ = cols;
|
|
}
|
|
|
|
|
|
void
|
|
Editor::SetStatus(const std::string &message)
|
|
{
|
|
msg_ = message;
|
|
msgtm_ = std::time(nullptr);
|
|
}
|
|
|
|
|
|
Buffer *
|
|
Editor::CurrentBuffer()
|
|
{
|
|
if (buffers_.empty() || curbuf_ >= buffers_.size()) {
|
|
return nullptr;
|
|
}
|
|
return &buffers_[curbuf_];
|
|
}
|
|
|
|
|
|
const Buffer *
|
|
Editor::CurrentBuffer() const
|
|
{
|
|
if (buffers_.empty() || curbuf_ >= buffers_.size()) {
|
|
return nullptr;
|
|
}
|
|
return &buffers_[curbuf_];
|
|
}
|
|
|
|
|
|
static std::vector<std::filesystem::path>
|
|
split_reverse(const std::filesystem::path &p)
|
|
{
|
|
std::vector<std::filesystem::path> parts;
|
|
for (auto it = p; !it.empty(); it = it.parent_path()) {
|
|
if (it == it.parent_path()) {
|
|
// root or single element
|
|
if (!it.empty())
|
|
parts.push_back(it);
|
|
break;
|
|
}
|
|
parts.push_back(it.filename());
|
|
}
|
|
return parts; // from leaf toward root
|
|
}
|
|
|
|
|
|
std::string
|
|
Editor::DisplayNameFor(const Buffer &buf) const
|
|
{
|
|
std::string full = buf.Filename();
|
|
if (full.empty())
|
|
return std::string("[no name]");
|
|
|
|
std::filesystem::path target(full);
|
|
auto target_parts = split_reverse(target);
|
|
if (target_parts.empty())
|
|
return target.filename().string();
|
|
|
|
// Prepare list of other buffer paths
|
|
std::vector<std::vector<std::filesystem::path> > others;
|
|
others.reserve(buffers_.size());
|
|
for (const auto &b: buffers_) {
|
|
if (&b == &buf)
|
|
continue;
|
|
if (b.Filename().empty())
|
|
continue;
|
|
others.push_back(split_reverse(std::filesystem::path(b.Filename())));
|
|
}
|
|
|
|
// Increase suffix length until unique among others
|
|
std::size_t need = 1; // at least basename
|
|
for (;;) {
|
|
// Build candidate suffix for target
|
|
std::filesystem::path cand;
|
|
for (std::size_t i = 0; i < need && i < target_parts.size(); ++i) {
|
|
cand = std::filesystem::path(target_parts[i]) / cand;
|
|
}
|
|
// Compare against others
|
|
bool clash = false;
|
|
for (const auto &o_parts: others) {
|
|
std::filesystem::path ocand;
|
|
for (std::size_t i = 0; i < need && i < o_parts.size(); ++i) {
|
|
ocand = std::filesystem::path(o_parts[i]) / ocand;
|
|
}
|
|
if (ocand == cand) {
|
|
clash = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!clash || need >= target_parts.size()) {
|
|
std::string s = cand.string();
|
|
// Remove any trailing slash that may appear from root joining
|
|
if (!s.empty() && (s.back() == '/' || s.back() == '\\'))
|
|
s.pop_back();
|
|
return s;
|
|
}
|
|
++need;
|
|
}
|
|
}
|
|
|
|
|
|
std::size_t
|
|
Editor::AddBuffer(const Buffer &buf)
|
|
{
|
|
buffers_.push_back(buf);
|
|
// Attach swap recorder
|
|
if (swap_) {
|
|
swap_->Attach(&buffers_.back());
|
|
buffers_.back().SetSwapRecorder(swap_->RecorderFor(&buffers_.back()));
|
|
}
|
|
if (buffers_.size() == 1) {
|
|
curbuf_ = 0;
|
|
}
|
|
return buffers_.size() - 1;
|
|
}
|
|
|
|
|
|
std::size_t
|
|
Editor::AddBuffer(Buffer &&buf)
|
|
{
|
|
buffers_.push_back(std::move(buf));
|
|
if (swap_) {
|
|
swap_->Attach(&buffers_.back());
|
|
buffers_.back().SetSwapRecorder(swap_->RecorderFor(&buffers_.back()));
|
|
}
|
|
if (buffers_.size() == 1) {
|
|
curbuf_ = 0;
|
|
}
|
|
return buffers_.size() - 1;
|
|
}
|
|
|
|
|
|
bool
|
|
Editor::OpenFile(const std::string &path, std::string &err)
|
|
{
|
|
// If there is exactly one unnamed, empty, clean buffer, reuse it instead
|
|
// of creating a new one.
|
|
if (buffers_.size() == 1) {
|
|
Buffer &cur = buffers_[curbuf_];
|
|
const bool unnamed = cur.Filename().empty() && !cur.IsFileBacked();
|
|
const bool clean = !cur.Dirty();
|
|
const auto &rows = cur.Rows();
|
|
const bool rows_empty = rows.empty();
|
|
const bool single_empty_line = (!rows.empty() && rows.size() == 1 && rows[0].size() == 0);
|
|
if (unnamed && clean && (rows_empty || single_empty_line)) {
|
|
bool ok = cur.OpenFromFile(path, err);
|
|
if (!ok)
|
|
return false;
|
|
// Ensure swap recorder is attached for this buffer
|
|
if (swap_) {
|
|
swap_->Attach(&cur);
|
|
cur.SetSwapRecorder(swap_->RecorderFor(&cur));
|
|
swap_->NotifyFilenameChanged(cur);
|
|
}
|
|
// Setup highlighting using registry (extension + shebang)
|
|
cur.EnsureHighlighter();
|
|
std::string first = "";
|
|
const auto &cur_rows = cur.Rows();
|
|
if (!cur_rows.empty())
|
|
first = static_cast<std::string>(cur_rows[0]);
|
|
std::string ft = kte::HighlighterRegistry::DetectForPath(path, first);
|
|
if (!ft.empty()) {
|
|
cur.SetFiletype(ft);
|
|
cur.SetSyntaxEnabled(true);
|
|
if (auto *eng = cur.Highlighter()) {
|
|
eng->SetHighlighter(kte::HighlighterRegistry::CreateFor(ft));
|
|
eng->InvalidateFrom(0);
|
|
}
|
|
} else {
|
|
cur.SetFiletype("");
|
|
cur.SetSyntaxEnabled(true);
|
|
if (auto *eng = cur.Highlighter()) {
|
|
eng->SetHighlighter(std::make_unique<kte::NullHighlighter>());
|
|
eng->InvalidateFrom(0);
|
|
}
|
|
}
|
|
// Defensive: ensure any active prompt is closed after a successful open
|
|
CancelPrompt();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
Buffer b;
|
|
if (!b.OpenFromFile(path, err)) {
|
|
return false;
|
|
}
|
|
// NOTE: swap recorder/attach must happen after the buffer is stored in its
|
|
// final location (vector) because swap manager keys off Buffer*.
|
|
// Initialize syntax highlighting by extension + shebang via registry (v2)
|
|
b.EnsureHighlighter();
|
|
std::string first = "";
|
|
{
|
|
const auto &rows = b.Rows();
|
|
if (!rows.empty())
|
|
first = static_cast<std::string>(rows[0]);
|
|
}
|
|
std::string ft = kte::HighlighterRegistry::DetectForPath(path, first);
|
|
if (!ft.empty()) {
|
|
b.SetFiletype(ft);
|
|
b.SetSyntaxEnabled(true);
|
|
if (auto *eng = b.Highlighter()) {
|
|
eng->SetHighlighter(kte::HighlighterRegistry::CreateFor(ft));
|
|
eng->InvalidateFrom(0);
|
|
}
|
|
} else {
|
|
b.SetFiletype("");
|
|
b.SetSyntaxEnabled(true);
|
|
if (auto *eng = b.Highlighter()) {
|
|
eng->SetHighlighter(std::make_unique<kte::NullHighlighter>());
|
|
eng->InvalidateFrom(0);
|
|
}
|
|
}
|
|
// Add as a new buffer and switch to it
|
|
std::size_t idx = AddBuffer(std::move(b));
|
|
if (swap_) {
|
|
swap_->NotifyFilenameChanged(buffers_[idx]);
|
|
}
|
|
SwitchTo(idx);
|
|
// Defensive: ensure any active prompt is closed after a successful open
|
|
CancelPrompt();
|
|
return true;
|
|
}
|
|
|
|
|
|
void
|
|
Editor::RequestOpenFile(const std::string &path, const std::size_t line1)
|
|
{
|
|
PendingOpen p;
|
|
p.path = path;
|
|
p.line1 = line1;
|
|
pending_open_.push_back(std::move(p));
|
|
}
|
|
|
|
|
|
bool
|
|
Editor::HasPendingOpens() const
|
|
{
|
|
return !pending_open_.empty();
|
|
}
|
|
|
|
|
|
Editor::RecoveryPromptKind
|
|
Editor::PendingRecoveryPrompt() const
|
|
{
|
|
return pending_recovery_prompt_;
|
|
}
|
|
|
|
|
|
void
|
|
Editor::CancelRecoveryPrompt()
|
|
{
|
|
pending_recovery_prompt_ = RecoveryPromptKind::None;
|
|
pending_recovery_open_ = PendingOpen{};
|
|
pending_recovery_swap_path_.clear();
|
|
pending_recovery_replay_err_.clear();
|
|
}
|
|
|
|
|
|
bool
|
|
Editor::ResolveRecoveryPrompt(const bool yes)
|
|
{
|
|
const RecoveryPromptKind kind = pending_recovery_prompt_;
|
|
if (kind == RecoveryPromptKind::None)
|
|
return false;
|
|
const PendingOpen req = pending_recovery_open_;
|
|
const std::string swp = pending_recovery_swap_path_;
|
|
const std::string rerr_s = pending_recovery_replay_err_;
|
|
CancelRecoveryPrompt();
|
|
|
|
std::string err;
|
|
if (kind == RecoveryPromptKind::RecoverOrDiscard) {
|
|
if (yes) {
|
|
if (!OpenFile(req.path, err)) {
|
|
SetStatus(err);
|
|
return false;
|
|
}
|
|
Buffer *b = CurrentBuffer();
|
|
if (!b) {
|
|
SetStatus("Recovery failed: no buffer");
|
|
return false;
|
|
}
|
|
std::string rerr;
|
|
if (!kte::SwapManager::ReplayFile(*b, swp, rerr)) {
|
|
SetStatus("Swap recovery failed: " + rerr);
|
|
return false;
|
|
}
|
|
b->SetDirty(true);
|
|
apply_pending_line(*this, req.line1);
|
|
SetStatus("Recovered " + req.path);
|
|
return true;
|
|
}
|
|
// Discard: best-effort delete swap, then open clean.
|
|
(void) std::remove(swp.c_str());
|
|
if (!OpenFile(req.path, err)) {
|
|
SetStatus(err);
|
|
return false;
|
|
}
|
|
apply_pending_line(*this, req.line1);
|
|
SetStatus("Opened " + req.path);
|
|
return true;
|
|
}
|
|
if (kind == RecoveryPromptKind::DeleteCorruptSwap) {
|
|
if (yes) {
|
|
(void) std::remove(swp.c_str());
|
|
}
|
|
if (!OpenFile(req.path, err)) {
|
|
SetStatus(err);
|
|
return false;
|
|
}
|
|
apply_pending_line(*this, req.line1);
|
|
// Include a short hint that the swap was corrupt.
|
|
if (!rerr_s.empty()) {
|
|
SetStatus("Opened " + req.path + " (swap unreadable)");
|
|
} else {
|
|
SetStatus("Opened " + req.path);
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
bool
|
|
Editor::ProcessPendingOpens()
|
|
{
|
|
if (PromptActive())
|
|
return false;
|
|
if (pending_recovery_prompt_ != RecoveryPromptKind::None)
|
|
return false;
|
|
|
|
bool opened_any = false;
|
|
while (!pending_open_.empty()) {
|
|
PendingOpen req = std::move(pending_open_.front());
|
|
pending_open_.pop_front();
|
|
if (req.path.empty())
|
|
continue;
|
|
|
|
std::string swp = kte::SwapManager::ComputeSwapPathForFilename(req.path);
|
|
bool swp_exists = false;
|
|
try {
|
|
swp_exists = !swp.empty() && std::filesystem::exists(std::filesystem::path(swp));
|
|
} catch (...) {
|
|
swp_exists = false;
|
|
}
|
|
if (swp_exists) {
|
|
Buffer tmp;
|
|
std::string oerr;
|
|
if (tmp.OpenFromFile(req.path, oerr)) {
|
|
const std::string orig = buffer_bytes_via_views(tmp);
|
|
std::string rerr;
|
|
if (kte::SwapManager::ReplayFile(tmp, swp, rerr)) {
|
|
const std::string rec = buffer_bytes_via_views(tmp);
|
|
if (rec != orig) {
|
|
pending_recovery_prompt_ = RecoveryPromptKind::RecoverOrDiscard;
|
|
pending_recovery_open_ = req;
|
|
pending_recovery_swap_path_ = swp;
|
|
StartPrompt(PromptKind::Confirm, "Recover", "");
|
|
SetStatus("Recover swap edits for " + req.path + "? (y/N, C-g cancel)");
|
|
return opened_any;
|
|
}
|
|
} else {
|
|
pending_recovery_prompt_ = RecoveryPromptKind::DeleteCorruptSwap;
|
|
pending_recovery_open_ = req;
|
|
pending_recovery_swap_path_ = swp;
|
|
pending_recovery_replay_err_ = rerr;
|
|
StartPrompt(PromptKind::Confirm, "Swap", "");
|
|
SetStatus(
|
|
"Swap file unreadable for " + req.path +
|
|
". Delete it? (y/N, C-g cancel)");
|
|
return opened_any;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::string err;
|
|
if (!OpenFile(req.path, err)) {
|
|
SetStatus(err);
|
|
opened_any = false;
|
|
continue;
|
|
}
|
|
apply_pending_line(*this, req.line1);
|
|
SetStatus("Opened " + req.path);
|
|
opened_any = true;
|
|
// Open at most one per call; frontends can call us again next frame.
|
|
break;
|
|
}
|
|
return opened_any;
|
|
}
|
|
|
|
|
|
bool
|
|
Editor::SwitchTo(std::size_t index)
|
|
{
|
|
if (index >= buffers_.size()) {
|
|
return false;
|
|
}
|
|
curbuf_ = index;
|
|
// Robustness: ensure a valid highlighter is installed when switching buffers
|
|
Buffer &b = buffers_[curbuf_];
|
|
if (b.SyntaxEnabled()) {
|
|
b.EnsureHighlighter();
|
|
if (auto *eng = b.Highlighter()) {
|
|
if (!eng->HasHighlighter()) {
|
|
// Try to set based on existing filetype; fall back to NullHighlighter
|
|
if (!b.Filetype().empty()) {
|
|
auto hl = kte::HighlighterRegistry::CreateFor(b.Filetype());
|
|
if (hl) {
|
|
eng->SetHighlighter(std::move(hl));
|
|
} else {
|
|
eng->SetHighlighter(std::make_unique<kte::NullHighlighter>());
|
|
}
|
|
} else {
|
|
eng->SetHighlighter(std::make_unique<kte::NullHighlighter>());
|
|
}
|
|
eng->InvalidateFrom(0);
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
bool
|
|
Editor::CloseBuffer(std::size_t index)
|
|
{
|
|
if (index >= buffers_.size()) {
|
|
return false;
|
|
}
|
|
if (swap_) {
|
|
// Always remove swap file when closing a buffer on normal exit.
|
|
// Swap files are for crash recovery; on clean close, we don't need them.
|
|
// This prevents stale swap files from accumulating (e.g., when used as git editor).
|
|
swap_->Detach(&buffers_[index], true);
|
|
buffers_[index].SetSwapRecorder(nullptr);
|
|
}
|
|
buffers_.erase(buffers_.begin() + static_cast<std::ptrdiff_t>(index));
|
|
if (buffers_.empty()) {
|
|
curbuf_ = 0;
|
|
} else if (curbuf_ >= buffers_.size()) {
|
|
curbuf_ = buffers_.size() - 1;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
void
|
|
Editor::Reset()
|
|
{
|
|
rows_ = cols_ = 0;
|
|
mode_ = 0;
|
|
kill_ = 0;
|
|
no_kill_ = 0;
|
|
dirtyex_ = 0;
|
|
msg_.clear();
|
|
msgtm_ = 0;
|
|
uarg_ = 0;
|
|
ucount_ = 0;
|
|
repeatable_ = false;
|
|
quit_requested_ = false;
|
|
quit_confirm_pending_ = false;
|
|
// Reset close-confirm/save state
|
|
close_confirm_pending_ = false;
|
|
close_after_save_ = false;
|
|
buffers_.clear();
|
|
curbuf_ = 0;
|
|
}
|
|
|
|
|
|
// --- Universal argument helpers ---
|
|
void
|
|
Editor::UArgStart()
|
|
{
|
|
// If not active, start fresh; else multiply by 4 per ke semantics
|
|
if (uarg_ == 0) {
|
|
ucount_ = 0;
|
|
} else {
|
|
if (ucount_ == 0) {
|
|
ucount_ = 1;
|
|
}
|
|
ucount_ *= 4;
|
|
}
|
|
uarg_ = 1;
|
|
char buf[64];
|
|
std::snprintf(buf, sizeof(buf), "C-u %d", ucount_);
|
|
SetStatus(buf);
|
|
}
|
|
|
|
|
|
void
|
|
Editor::UArgDigit(int d)
|
|
{
|
|
if (d < 0)
|
|
d = 0;
|
|
if (d > 9)
|
|
d = 9;
|
|
if (uarg_ == 0) {
|
|
uarg_ = 1;
|
|
ucount_ = 0;
|
|
}
|
|
ucount_ = ucount_ * 10 + d;
|
|
char buf[64];
|
|
std::snprintf(buf, sizeof(buf), "C-u %d", ucount_);
|
|
SetStatus(buf);
|
|
}
|
|
|
|
|
|
void
|
|
Editor::UArgClear()
|
|
{
|
|
uarg_ = 0;
|
|
ucount_ = 0;
|
|
}
|
|
|
|
|
|
int
|
|
Editor::UArgGet()
|
|
{
|
|
int n = (ucount_ > 0) ? ucount_ : 1;
|
|
UArgClear();
|
|
return n;
|
|
} |