feat: add open_lsp_config_global and open_lsp_config_project commands

Also, simplify cbor encoding of initializationOptions.

build.zig

@@ -378,6 +378,13 @@ pub fn build_exe(
         },
     });
 
+    const lsp_config_mod = b.createModule(.{
+        .root_source_file = b.path("src/lsp_config.zig"),
+        .imports = &.{
+            .{ .name = "soft_root", .module = soft_root_mod },
+        },
+    });
+
     const log_mod = b.createModule(.{
         .root_source_file = b.path("src/log.zig"),
         .imports = &.{
@@ -579,6 +586,7 @@ pub fn build_exe(
             .{ .name = "Buffer", .module = Buffer_mod },
             .{ .name = "tracy", .module = tracy_mod },
             .{ .name = "file_type_config", .module = file_type_config_mod },
+            .{ .name = "lsp_config", .module = lsp_config_mod },
             .{ .name = "dizzy", .module = dizzy_dep.module("dizzy") },
             .{ .name = "fuzzig", .module = fuzzig_dep.module("fuzzig") },
             .{ .name = "git", .module = git_mod },
@@ -615,6 +623,7 @@ pub fn build_exe(
             .{ .name = "config", .module = config_mod },
             .{ .name = "gui_config", .module = gui_config_mod },
             .{ .name = "file_type_config", .module = file_type_config_mod },
+            .{ .name = "lsp_config", .module = lsp_config_mod },
             .{ .name = "log", .module = log_mod },
             .{ .name = "command", .module = command_mod },
             .{ .name = "EventHandler", .module = EventHandler_mod },

src/Project.zig

@@ -314,7 +314,7 @@ fn get_existing_language_server(self: *Self, language_server: []const u8) ?*cons
     return null;
 }
 
-fn get_language_server_instance(self: *Self, language_server: []const u8) StartLspError!*const LSP {
+fn get_language_server_instance(self: *Self, language_server: []const u8, language_server_options: []const u8) StartLspError!*const LSP {
     if (self.get_existing_language_server(language_server)) |lsp| return lsp;
     const lsp = try LSP.open(self.allocator, self.name, .{ .buf = language_server });
     errdefer lsp.deinit();
@@ -324,15 +324,15 @@ fn get_language_server_instance(self: *Self, language_server: []const u8) StartL
     const basename = if (basename_begin) |begin| self.name[begin + 1 ..] else self.name;
 
     errdefer lsp.deinit();
-    try self.send_lsp_init_request(lsp, self.name, basename, uri, language_server);
+    try self.send_lsp_init_request(lsp, self.name, basename, uri, language_server, language_server_options);
     try self.language_servers.put(try self.allocator.dupe(u8, language_server), lsp);
     return lsp;
 }
 
-fn get_or_start_language_server(self: *Self, file_path: []const u8, language_server: []const u8) StartLspError!*const LSP {
+fn get_or_start_language_server(self: *Self, file_path: []const u8, language_server: []const u8, language_server_options: []const u8) StartLspError!*const LSP {
     if (self.file_language_server_name.get(file_path)) |lsp_name|
         return self.get_existing_language_server(lsp_name) orelse error.LspFailed;
-    const lsp = try self.get_language_server_instance(language_server);
+    const lsp = try self.get_language_server_instance(language_server, language_server_options);
     const key = try self.allocator.dupe(u8, file_path);
     const value = try self.allocator.dupe(u8, language_server);
     try self.file_language_server_name.put(key, value);
@@ -762,10 +762,10 @@ pub fn delete_task(self: *Self, command: []const u8) error{}!void {
         };
 }
 
-pub fn did_open(self: *Self, file_path: []const u8, file_type: []const u8, language_server: []const u8, version: usize, text: []const u8) StartLspError!void {
+pub fn did_open(self: *Self, file_path: []const u8, file_type: []const u8, language_server: []const u8, language_server_options: []const u8, version: usize, text: []const u8) StartLspError!void {
     defer std.heap.c_allocator.free(text);
     self.update_mru(file_path, 0, 0) catch {};
-    const lsp = try self.get_or_start_language_server(file_path, language_server);
+    const lsp = try self.get_or_start_language_server(file_path, language_server, language_server_options);
     const uri = try self.make_URI(file_path);
     defer self.allocator.free(uri);
     lsp.send_notification("textDocument/didOpen", .{
@@ -1999,7 +1999,7 @@ pub fn unsupported_lsp_request(self: *Self, from: tp.pid_ref, cbor_id: []const u
     return LSP.send_error_response(self.allocator, from, cbor_id, LSP.ErrorCode.MethodNotFound, method) catch error.ClientFailed;
 }
 
-fn send_lsp_init_request(self: *Self, lsp: *const LSP, project_path: []const u8, project_basename: []const u8, project_uri: []const u8, language_server: []const u8) !void {
+fn send_lsp_init_request(self: *Self, lsp: *const LSP, project_path: []const u8, project_basename: []const u8, project_uri: []const u8, language_server: []const u8, language_server_options: []const u8) !void {
     const handler: struct {
         language_server: []const u8,
         lsp: LSP,
@@ -2025,8 +2025,22 @@ fn send_lsp_init_request(self: *Self, lsp: *const LSP, project_path: []const u8,
     };
 
     const version = if (root.version.len > 0 and root.version[0] == 'v') root.version[1..] else root.version;
+    const initializationOptions: struct {
+        pub fn cborEncode(self_: @This(), writer: *std.Io.Writer) std.io.Writer.Error!void {
+            const toCbor = cbor.fromJsonAlloc(self_.alloc, self_.options) catch {
+                try cbor.writeValue(writer, cbor.null_);
+                return;
+            };
+            defer self_.alloc.free(toCbor);
+
+            writer.writeAll(toCbor) catch return error.WriteFailed;
+        }
+        options: []const u8,
+        alloc: std.mem.Allocator,
+    } = .{ .options = language_server_options, .alloc = self.allocator };
 
     try lsp.send_request(self.allocator, "initialize", .{
+        .initializationOptions = initializationOptions,
         .processId = if (builtin.os.tag == .linux) std.os.linux.getpid() else null,
         .rootPath = project_path,
         .rootUri = project_uri,

src/lsp_config.zig

@@ -0,0 +1,75 @@
+pub fn get(project: []const u8, lsp_name: []const u8) ?[]const u8 {
+    if (project.len == 0) return get_global(lsp_name);
+    if (get_project(project, lsp_name)) |conf| return conf;
+    return get_global(lsp_name);
+}
+
+fn get_project(project: []const u8, lsp_name: []const u8) ?[]const u8 {
+    const file_name = get_config_file_path(project, lsp_name, .project, .no_create) catch return null;
+    defer allocator.free(file_name);
+    const file: std.fs.File = std.fs.openFileAbsolute(file_name, .{ .mode = .read_only }) catch return null;
+    defer file.close();
+    return file.readToEndAlloc(allocator, std.math.maxInt(usize)) catch return null;
+}
+
+fn get_global(lsp_name: []const u8) ?[]const u8 {
+    const file_name = get_config_file_path(&.{}, lsp_name, .global, .no_create) catch return null;
+    defer allocator.free(file_name);
+    const file: std.fs.File = std.fs.openFileAbsolute(file_name, .{ .mode = .read_only }) catch return null;
+    defer file.close();
+    return file.readToEndAlloc(allocator, std.math.maxInt(usize)) catch return null;
+}
+
+pub fn get_config_file_path(project: ?[]const u8, lsp_name: []const u8, scope: Scope, mode: Mode) ![]u8 {
+    const config_dir_path = try get_config_dir_path(project, scope, mode);
+    defer allocator.free(config_dir_path);
+    var stream: std.Io.Writer.Allocating = .init(allocator);
+    defer stream.deinit();
+    try stream.writer.print("{s}{s}.json", .{ config_dir_path, lsp_name });
+    return stream.toOwnedSlice();
+}
+
+fn get_config_dir_path(project: ?[]const u8, scope: Scope, mode: Mode) ![]u8 {
+    var stream: std.Io.Writer.Allocating = .init(allocator);
+    defer stream.deinit();
+    const writer = &stream.writer;
+    try writer.writeAll(try root.get_config_dir());
+    try writer.writeByte(std.fs.path.sep);
+    switch (scope) {
+        .project => {
+            try writer.writeAll("project");
+            try writer.writeByte(std.fs.path.sep);
+            if (mode == .mk_parents) std.fs.makeDirAbsolute(stream.written()) catch |e| switch (e) {
+                error.PathAlreadyExists => {},
+                else => return e,
+            };
+            if (project) |prj| {
+                for (prj) |c| {
+                    _ = if (std.fs.path.isSep(c))
+                        try writer.write("__")
+                    else if (c == ':')
+                        try writer.write("___")
+                    else
+                        try writer.writeByte(c);
+                }
+                _ = try writer.writeByte(std.fs.path.sep);
+            }
+        },
+        .global => {
+            try writer.writeAll("lsp");
+            try writer.writeByte(std.fs.path.sep);
+        },
+    }
+    if (mode == .mk_parents) std.fs.makeDirAbsolute(stream.written()) catch |e| switch (e) {
+        error.PathAlreadyExists => {},
+        else => return e,
+    };
+    return stream.toOwnedSlice();
+}
+
+pub const Scope = enum { project, global };
+pub const Mode = enum { mk_parents, no_create };
+
+pub const allocator = std.heap.c_allocator;
+const std = @import("std");
+const root = @import("soft_root").root;

src/project_manager.zig

@@ -4,6 +4,7 @@ const cbor = @import("cbor");
 const log = @import("log");
 const tracy = @import("tracy");
 const file_type_config = @import("file_type_config");
+const lsp_config = @import("lsp_config");
 const root = @import("soft_root").root;
 const Buffer = @import("Buffer");
 const builtin = @import("builtin");
@@ -192,7 +193,9 @@ pub fn did_open(file_path: []const u8, file_type: file_type_config, version: usi
         return error.NoProject;
     const text_ptr: usize = if (text.len > 0) @intFromPtr(text.ptr) else 0;
     const language_server = file_type.language_server orelse return;
-    return send(.{ "did_open", project, file_path, file_type.name, language_server, version, text_ptr, text.len });
+    const language_server_options = if (file_type.language_server) |lsp| lsp_config.get(project, lsp[0]) orelse &.{} else &.{};
+    defer lsp_config.allocator.free(language_server_options);
+    return send(.{ "did_open", project, file_path, file_type.name, language_server, language_server_options, version, text_ptr, text.len });
 }
 
 pub fn did_change(file_path: []const u8, version: usize, text_dst: []const u8, text_src: []const u8, eol_mode: Buffer.EolMode) (ProjectManagerError || ProjectError)!void {
@@ -376,6 +379,7 @@ const Process = struct {
         var query: []const u8 = undefined;
         var file_type: []const u8 = undefined;
         var language_server: []const u8 = undefined;
+        var language_server_options: []const u8 = undefined;
         var method: []const u8 = undefined;
         var cbor_id: []const u8 = undefined;
         var params_cb: []const u8 = undefined;
@@ -444,9 +448,9 @@ const Process = struct {
             self.add_task(project_directory, task) catch |e| return from.forward_error(e, @errorReturnTrace()) catch error.ClientFailed;
         } else if (try cbor.match(m.buf, .{ "delete_task", tp.extract(&project_directory), tp.extract(&task) })) {
             self.delete_task(project_directory, task) catch |e| return from.forward_error(e, @errorReturnTrace()) catch error.ClientFailed;
-        } else if (try cbor.match(m.buf, .{ "did_open", tp.extract(&project_directory), tp.extract(&path), tp.extract(&file_type), tp.extract_cbor(&language_server), tp.extract(&version), tp.extract(&text_ptr), tp.extract(&text_len) })) {
+        } else if (try cbor.match(m.buf, .{ "did_open", tp.extract(&project_directory), tp.extract(&path), tp.extract(&file_type), tp.extract_cbor(&language_server), tp.extract(&language_server_options), tp.extract(&version), tp.extract(&text_ptr), tp.extract(&text_len) })) {
             const text = if (text_len > 0) @as([*]const u8, @ptrFromInt(text_ptr))[0..text_len] else "";
-            self.did_open(project_directory, path, file_type, language_server, version, text) catch |e| return from.forward_error(e, @errorReturnTrace()) catch error.ClientFailed;
+            self.did_open(project_directory, path, file_type, language_server, language_server_options, version, text) catch |e| return from.forward_error(e, @errorReturnTrace()) catch error.ClientFailed;
         } else if (try cbor.match(m.buf, .{ "did_change", tp.extract(&project_directory), tp.extract(&path), tp.extract(&version), tp.extract(&text_dst_ptr), tp.extract(&text_dst_len), tp.extract(&text_src_ptr), tp.extract(&text_src_len), tp.extract(&eol_mode) })) {
             const text_dst = if (text_dst_len > 0) @as([*]const u8, @ptrFromInt(text_dst_ptr))[0..text_dst_len] else "";
             const text_src = if (text_src_len > 0) @as([*]const u8, @ptrFromInt(text_src_ptr))[0..text_src_len] else "";
@@ -635,11 +639,11 @@ const Process = struct {
         try project.request_vcs_status(from);
     }
 
-    fn did_open(self: *Process, project_directory: []const u8, file_path: []const u8, file_type: []const u8, language_server: []const u8, version: usize, text: []const u8) (ProjectError || Project.StartLspError || CallError || cbor.Error)!void {
+    fn did_open(self: *Process, project_directory: []const u8, file_path: []const u8, file_type: []const u8, language_server: []const u8, language_server_options: []const u8, version: usize, text: []const u8) (ProjectError || Project.StartLspError || CallError || cbor.Error)!void {
         const frame = tracy.initZone(@src(), .{ .name = module_name ++ ".did_open" });
         defer frame.deinit();
         const project = self.projects.get(project_directory) orelse return error.NoProject;
-        return project.did_open(file_path, file_type, language_server, version, text);
+        return project.did_open(file_path, file_type, language_server, language_server_options, version, text);
     }
 
     fn did_change(self: *Process, project_directory: []const u8, file_path: []const u8, version: usize, text_dst: []const u8, text_src: []const u8, eol_mode: Buffer.EolMode) (ProjectError || Project.LspError)!void {

src/tui/mainview.zig

@@ -10,6 +10,7 @@ const log = @import("log");
 const shell = @import("shell");
 const syntax = @import("syntax");
 const file_type_config = @import("file_type_config");
+const lsp_config = @import("lsp_config");
 const builtin = @import("builtin");
 const build_options = @import("build_options");
 
@@ -684,6 +685,27 @@ const cmds = struct {
         .description = "Edit file type configuration",
     };
 
+    pub fn open_lsp_config_global(self: *Self, _: Ctx) Result {
+        const editor = self.get_active_editor() orelse return no_lsp_error();
+        const file_type = editor.file_type orelse return no_lsp_error();
+        const language_server = file_type.language_server orelse return no_lsp_error();
+        const lsp_name = language_server[0];
+        const file_name = try lsp_config.get_config_file_path(null, lsp_name, .global, .mk_parents);
+        try tp.self_pid().send(.{ "cmd", "navigate", .{ .file = file_name } });
+    }
+    pub const open_lsp_config_global_meta: Meta = .{ .description = "Edit LSP configuration (global)" };
+
+    pub fn open_lsp_config_project(self: *Self, _: Ctx) Result {
+        const editor = self.get_active_editor() orelse return no_lsp_error();
+        const file_type = editor.file_type orelse return no_lsp_error();
+        const language_server = file_type.language_server orelse return no_lsp_error();
+        const lsp_name = language_server[0];
+        const project = tp.env.get().str("project");
+        const file_name = try lsp_config.get_config_file_path(project, lsp_name, .project, .mk_parents);
+        try tp.self_pid().send(.{ "cmd", "navigate", .{ .file = file_name } });
+    }
+    pub const open_lsp_config_project_meta: Meta = .{ .description = "Edit LSP configuration (project)" };
+
     pub fn create_scratch_buffer(self: *Self, ctx: Ctx) Result {
         const args = try ctx.args.clone(self.allocator);
         defer self.allocator.free(args.buf);
@@ -1438,6 +1460,12 @@ const cmds = struct {
     pub const place_next_tab_meta: Meta = .{ .arguments = &.{ .string, .integer } };
 };
 
+fn no_lsp_error() void {
+    const logger = log.logger("editor");
+    defer logger.deinit();
+    logger.print("no LSP currently in use", .{});
+}
+
 pub fn handle_editor_event(self: *Self, _: tp.pid_ref, m: tp.message) tp.result {
     const editor = self.get_active_editor() orelse return;
     var sel: ed.Selection = undefined;