Merge branch 'master' into relative-number

Author: ivanjermakov

patch/auto-indent/README.md

@@ -4,14 +4,14 @@ Tree-sitter powered insert mode auto-indenting.
 
 Adds editor options:
 
-- `.indent_newline`: auto-indent inserted newline
-- `.reindent_block_end`: reindent current line upon insertion of one of `reindent_block_end_chars`
+- `indent_newline`: auto-indent inserted newline
+- `reindent_block_end_chars`: reindent current line upon insertion of one of these chars
 
 ## Usage
 
-Configure auto-indent fields in `config` in `editor.zig`:
+Configure auto-indent fields in `Config` in `editor.zig`:
 
 ```zig
-.indent_newline = true,
-.reindent_block_end = true,
+pub const indent_newline: bool = true;
+pub const reindent_block_end_chars: ?[]const u21 = &.{ '}', ']', ')' };
 ```

patch/auto-indent/auto-indent.diff

@@ -1,18 +1,121 @@
 diff --git a/src/buffer.zig b/src/buffer.zig
-index 5b1c666..249c012 100644
+index f3c72f9..92ff3eb 100644
 --- a/src/buffer.zig
 +++ b/src/buffer.zig
-@@ -534,6 +534,23 @@ pub const Buffer = struct {
-         }
+@@ -564,62 +564,87 @@ pub const Buffer = struct {
+         log.trace(@This(), "line byte positions: {any}\n", .{self.line_positions.items});
      }
 
+-    pub fn updateIndents(self: *Buffer) FatalError!void {
+-        if (self.ts_state == null or self.ts_state.?.indent == null) return;
+-        try self.reparse();
+-
+-        self.indents.clearRetainingCapacity();
+-        for (0..self.line_byte_positions.items.len) |row| {
+-            try self.indents.append(self.allocator, try self.lineIndent(row));
+-        }
+-        log.debug(@This(), "indents: {any}\n", .{self.indents.items});
+-    }
+-
+     pub fn lineIndent(self: *Buffer, row: usize) FatalError!usize {
+         const ts_state = if (self.ts_state) |ts_state| ts_state else return 0;
+         const query = ts_state.indent orelse return 0;
+-        if (self.lineLength(row) == 0 and row > 0) return self.lineIndent(row - 1);
+         const root_node = ts.ts.ts_tree_root_node(ts_state.tree);
+ 
+         const line_span = SpanFlat{
+             .start = if (row == 0) 0 else self.line_byte_positions.items[row - 1],
+             .end = self.line_byte_positions.items[row],
+         };
+-        if (ts.firstSmallestDescendentInSpan(root_node, line_span)) |node| {
+-            log.trace(@This(), "line {} {}\n", .{ row + 1, line_span });
+-            var n = node;
+-            var indent: i32 = 0;
+-            var processed_rows = std.AutoHashMap(usize, void).init(self.allocator);
+-            defer processed_rows.deinit();
+-            while (!ts.ts.ts_node_is_null(n)) {
+-                const span = SpanFlat{
+-                    .start = ts.ts.ts_node_start_byte(n),
+-                    .end = ts.ts.ts_node_end_byte(n),
+-                };
+-                log.trace(@This(), "node {}\n", .{span});
+-                if (query.captures.get(@intFromPtr(n.id))) |cap| c: {
+-                    const pos = Span.fromSpanFlat(self, span);
++        log.trace(@This(), "indent line {} {}\n", .{ row + 1, line_span });
+ 
++        var n: ?ts.ts.TSNode = null;
++        if (line_span.start > 2 and self.lineLength(row) == 0) {
++            // assumes no trailing spaces on prev line
++            const prev_line_end_span = SpanFlat{ .start = line_span.start - 2, .end = line_span.start - 1 };
++            n = ts.firstSmallestDescendentInSpan(root_node, prev_line_end_span);
++            if (n) |n_| {
++                if (query.captures.get(@intFromPtr(n_.id))) |cap| {
+                     var capture_name_len: u32 = undefined;
+                     const capture_name_buf = ts.ts.ts_query_capture_name_for_id(query.query.?, cap.index, &capture_name_len);
+                     const capture_name = capture_name_buf[0..capture_name_len];
+-                    log.trace(@This(), "capture {s} [{}-{}]\n", .{ capture_name, span.start, span.end });
+-
+-                    if (processed_rows.contains(@intCast(pos.start.row))) break :c;
+-                    if (pos.start.row != pos.end.row and pos.start.row != row and std.mem.eql(u8, capture_name, "indent.begin")) {
+-                        indent += 1;
+-                        try processed_rows.put(@intCast(pos.start.row), {});
+-                    } else if (std.mem.eql(u8, capture_name, "indent.end") or std.mem.eql(u8, capture_name, "indent.branch")) {
+-                        indent -= 1;
++                    if (std.mem.eql(u8, capture_name, "indent.end") or std.mem.eql(u8, capture_name, "indent.branch")) {
++                        n = ts.firstSmallestDescendentInSpan(root_node, line_span);
+                     }
+                 }
+-                n = ts.ts.ts_node_parent(n);
+             }
+-            return if (indent < 0) 0 else @intCast(indent);
+         } else {
+-            log.trace(@This(), "line {}[{}-{}] no node\n", .{ row + 1, line_span.start, line_span.end });
++            n = ts.firstSmallestDescendentInSpan(root_node, line_span);
++        }
++        if (n == null) {
++            log.warn(@This(), "no node\n", .{});
+             return 0;
+         }
++        var node = n.?;
++        const indent_row: usize = @intCast(self.posToCursor(ts.ts.ts_node_start_byte(node)).row);
++
++        var indent: i32 = 0;
++        var processed_rows = std.AutoHashMap(usize, void).init(self.allocator);
++        defer processed_rows.deinit();
++        while (!ts.ts.ts_node_is_null(node)) {
++            const span = SpanFlat{
++                .start = ts.ts.ts_node_start_byte(node),
++                .end = ts.ts.ts_node_end_byte(node),
++            };
++            log.trace(@This(), "node {}\n", .{span});
++            if (query.captures.get(@intFromPtr(node.id))) |cap| c: {
++                const pos = Span.fromSpanFlat(self, span);
++
++                var capture_name_len: u32 = undefined;
++                const capture_name_buf = ts.ts.ts_query_capture_name_for_id(query.query.?, cap.index, &capture_name_len);
++                const capture_name = capture_name_buf[0..capture_name_len];
++                log.trace(@This(), "capture {s} [{}-{}]\n", .{ capture_name, span.start, span.end });
++
++                if (processed_rows.contains(@intCast(pos.start.row))) break :c;
++                if (pos.start.row != pos.end.row and pos.start.row != indent_row and std.mem.eql(u8, capture_name, "indent.begin")) {
++                    indent += 1;
++                    try processed_rows.put(@intCast(pos.start.row), {});
++                } else if (std.mem.eql(u8, capture_name, "indent.end") or std.mem.eql(u8, capture_name, "indent.branch")) {
++                    indent -= 1;
++                }
++            }
++            node = ts.ts.ts_node_parent(node);
++        }
++        return if (indent < 0) 0 else @intCast(indent);
++    }
++
 +    pub fn indentEmptyLine(self: *Buffer) FatalError!void {
 +        if (self.ts_state == null) return;
 +        std.debug.assert(self.cursor.col == 0);
++        try self.reparse();
 +        if (self.lineLength(@intCast(self.cursor.row)) != 0) return;
-+        try self.updateIndents();
 +
-+        const correct_indent: usize = self.indents.items[@intCast(self.cursor.row)];
++        const correct_indent: usize = try self.lineIndent(@intCast(self.cursor.row));
 +        const correct_indent_spaces = correct_indent * self.file_type.indent_spaces;
 +        if (correct_indent_spaces > 0) {
 +            const indent_text = try self.allocator.alloc(u21, correct_indent_spaces);
@@ -21,50 +124,38 @@ index 5b1c666..249c012 100644
 +            var indent_change = try cha.Change.initInsert(self.allocator, self, self.cursor, indent_text);
 +            try self.appendChange(&indent_change);
 +        }
-+    }
-+
+     }
+ 
      pub fn undo(self: *Buffer) !void {
-         log.debug(@This(), "undo: {?}/{}\n", .{ self.history_index, self.history.items.len });
-         if (self.history_index) |h_idx| {
 diff --git a/src/editor.zig b/src/editor.zig
-index 9e47642..b7d7987 100644
+index 8986a02..eaa0bf0 100644
 --- a/src/editor.zig
 +++ b/src/editor.zig
-@@ -19,12 +19,20 @@ const ur = @import("uri.zig");
- 
- pub const config = Config{
-     .end_of_buffer_char = null,
-+    .indent_newline = false,
-+    .reindent_block_end = false,
- };
- 
- pub const Config = struct {
-     /// Char to denote terminal lines after end of buffer
-     /// See vim's :h fillchars -> eob
-     end_of_buffer_char: ?u8,
+@@ -24,6 +24,10 @@ pub const Config = struct {
+     /// Attempt to find matching pair when cursor is over one of these [start, end] chars
+     /// If start == end, will only check forward until first encountered match
+     pub const matching_pair_chars: ?[]const [2]u21 = &.{ .{ '{', '}' }, .{ '[', ']' }, .{ '(', ')' }, .{ '<', '>' }, .{ '|', '|' } };
 +    /// In buffers with TS indent support, autoindent inserted newline
-+    indent_newline: bool,
-+    /// In buffers with TS indent support, reindent current line upon insertion of one of `reindent_block_end_chars`
-+    reindent_block_end: bool,
-+
-+    pub const reindent_block_end_chars: []const u21 = &.{ '}', ']', ')' };
++    pub const indent_newline: bool = false;
++    /// In buffers with TS indent support, reindent current line upon insertion of one of these chars
++    pub const reindent_block_end_chars: ?[]const u21 = null;
  };
 
  pub const Dirty = struct {
 diff --git a/src/main.zig b/src/main.zig
-index bab23db..281d62b 100644
+index d117195..44b359a 100644
 --- a/src/main.zig
 +++ b/src/main.zig
-@@ -216,6 +216,17 @@ pub fn startEditor(allocator: std.mem.Allocator) FatalError!void {
+@@ -220,6 +220,17 @@ pub fn startEditor(allocator: std.mem.Allocator) FatalError!void {
                          if (next_key != null and next_key.?.printable != null) {
                              try printable.append(allocator, next_key.?.printable.?);
                              keys_consumed += 1;
-+                            if (edi.config.indent_newline and keys_consumed == 1 and next_key.?.printable == '\n') {
++                            if (edi.Config.indent_newline and keys_consumed == 1 and next_key.?.printable == '\n') {
 +                                try buffer.changeInsertText(try printable.toOwnedSlice(allocator));
 +                                try buffer.indentEmptyLine();
 +                            }
-+                            if (edi.config.reindent_block_end and
-+                                std.mem.containsAtLeastScalar(u21, edi.Config.reindent_block_end_chars, 1, next_key.?.printable.?))
++                            if (edi.Config.reindent_block_end_chars != null and
++                                std.mem.containsAtLeastScalar(u21, edi.Config.reindent_block_end_chars.?, 1, next_key.?.printable.?))
 +                            {
 +                                try buffer.changeInsertText(try printable.toOwnedSlice(allocator));
 +                                log.warn(@This(), "align!!!\n", .{});
@@ -73,13 +164,26 @@ index bab23db..281d62b 100644
                          } else {
                              break;
                          }
-@@ -359,6 +370,9 @@ pub fn startEditor(allocator: std.mem.Allocator) FatalError!void {
+@@ -427,6 +438,9 @@ pub fn startEditor(allocator: std.mem.Allocator) FatalError!void {
                      var change = try cha.Change.initInsert(allocator, buffer, pos, &.{'\n'});
                      try buffer.appendChange(&change);
                      if (!below) buffer.moveCursor(.{ .row = row });
-+                    if (edi.config.indent_newline) {
++                    if (edi.Config.indent_newline) {
 +                        try buffer.indentEmptyLine();
 +                    }
                  } else if (buffer.mode == .normal and eql(u8, key, "J")) {
                      for (0..@intCast(repeat_or_1)) |_| {
                          if (buffer.cursor.row + 1 < buffer.line_positions.items.len) {
+diff --git a/src/ts.zig b/src/ts.zig
+index a7de638..bfd6d5e 100644
+--- a/src/ts.zig
++++ b/src/ts.zig
+@@ -213,7 +213,7 @@ pub fn firstSmallestDescendentInSpan(node: ts.TSNode, span: SpanFlat) ?ts.TSNode
+ 
+     if (node_end < span.start) return null;
+     const child_count = ts.ts_node_child_count(node);
+-    if (child_count == 0 and node_start >= span.start and node_end <= span.end) return node;
++    if (child_count == 0 and node_start >= span.start) return node;
+ 
+     for (0..child_count) |child_idx| {
+         const child_candidate = ts.ts_node_child(node, @intCast(child_idx));

patch/autosave/README.md

@@ -1,13 +1,13 @@
 # Autosave
 
-Adds editor option `.autosave`.
+Adds editor option `autosave`.
 
 When enabled, every `Buffer.commitChanges` will be followed by write to disk.
 
 ## Usage
 
-Configure autosave fields in `config` in `editor.zig`:
+Configure autosave fields in `Config` in `editor.zig`:
 
 ```zig
-.autosave = true,
+pub const autosave: bool = true;
 ```

patch/autosave/autosave.diff

@@ -1,8 +1,8 @@
 diff --git a/src/buffer.zig b/src/buffer.zig
-index 5b1c666..d0d94e1 100644
+index f3c72f9..1d100d8 100644
 --- a/src/buffer.zig
 +++ b/src/buffer.zig
-@@ -223,14 +223,6 @@ pub const Buffer = struct {
+@@ -241,14 +241,6 @@ pub const Buffer = struct {
          _ = try self.syncFs();
 
          self.file_history_index = self.history_index;
@@ -17,58 +17,51 @@ index 5b1c666..d0d94e1 100644
      }
 
      pub fn moveCursor(self: *Buffer, new_cursor: Cursor) void {
-@@ -428,6 +420,11 @@ pub const Buffer = struct {
+@@ -498,6 +490,11 @@ pub const Buffer = struct {
          self.history_index = self.history.items.len - 1;
 
          main.editor.dotRepeatCommitReady();
 +
-+        if (edi.config.autosave) {
++        if (edi.Config.autosave) {
 +            log.debug(@This(), "autosave {s}\n", .{self.path});
 +            self.write() catch |e| log.err(@This(), "write buffer error: {}", .{e});
 +        }
      }
 
      pub fn changeInsertText(self: *Buffer, text: []const u21) FatalError!void {
-@@ -546,6 +543,11 @@ pub const Buffer = struct {
+@@ -634,6 +631,11 @@ pub const Buffer = struct {
                  self.moveCursor(inv_change.new_span.?.start);
              }
              self.history_index = if (h_idx > 0) h_idx - 1 else null;
 +
-+            if (edi.config.autosave) {
++            if (edi.Config.autosave) {
 +                self.write() catch |e| log.err(@This(), "write buffer error: {}", .{e});
 +                log.debug(@This(), "autosave {s}\n", .{self.path});
 +            }
          }
      }
 
-@@ -561,6 +563,11 @@ pub const Buffer = struct {
+@@ -649,6 +651,11 @@ pub const Buffer = struct {
              self.moveCursor(change.new_span.?.start);
          }
          self.history_index = redo_idx;
 +
-+        if (edi.config.autosave) {
++        if (edi.Config.autosave) {
 +            self.write() catch |e| log.err(@This(), "write buffer error: {}", .{e});
 +            log.debug(@This(), "autosave {s}\n", .{self.path});
 +        }
      }
 
      pub fn textAt(self: *const Buffer, span: Span) []const u21 {
 diff --git a/src/editor.zig b/src/editor.zig
-index 9e47642..cfa00fa 100644
+index 8986a02..8d412aa 100644
 --- a/src/editor.zig
 +++ b/src/editor.zig
-@@ -19,12 +19,14 @@ const ur = @import("uri.zig");
- 
- pub const config = Config{
-     .end_of_buffer_char = null,
-+    .autosave = false,
- };
- 
- pub const Config = struct {
-     /// Char to denote terminal lines after end of buffer
-     /// See vim's :h fillchars -> eob
-     end_of_buffer_char: ?u8,
-+    autosave: bool,
+@@ -24,6 +24,7 @@ pub const Config = struct {
+     /// Attempt to find matching pair when cursor is over one of these [start, end] chars
+     /// If start == end, will only check forward until first encountered match
+     pub const matching_pair_chars: ?[]const [2]u21 = &.{ .{ '{', '}' }, .{ '[', ']' }, .{ '(', ')' }, .{ '<', '>' }, .{ '|', '|' } };
++    pub const autosave: bool = false;
  };
 
  pub const Dirty = struct {

patch/buffer-centering/README.md

@@ -1,17 +1,17 @@
 # Buffer centering
 
-Adds editor option `.centering_width`
+Adds editor option `centering_width`
 
-* `.centering_width = N` means that the buffer will be left padded, so that line with N width is horizontally
+* `centering_width = N` means that the buffer will be left padded, so that line with N width is horizontally
 centered within the terminal
-* `.centering_width = null` means do not pad, default behavior
+* `centering_width = null` means do not pad, default behavior
 
 ## Usage
 
-Configure fields in `config` in `editor.zig`:
+Configure fields in `Config` in `editor.zig`:
 
 ```zig
-.centering_width = 140,
+pub const centering_width: ?usize = 140;
 ```
 
 ## Screenshots