Merge branch 'master' into personal

Author: ivanjermakov

README.md

@@ -65,9 +65,6 @@ Hat is a **ha**ckable modal **t**ext editor for modern terminals.
 
 ## Philosophy
 
-Based on [suckless](https://suckless.org/philosophy/) and
-[unix](https://en.wikipedia.org/wiki/Unix_philosophy) philosophies.
-
 Software is:
 - doing not more and not less than what the user needs
     * Every feature is implemented in the most simple and straightforward form: keep it simple, fast, and clear
@@ -78,10 +75,12 @@ Software is:
 - distributed as source code, compiled by the user
 - not meant to be developed forever and its final state should be described by its feature set from
 the beginning
-- extended either by the user directly or by applying
-[source code patches](https://en.wikipedia.org/wiki/Patch_(computing)#Source_code_patching), distributed as diff files
+- extended either by the user directly, or by applying [source code patches](https://en.wikipedia.org/wiki/Patch_(computing)#Source_code_patching)
+distributed as diff files
     * It is encouraged to share your extensions with others who can find it useful
 
+See [Hackable software](http://blog.ivnj.org/post/hackable-software.html) for details.
+
 ## Build, install, usage, configuration
 
 See [`HACKING.md`](HACKING.md).

src/color.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const lsp = @import("lsp");
 
 pub const RgbColor = struct {
     r: u8,
@@ -46,7 +47,7 @@ pub const AnsiColor = enum(u8) {
     }
 };
 
-pub const Color = struct {
+pub const color = struct {
     pub const black = RgbColor.fromHex(0x000000);
     pub const gray1 = RgbColor.fromHex(0x1b1b1d);
     pub const gray2 = RgbColor.fromHex(0x2a2a2d);
@@ -63,14 +64,14 @@ pub const Color = struct {
     pub const magenta = RgbColor.fromHex(0xd3a8ef);
 };
 
-pub const Attr = union(enum) {
+pub const Attribute = union(enum) {
     fg: RgbColor,
     bg: RgbColor,
     underline: RgbColor,
     curly_underline,
     bold,
 
-    pub fn write(self: Attr, writer: *std.io.Writer) !void {
+    pub fn write(self: Attribute, writer: *std.io.Writer) !void {
         switch (self) {
             .fg => |c| try writer.print("\x1b[38;2;{};{};{}m", .{ c.r, c.g, c.b }),
             .bg => |c| try writer.print("\x1b[48;2;{};{};{}m", .{ c.r, c.g, c.b }),
@@ -79,31 +80,41 @@ pub const Attr = union(enum) {
             .bold => _ = try writer.write("\x1b[1m"),
         }
     }
-};
 
-pub const Attributes = struct {
-    pub const text = &[_]Attr{.{ .fg = Color.white }};
-    pub const selection = &[_]Attr{.{ .bg = Color.gray3 }};
-    pub const selection_normal = &[_]Attr{.{ .bg = Color.gray2 }};
-    pub const highlight = &[_]Attr{.{ .bg = Color.gray3 }};
-    pub const keyword = &[_]Attr{.{ .fg = Color.magenta }};
-    pub const string = &[_]Attr{.{ .fg = Color.green }};
-    pub const literal = &[_]Attr{.{ .fg = Color.yellow }};
-    pub const comment = &[_]Attr{.{ .fg = Color.gray7 }};
-    pub const diagnostic_error = &[_]Attr{ .curly_underline, .{ .underline = Color.red } };
-    pub const completion_menu = &[_]Attr{.{ .bg = Color.gray2 }};
-    pub const completion_menu_active = &[_]Attr{.{ .bg = Color.gray4 }};
-    pub const overlay = &[_]Attr{.{ .bg = Color.gray2 }};
-    pub const message = &[_]Attr{.{ .bg = Color.gray2 }};
-    pub const command_line = &[_]Attr{.{ .bg = Color.gray2 }};
-    pub const number_line = &[_]Attr{.{ .fg = Color.gray4 }};
-    pub const git_added = &[_]Attr{ .{ .fg = Color.green }, .bold };
-    pub const git_modified = &[_]Attr{ .{ .fg = Color.yellow }, .bold };
-    pub const git_deleted = &[_]Attr{ .{ .fg = Color.red }, .bold };
+    pub const text = &[_]Attribute{.{ .fg = color.white }};
+    pub const selection = &[_]Attribute{.{ .bg = color.gray3 }};
+    pub const selection_normal = &[_]Attribute{.{ .bg = color.gray2 }};
+    pub const highlight = &[_]Attribute{.{ .bg = color.gray3 }};
+    pub const keyword = &[_]Attribute{.{ .fg = color.magenta }};
+    pub const string = &[_]Attribute{.{ .fg = color.green }};
+    pub const literal = &[_]Attribute{.{ .fg = color.yellow }};
+    pub const comment = &[_]Attribute{.{ .fg = color.gray7 }};
+    pub const completion_menu = &[_]Attribute{.{ .bg = color.gray2 }};
+    pub const completion_menu_active = &[_]Attribute{.{ .bg = color.gray4 }};
+    pub const overlay = &[_]Attribute{.{ .bg = color.gray2 }};
+    pub const message = &[_]Attribute{.{ .bg = color.gray2 }};
+    pub const command_line = &[_]Attribute{.{ .bg = color.gray2 }};
+    pub const number_line = &[_]Attribute{.{ .fg = color.gray4 }};
+    pub const git_added = &[_]Attribute{ .{ .fg = color.green }, .bold };
+    pub const git_modified = &[_]Attribute{ .{ .fg = color.yellow }, .bold };
+    pub const git_deleted = &[_]Attribute{ .{ .fg = color.red }, .bold };
+    pub const diagnostic_error = &[_]Attribute{ .curly_underline, .{ .underline = color.red } };
+    pub const diagnostic_warn = &[_]Attribute{ .curly_underline, .{ .underline = color.yellow } };
+    pub const diagnostic_info = &[_]Attribute{ .curly_underline, .{ .underline = color.magenta } };
+    pub const diagnostic_hint = &[_]Attribute{.{ .fg = color.gray6 }};
 
-    pub fn write(attrs: []const Attr, writer: *std.io.Writer) !void {
+    pub fn writeSlice(attrs: []const Attribute, writer: *std.io.Writer) !void {
         for (attrs) |attr| {
             try attr.write(writer);
         }
     }
+
+    pub fn diagnosticSeverity(severity: lsp.types.DiagnosticSeverity) []const Attribute {
+        return switch (severity) {
+            .Warning => diagnostic_warn,
+            .Information => diagnostic_info,
+            .Hint => diagnostic_hint,
+            else => diagnostic_error,
+        };
+    }
 };

src/lsp.zig

@@ -103,7 +103,7 @@ pub const LspConnection = struct {
     stdin_buf: [2 << 12]u8 = undefined,
     stdin_writer: std.fs.File.Writer,
     /// Updates left for connection to terminate until forced termination
-    wait_fuel: usize = 30,
+    wait_fuel: usize = 10,
     allocator: Allocator,
 
     pub fn connect(allocator: Allocator, config: LspConfig) !LspConnection {
@@ -702,7 +702,9 @@ pub const LspConnection = struct {
         if (main.editor.findBufferByUri(params_typed.value.uri)) |buffer| {
             buffer.clearDiagnostics();
             for (params_typed.value.diagnostics) |diagnostic| {
-                try buffer.diagnostics.append(self.allocator, try dia.Diagnostic.fromLsp(buffer.allocator, diagnostic));
+                var d = try dia.Diagnostic.fromLsp(buffer.allocator, diagnostic);
+                if (std.meta.eql(d.span.start, d.span.end)) d.span.end.col += 1;
+                try buffer.diagnostics.append(self.allocator, d);
             }
             std.mem.sort(dia.Diagnostic, buffer.diagnostics.items, {}, dia.Diagnostic.lessThan);
             log.debug(@This(), "got {} diagnostics\n", .{buffer.diagnostics.items.len});

src/printer.zig

@@ -62,22 +62,22 @@ pub fn printBuffer(buffer: *buf.Buffer, writer: *std.io.Writer, highlight: ?High
             if (buffer.ts_state) |ts_state| {
                 if (ts_state.highlight) |hi| {
                     const highlight_spans = hi.spans.items;
-                    const ch_attrs: []const co.Attr = b: while (span_index < highlight_spans.len) {
+                    const ch_attrs: []const co.Attribute = b: while (span_index < highlight_spans.len) {
                         const span = highlight_spans[span_index];
-                        if (span.span.start > byte) break :b co.Attributes.text;
+                        if (span.span.start > byte) break :b co.Attribute.text;
                         if (byte >= span.span.start and byte < span.span.end) {
                             break :b span.attrs;
                         }
                         span_index += 1;
                     } else {
-                        break :b co.Attributes.text;
+                        break :b co.Attribute.text;
                     };
-                    try co.Attributes.write(ch_attrs, &attrs_writer);
+                    try co.Attribute.writeSlice(ch_attrs, &attrs_writer);
                 }
             }
 
             const hi_line = highlight != null and row == highlight.?.highlight_line;
-            if (hi_line) try co.Attributes.write(co.Attributes.selection, &attrs_writer);
+            if (hi_line) try co.Attribute.writeSlice(co.Attribute.selection, &attrs_writer);
 
             attrs = attrs_writer.buffered();
             if (last_attrs == null or !std.mem.eql(u8, attrs, last_attrs.?)) {

src/signal.zig

@@ -4,7 +4,10 @@ const log = @import("log.zig");
 const main = @import("main.zig");
 const ter = @import("terminal.zig");
 
-pub const SigHandle = struct { sig: u8, handle: std.posix.Sigaction.handler_fn };
+pub const SigHandle = struct {
+    sig: u8,
+    handle: std.posix.Sigaction.handler_fn,
+};
 
 pub const sig_handle = .{
     .int = SigHandle{ .sig = std.posix.SIG.INT, .handle = handleSigInt },

src/terminal.zig

@@ -127,7 +127,7 @@ pub const Terminal = struct {
         try self.writer.writeAll(if (enable) "\x1b[?7h" else "\x1b[?7l");
     }
 
-    fn resetAttributes(self: *Terminal) !void {
+    fn resetAttribute(self: *Terminal) !void {
         try self.writer.writeAll("\x1b[0m");
     }
 
@@ -140,8 +140,8 @@ pub const Terminal = struct {
     }
 
     fn drawNumberLine(self: *Terminal, buffer: *buf.Buffer, area: Area) !void {
-        try co.Attributes.write(co.Attributes.number_line, self.writer);
-        defer self.resetAttributes() catch {};
+        try co.Attribute.writeSlice(co.Attribute.number_line, self.writer);
+        defer self.resetAttribute() catch {};
         const cursor_row = buffer.cursor.row;
         for (@intCast(area.pos.row)..@as(usize, @intCast(area.pos.row)) + area.dims.height) |term_row| {
             const buffer_row = @as(i32, @intCast(term_row)) + buffer.offset.row;
@@ -194,15 +194,15 @@ pub const Terminal = struct {
                     try self.moveCursor(.{ .row = @intCast(term_row), .col = area.pos.col });
                     switch (hunk.type) {
                         .add => {
-                            try co.Attributes.write(co.Attributes.git_added, self.writer);
+                            try co.Attribute.writeSlice(co.Attribute.git_added, self.writer);
                             try self.writer.writeAll("┃");
                         },
                         .delete => {
-                            try co.Attributes.write(co.Attributes.git_deleted, self.writer);
+                            try co.Attribute.writeSlice(co.Attribute.git_deleted, self.writer);
                             try self.writer.writeAll("▁");
                         },
                         .modify => {
-                            try co.Attributes.write(co.Attributes.git_modified, self.writer);
+                            try co.Attribute.writeSlice(co.Attribute.git_modified, self.writer);
                             try self.writer.writeAll("┃");
                         },
                     }
@@ -252,30 +252,30 @@ pub const Terminal = struct {
                 if (buffer.ts_state) |ts_state| {
                     if (ts_state.highlight) |hi| {
                         const highlight_spans = hi.spans.items;
-                        const ch_attrs: []const co.Attr = b: while (span_index < highlight_spans.len) {
+                        const ch_attrs: []const co.Attribute = b: while (span_index < highlight_spans.len) {
                             const span = highlight_spans[span_index];
-                            if (span.span.start > byte) break :b co.Attributes.text;
+                            if (span.span.start > byte) break :b co.Attribute.text;
                             if (byte >= span.span.start and byte < span.span.end) {
                                 break :b span.attrs;
                             }
                             span_index += 1;
                         } else {
-                            break :b co.Attributes.text;
+                            break :b co.Attribute.text;
                         };
-                        try co.Attributes.write(ch_attrs, &attrs_writer);
+                        try co.Attribute.writeSlice(ch_attrs, &attrs_writer);
                     }
                 }
 
                 if (buffer.selection) |selection| {
                     if (selection.inRange(.{ .row = buffer_row, .col = buffer_col })) {
-                        const attr = if (buffer.mode.isSelect()) co.Attributes.selection else co.Attributes.selection_normal;
-                        try co.Attributes.write(attr, &attrs_writer);
+                        const attr = if (buffer.mode.isSelect()) co.Attribute.selection else co.Attribute.selection_normal;
+                        try co.Attribute.writeSlice(attr, &attrs_writer);
                     }
                 } else {
                     if (buffer.mode == .normal) {
                         for (buffer.highlights.items) |hi| {
                             if (hi.inRange(.{ .row = buffer_row, .col = buffer_col })) {
-                                try co.Attributes.write(co.Attributes.highlight, &attrs_writer);
+                                try co.Attribute.writeSlice(co.Attribute.highlight, &attrs_writer);
                             }
                         }
                     }
@@ -286,15 +286,15 @@ pub const Terminal = struct {
                         const span = diagnostic.span;
 
                         if (span.inRange(.{ .row = buffer_row, .col = buffer_col })) {
-                            try co.Attributes.write(co.Attributes.diagnostic_error, &attrs_writer);
+                            try co.Attribute.writeSlice(co.Attribute.diagnosticSeverity(diagnostic.severity), &attrs_writer);
                             break;
                         }
                     }
                 }
 
                 attrs = attrs_writer.buffered();
                 if (last_attrs == null or !std.mem.eql(u8, attrs, last_attrs.?)) {
-                    self.resetAttributes() catch {};
+                    self.resetAttribute() catch {};
                     try self.writer.writeAll(attrs);
                     @memcpy(&last_attrs_buf, &attrs_buf);
                     last_attrs = last_attrs_buf[0..attrs.len];
@@ -308,7 +308,7 @@ pub const Terminal = struct {
                 if (col_width > 1) try self.moveCursor(.{ .row = @intCast(term_row), .col = area.pos.col + area_col });
             }
             // reached line end
-            try self.resetAttributes();
+            try self.resetAttribute();
             last_attrs = null;
         }
     }
@@ -337,7 +337,7 @@ pub const Terminal = struct {
         const menu_width = @min(max_width, longest_item + 1);
 
         {
-            try self.resetAttributes();
+            try self.resetAttribute();
 
             for (0..cmp_menu.display_items.items.len) |menu_row| {
                 const idx = cmp_menu.display_items.items[menu_row];
@@ -347,9 +347,9 @@ pub const Terminal = struct {
                     .col = menu_pos.col,
                 });
                 if (menu_row == cmp_menu.active_item) {
-                    try co.Attributes.write(co.Attributes.completion_menu_active, self.writer);
+                    try co.Attribute.writeSlice(co.Attribute.completion_menu_active, self.writer);
                 } else {
-                    try co.Attributes.write(co.Attributes.completion_menu, self.writer);
+                    try co.Attribute.writeSlice(co.Attribute.completion_menu, self.writer);
                 }
                 try self.writer.writeAll(cmp_item.label[0..@min(cmp_item.label.len, menu_width)]);
 
@@ -360,7 +360,7 @@ pub const Terminal = struct {
                     }
                 }
             }
-            try self.resetAttributes();
+            try self.resetAttribute();
         }
 
         {
@@ -436,8 +436,8 @@ pub const Terminal = struct {
     /// Draw a box on top of the editor's content, containing `lines`
     /// Box width is min(longest line, available area)
     fn drawOverlay(self: *Terminal, lines: []const []const u8, pos: Cursor) !void {
-        try co.Attributes.write(co.Attributes.overlay, self.writer);
-        defer self.resetAttributes() catch {};
+        try co.Attribute.writeSlice(co.Attribute.overlay, self.writer);
+        defer self.resetAttribute() catch {};
 
         const max_doc_width = 90;
         var longest_line: usize = 0;
@@ -466,21 +466,21 @@ pub const Terminal = struct {
         const message = main.editor.messages.items[main.editor.message_read_idx];
         const message_height = std.mem.count(u8, message, "\n") + 1;
         try self.moveCursor(.{ .row = @intCast(self.dimensions.height - message_height) });
-        try co.Attributes.write(co.Attributes.message, self.writer);
+        try co.Attribute.writeSlice(co.Attribute.message, self.writer);
         try self.writer.writeAll(message);
-        try self.resetAttributes();
+        try self.resetAttribute();
     }
 
     fn drawCmd(self: *Terminal, command_line: *const cmd.CommandLine) !void {
         const last_row = self.dimensions.height - 1;
         const prefix = command_line.command.?.prefix();
         try self.moveCursor(.{ .row = @intCast(last_row) });
-        try co.Attributes.write(co.Attributes.command_line, self.writer);
+        try co.Attribute.writeSlice(co.Attribute.command_line, self.writer);
         try self.writer.writeAll(prefix);
         for (command_line.content.items) |ch| {
             try uni.unicodeToBytesWrite(self.writer, &.{ch});
         }
-        try self.resetAttributes();
+        try self.resetAttribute();
         try self.moveCursor(.{ .row = @intCast(last_row), .col = @intCast(prefix.len + command_line.cursor) });
     }
 };

src/ts.zig

@@ -169,7 +169,7 @@ pub const State = struct {
 
 pub const AttrsSpan = struct {
     span: SpanFlat,
-    attrs: []const col.Attr,
+    attrs: []const col.Attribute,
 
     /// Capture name is a dot-separated list of ts node types, forming hierarchy, e.g. `identifier.type`
     /// @see https://tree-sitter.github.io/tree-sitter/using-parsers/queries/2-operators.html#capturing-nodes
@@ -185,7 +185,7 @@ pub const AttrsSpan = struct {
     ///   * check `identifier.type`
     ///   * check `identifier`
     ///   * null
-    pub fn findAttrs(capture_name: []const u8) ?[]const col.Attr {
+    pub fn findAttrs(capture_name: []const u8) ?[]const col.Attribute {
         if (node_highlights_exact.get(capture_name)) |a| return a;
         if (node_highlights.get(capture_name)) |a| return a;
         if (!std.mem.containsAtLeastScalar(u8, capture_name, 1, '.')) return null;
@@ -201,16 +201,16 @@ pub const AttrsSpan = struct {
     }
 };
 
-pub const node_highlights = std.StaticStringMap([]const col.Attr).initComptime(.{
-    .{ "keyword", col.Attributes.keyword },
-    .{ "string", col.Attributes.string },
-    .{ "number", col.Attributes.literal },
-    .{ "boolean", col.Attributes.literal },
-    .{ "comment", col.Attributes.comment },
+pub const node_highlights = std.StaticStringMap([]const col.Attribute).initComptime(.{
+    .{ "keyword", col.Attribute.keyword },
+    .{ "string", col.Attribute.string },
+    .{ "number", col.Attribute.literal },
+    .{ "boolean", col.Attribute.literal },
+    .{ "comment", col.Attribute.comment },
 });
 
-pub const node_highlights_exact = std.StaticStringMap([]const col.Attr).initComptime(.{
-    .{ "tag", col.Attributes.keyword },
+pub const node_highlights_exact = std.StaticStringMap([]const col.Attribute).initComptime(.{
+    .{ "tag", col.Attribute.keyword },
 });
 
 pub fn firstSmallestDescendentInSpan(node: ts.TSNode, span: SpanFlat) ?ts.TSNode {