fix: remove extra close_file call in mainview.extract_state

src/main.zig

@@ -533,7 +533,7 @@ pub fn read_config(T: type, allocator: std.mem.Allocator) struct { T, [][]const
 
 // returns true if the file was found
 fn read_config_file(T: type, allocator: std.mem.Allocator, conf: *T, bufs: *[][]const u8, file_name: []const u8) bool {
-    std.log.info("loading {s}", .{file_name});
+    // std.log.info("loading {s}", .{file_name});
     const err: anyerror = blk: {
         if (std.mem.endsWith(u8, file_name, ".json")) if (read_json_config_file(T, allocator, conf, bufs, file_name)) return true else |e| break :blk e;
         if (read_text_config_file(T, allocator, conf, bufs, file_name)) return true else |e| break :blk e;

src/tui/mainview.zig

@@ -58,6 +58,7 @@ file_list_type: FileListType = .find_in_files,
 panel_height: ?usize = null,
 symbols: std.ArrayListUnmanaged(u8) = .empty,
 symbols_complete: bool = true,
+closing_project: bool = false,
 
 const FileListType = enum {
     diagnostics,
@@ -392,6 +393,8 @@ const cmds = struct {
     pub const close_project_meta: Meta = .{ .arguments = &.{.string} };
 
     pub fn change_project(self: *Self, ctx: Ctx) Result {
+        const logger = log.logger("change_project");
+        defer logger.deinit();
         var project_dir: []const u8 = undefined;
         if (!try ctx.args.match(.{tp.extract(&project_dir)}))
             return;
@@ -406,26 +409,34 @@ const cmds = struct {
             var state_al = state_writer.toArrayList();
             const state = state_al.toManaged(self.allocator);
             try project_manager.store_state(old_project, state);
+            logger.print("stored project state for: {s} ({d} bytes)", .{ old_project, state.items.len });
         }
 
         const project_state = try project_manager.open(project_dir);
 
-        try self.close_all_editors();
+        {
-        self.delete_all_buffers();
+            self.closing_project = true;
-        self.clear_find_in_files_results(.diagnostics);
+            defer self.closing_project = false;
-        if (self.file_list_type == .diagnostics and self.is_panel_view_showing(filelist_view))
+            try self.close_all_editors();
-            try self.toggle_panel_view(filelist_view, false);
+            self.delete_all_buffers();
-        self.buffer_manager.deinit();
+            self.clear_find_in_files_results(.diagnostics);
-        self.buffer_manager = Buffer.Manager.init(self.allocator);
+            if (self.file_list_type == .diagnostics and self.is_panel_view_showing(filelist_view))
+                try self.toggle_panel_view(filelist_view, false);
+            self.buffer_manager.deinit();
+            self.buffer_manager = Buffer.Manager.init(self.allocator);
+        }
 
         const project = tp.env.get().str("project");
         tui.rdr().set_terminal_working_directory(project);
-        if (project_state) |state| try self.restore_state(state);
+        if (project_state) |state| {
+            logger.print("restoring {d} bytes of project state for: {s}", .{ state.len, project });
+            try self.restore_state(state);
+        } else {
+            logger.print("no project state to restore for: {s}", .{project});
+        }
 
         if (self.top_bar) |bar| _ = try bar.msg(.{ "PRJ", "open" });
         if (self.bottom_bar) |bar| _ = try bar.msg(.{ "PRJ", "open" });
-        if (project_state == null)
-            tp.self_pid().send(.{ "cmd", "open_recent" }) catch return;
     }
     pub const change_project_meta: Meta = .{ .arguments = &.{.string} };
 
@@ -1406,10 +1417,12 @@ pub fn handle_editor_event(self: *Self, _: tp.pid_ref, m: tp.message) tp.result
         return self.location_update(m);
 
     if (try m.match(.{ "E", "close" })) {
-        if (self.get_next_mru_buffer(.non_hidden)) |file_path|
+        if (!self.closing_project) {
-            self.show_file_async(file_path)
+            if (self.get_next_mru_buffer(.non_hidden)) |file_path|
-        else
+                self.show_file_async(file_path)
-            self.show_home_async();
+            else
+                self.show_home_async();
+        } else self.show_home_async();
         self.active_editor = null;
         return;
     }
@@ -1682,11 +1695,19 @@ fn restore_state(self: *Self, state: []const u8) !void {
 }
 
 fn extract_state(self: *Self, iter: *[]const u8) !void {
+    const logger = log.logger("extract_state");
+    defer logger.deinit();
     tp.trace(tp.channel.debug, .{ "mainview", "extract" });
     var editor_file_path: ?[]const u8 = undefined;
-    if (!try cbor.matchValue(iter, cbor.extract(&editor_file_path))) return error.MatchFilePathFailed;
+    var prev_len = iter.len;
+    if (!try cbor.matchValue(iter, cbor.extract(&editor_file_path))) {
+        logger.print("restore editor_file_path failed", .{});
+        return error.MatchFilePathFailed;
+    }
+    logger.print("restored editor_file_path: {s} ({d} bytes)", .{ editor_file_path orelse "(null)", prev_len - iter.len });
 
     tui.clipboard_clear_all();
+    prev_len = iter.len;
     var len = try cbor.decodeArrayHeader(iter);
     var prev_group: usize = 0;
     const clipboard_allocator = tui.clipboard_allocator();
@@ -1701,27 +1722,27 @@ fn extract_state(self: *Self, iter: *[]const u8) !void {
         prev_group = group;
         tui.clipboard_add_chunk(try clipboard_allocator.dupe(u8, text));
     }
+    logger.print("restored clipboard ({d} bytes)", .{prev_len - iter.len});
 
+    prev_len = iter.len;
     try self.buffer_manager.extract_state(iter);
+    logger.print("restored buffer manager ({d} bytes)", .{prev_len - iter.len});
 
+    prev_len = iter.len;
     if (self.widgets.get("tabs")) |tabs_widget|
         if (tabs_widget.dynamic_cast(@import("status/tabs.zig").TabBar)) |tabs|
-            tabs.extract_state(iter) catch |e| {
+            tabs.extract_state(iter) catch |e|
-                const logger = log.logger("mainview");
-                defer logger.deinit();
                 logger.print_err("mainview", "failed to restore tabs: {}", .{e});
-            };
+    logger.print("restored tabs ({d} bytes)", .{prev_len - iter.len});
 
     const buffers = try self.buffer_manager.list_unordered(self.allocator);
     defer self.allocator.free(buffers);
     for (buffers) |buffer| if (!buffer.is_ephemeral())
         send_buffer_did_open(self.allocator, buffer) catch {};
 
-    if (editor_file_path) |file_path| {
+    if (editor_file_path) |file_path|
         if (self.buffer_manager.get_buffer_for_file(file_path)) |_|
-            return tp.self_pid().send(.{ "cmd", "navigate", .{ .file = file_path } });
+            try tp.self_pid().send(.{ "cmd", "navigate", .{ .file = file_path } });
-    }
-    try tp.self_pid().send(.{ "cmd", "close_file" });
 }
 
 fn send_buffer_did_open(allocator: std.mem.Allocator, buffer: *Buffer) !void {

src/tui/mode/overlay/command_palette.zig

@@ -63,8 +63,8 @@ fn select(menu: **Type.MenuType, button: *Type.ButtonType, _: Type.Pos) void {
         cbor.skipValue(&iter) catch break;
     if (!(cbor.matchValue(&iter, cbor.extract(&command_id)) catch false)) return;
     update_used_time(menu.*.opts.ctx, command_id);
-    tp.self_pid().send(.{ "cmd", "exit_overlay_mode" }) catch |e| menu.*.opts.ctx.logger.err("navigate", e);
+    tp.self_pid().send(.{ "cmd", "exit_overlay_mode" }) catch |e| menu.*.opts.ctx.logger.err("command_palette", e);
-    tp.self_pid().send(.{ "cmd", command_id, .{} }) catch |e| menu.*.opts.ctx.logger.err("navigate", e);
+    tp.self_pid().send(.{ "cmd", command_id, .{} }) catch |e| menu.*.opts.ctx.logger.err("command_palette", e);
 }
 
 fn sort_by_used_time(palette: *Type) void {

src/tui/mode/overlay/list_all_commands_palette.zig

@@ -79,6 +79,6 @@ fn select(menu: **Type.MenuType, button: *Type.ButtonType, _: Type.Pos) void {
     while (len > 0) : (len -= 1)
         cbor.skipValue(&iter) catch break;
     if (!(cbor.matchValue(&iter, cbor.extract(&command_id)) catch false)) return;
-    tp.self_pid().send(.{ "cmd", "exit_overlay_mode" }) catch |e| menu.*.opts.ctx.logger.err("navigate", e);
+    tp.self_pid().send(.{ "cmd", "exit_overlay_mode" }) catch |e| menu.*.opts.ctx.logger.err("command_palette", e);
     tp.self_pid().send(.{ "cmd", "paste", .{command.get_name(command_id) orelse return} }) catch {};
 }