add some language feature basics, including zig format-on-save

src/libfn/Editor.zig

···
 const IndexPos = @import("indexpos.zig").IndexPos;
 const Range = @import("Range.zig");
 const Selection = @import("Selection.zig");
+const Language = @import("Language.zig");
+const Zig = @import("languages/Zig.zig");
 
 const Allocator = std.mem.Allocator;
 
···
 /// An array tracking all of the selections in the editor. **Modifying this will cause undefined
 /// behavior**. Use the methods on the editor to manipulate the selections instead.
 selections: std.ArrayListUnmanaged(Selection),
+/// Adds language support features when present.
+language: ?Language = null,
 
 pub const Command = union(enum) {
     /// Adds a new cursor at the given position.
···
     const file = try std.fs.cwd().createFile(filename, .{ .read = true, .truncate = false });
     defer file.close();
 
-    // 3. Get a reader to read the file.
+    self.text.clearAndFree(allocator);
 
-    var buffer: [1024]u8 = undefined;
-    var file_reader = file.reader(&buffer);
-    var reader = &file_reader.interface;
+    if (try file.getEndPos() > 0) {
+        // 3. Get a reader to read the file.
 
-    // 4. Read the file and store in state.
+        var buffer: [1024]u8 = undefined;
+        var file_reader = file.reader(&buffer);
+        var reader = &file_reader.interface;
 
-    self.text.clearAndFree(allocator);
+        // 4. Read the file and store in state.
 
-    var writer: std.Io.Writer.Allocating = .fromArrayList(allocator, &self.text);
-    defer writer.deinit();
+        var writer: std.Io.Writer.Allocating = .fromArrayList(allocator, &self.text);
+        defer writer.deinit();
 
-    // Stream from file to the text array list.
-    _ = try reader.stream(&writer.writer, .unlimited);
-    try writer.writer.flush();
-    self.text = writer.toArrayList();
+        // Stream from file to the text array list.
+        _ = try reader.stream(&writer.writer, .unlimited);
+        try writer.writer.flush();
+        self.text = writer.toArrayList();
+    }
 
     // 5. Only after the file has been successfully read do we update file name and other state.
 
···
     // 7. Tokenize the new text.
 
     try self.tokenize(allocator);
+
+    // 8. Initialize a language, if we have an implementation for it.
+
+    if (std.mem.eql(u8, std.fs.path.extension(self.filename.items), ".zig")) {
+        self.language = Zig.init();
+    } else {
+        self.language = null;
+    }
 }
 
 /// Saves the text to the current location based on the `filename` field.
-pub fn saveFile(self: *Editor) !void {
-    const file = try std.fs.cwd().createFile(self.filename.items, .{});
+pub fn saveFile(self: *Editor, gpa: std.mem.Allocator) !void {
+    if (self.language) |*l| format_text: {
+        const formatted = l.formatter.format(gpa, self.text.items) catch break :format_text;
+        defer gpa.free(formatted);
+
+        self.text.clearRetainingCapacity();
+        try self.text.ensureTotalCapacity(gpa, formatted.len);
+        self.text.appendSliceAssumeCapacity(formatted);
+
+        try self.updateLines(gpa);
+        try self.tokenize(gpa);
+    }
+
+    std.log.debug("saving file: {s}", .{self.filename.items});
+
+    const file = try std.fs.cwd().createFile(self.filename.items, .{ .read = true, .truncate = true });
     defer file.close();
 
     var buffer: [1024]u8 = undefined;

src/libfn/Formatter.zig

···
+const std = @import("std");
+
+const Formatter = @This();
+
+vtable: *const VTable,
+
+pub const VTable = struct {
+    format: *const fn (f: *Formatter, gpa: std.mem.Allocator, input: []const u8) anyerror![]const u8 = format,
+};
+
+/// Runs a formatter on the provided input, and returns the formatted output. Caller owns the
+/// returned memory.
+pub fn format(f: *Formatter, gpa: std.mem.Allocator, input: []const u8) anyerror![]const u8 {
+    return try f.vtable.format(f, gpa, input);
+}

src/libfn/Language.zig

···
+const std = @import("std");
+
+const Formatter = @import("Formatter.zig");
+
+const Language = @This();
+
+formatter: Formatter,

src/libfn/formatters/ZigFmt.zig

···
+const std = @import("std");
+
+const Formatter = @import("../Formatter.zig");
+
+const ZigFmt = @This();
+
+pub fn init() Formatter {
+    return .{
+        .vtable = &.{
+            .format = format,
+        },
+    };
+}
+
+pub fn format(f: *Formatter, gpa: std.mem.Allocator, input: []const u8) anyerror![]const u8 {
+    _ = f;
+
+    var child = std.process.Child.init(&.{ "zig", "fmt", "--stdin" }, gpa);
+    child.stdin_behavior = .Pipe;
+    child.stdout_behavior = .Pipe;
+    child.stderr_behavior = .Pipe;
+
+    try child.spawn();
+
+    const stdin = child.stdin.?;
+
+    var buffer: [4096]u8 = undefined;
+    var w = stdin.writer(&buffer);
+    _ = try w.interface.write(input);
+    try w.interface.flush();
+
+    child.stdin.?.close();
+    child.stdin = null;
+
+    var out: std.ArrayList(u8) = .empty;
+    var err: std.ArrayList(u8) = .empty;
+    defer out.deinit(gpa);
+    defer err.deinit(gpa);
+
+    // FIXME: maxInt(usize) is probably excessive here?
+    try child.collectOutput(gpa, &out, &err, std.math.maxInt(usize));
+
+    const result = try child.wait();
+
+    if (result.Exited == 0) return out.toOwnedSlice(gpa);
+
+    return error.FailedToFormat;
+}

src/libfn/languages/Zig.zig

···
+const std = @import("std");
+
+const Zig = @This();
+
+const Language = @import("../Language.zig");
+const ZigFmt = @import("../formatters/ZigFmt.zig");
+
+pub fn init() Language {
+    return .{
+        .formatter = ZigFmt.init(),
+    };
+}

src/tui/main.zig

···
         });
 
         if (menu_bar_action) |a| {
-            if (a.id == .file_menu_save and a.action == .clicked) try state.editor.saveFile();
+            if (a.id == .file_menu_save and a.action == .clicked) try state.editor.saveFile(state.gpa);
             if (a.id == .file_menu_quit and a.action == .clicked) return .stop;
         }
     }
···
                 }
             }
 
-            if (key.matches('s', .{ .super = true })) try state.editor.saveFile();
+            if (key.matches('s', .{ .super = true })) try state.editor.saveFile(state.gpa);
         },
         .mouse => |mouse| if (container.hasMouse(mouse)) |_| {
             if (mouse.button == .left and mouse.type == .press) {

test.zig

···
+pub fn main() void {
+    return;
+}