10 files changed, 42 insertions, 47 deletions

diff --git a/src/Buffer.zig b/src/Buffer.zig
index 0416fda..d7f051d 100644
--- a/src/Buffer.zig
+++ b/src/Buffer.zig
@@ -38,7 +38,7 @@ pub fn init(allocator: Allocator, name: []const u8) !Buffer {
     // TODO: buffer-specific config support
     var config = try Config.readConfig(allocator);
 
-    return Buffer {
+    return Buffer{
         .allocator = allocator,
 
         .name = name_owned,
@@ -193,7 +193,7 @@ pub fn drawRows(self: Buffer, writer: anytype, screenrows: usize, screencols: us
                 }
             }
         } else if (self.rows.items.len == 0 and y == screenrows / 3) {
-            const welcome_data = try std.fmt.allocPrint(self.allocator, "ES -- version {}", .{ es_config.es_version });
+            const welcome_data = try std.fmt.allocPrint(self.allocator, "ES -- version {}", .{es_config.es_version});
             defer self.allocator.free(welcome_data);
             var welcome = welcome_data;
             if (welcome.len > screencols - 1) {
@@ -201,7 +201,7 @@ pub fn drawRows(self: Buffer, writer: anytype, screenrows: usize, screencols: us
             }
 
             const padding = (screencols - welcome.len - 1) / 2;
-            try writer.print("{s}~{s}", .{Highlight.line_no.asString(), Highlight.normal.asString()});
+            try writer.print("{s}~{s}", .{ Highlight.line_no.asString(), Highlight.normal.asString() });
             try printWithLeftPadding(self.allocator, writer, "{s}", welcome.len + padding, ' ', .{welcome});
         } else {
             try writer.print("{s}~", .{Highlight.line_no.asString()});
@@ -225,7 +225,7 @@ pub fn drawStatusBar(self: Buffer, writer: anytype, screencols: usize) !void {
     else
         @as([]const u8, "");
 
-    var lbuf = try std.fmt.allocPrint(self.allocator, "{s}{s}", .{name, modified});
+    var lbuf = try std.fmt.allocPrint(self.allocator, "{s}{s}", .{ name, modified });
     defer self.allocator.free(lbuf);
 
     var rbuf = try std.fmt.allocPrint(self.allocator, " {s} | {}/{}", .{
@@ -263,7 +263,7 @@ pub fn goToLine(self: *Buffer, editor: *Editor) !void {
         defer editor.allocator.free(line_str);
 
         const line = std.fmt.parseUnsigned(usize, line_str, 0) catch |err| {
-            try editor.setStatusMessage("Couldn't parse '{s}' as an integer: {}", .{line_str, err});
+            try editor.setStatusMessage("Couldn't parse '{s}' as an integer: {}", .{ line_str, err });
             return;
         };
 
@@ -419,34 +419,34 @@ pub fn save(self: *Buffer, editor: *Editor) !void {
     // TODO: Add a config value for this
     try self.cleanWhiteSpace();
 
-    const tmpname = try std.fmt.allocPrint(self.allocator, "{s}~{}", .{self.name, std.time.milliTimestamp()});
+    const tmpname = try std.fmt.allocPrint(self.allocator, "{s}~{}", .{ self.name, std.time.milliTimestamp() });
     defer self.allocator.free(tmpname);
 
-    const tmpfile = std.fs.cwd().createFile(tmpname, .{.truncate = true}) catch |err| {
-        try editor.setStatusMessage("Cannot open tempfile '{s}' for writing: {}", .{tmpname, err});
+    const tmpfile = std.fs.cwd().createFile(tmpname, .{ .truncate = true }) catch |err| {
+        try editor.setStatusMessage("Cannot open tempfile '{s}' for writing: {}", .{ tmpname, err });
         return;
     };
     defer tmpfile.close();
 
     const stat = statFile(self.name) catch |err| {
-        try editor.setStatusMessage("Couldn't stat file '{s}': {}", .{self.name, err});
+        try editor.setStatusMessage("Couldn't stat file '{s}': {}", .{ self.name, err });
         return;
     };
 
     tmpfile.chmod(stat.mode) catch |err| {
-        try editor.setStatusMessage("Couldn't chmod tempfile '{s}': {}", .{tmpname, err});
+        try editor.setStatusMessage("Couldn't chmod tempfile '{s}': {}", .{ tmpname, err });
         return;
     };
 
     // TODO: chown
 
     self.writeToFile(tmpfile) catch |err| {
-        try editor.setStatusMessage("Couldn't write to tempfile '{s}': {}", .{tmpname, err});
+        try editor.setStatusMessage("Couldn't write to tempfile '{s}': {}", .{ tmpname, err });
         return;
     };
 
     std.fs.cwd().rename(tmpname, self.name) catch |err| {
-        try editor.setStatusMessage("Couldn't move '{s}' to '{s}': {}", .{tmpname, self.name, err});
+        try editor.setStatusMessage("Couldn't move '{s}' to '{s}': {}", .{ tmpname, self.name, err });
         return;
     };
 
@@ -480,9 +480,7 @@ pub fn selectSyntaxHighlighting(self: *Buffer) !void {
     for (Syntax.database) |syntax| {
         for (syntax.filematch) |filematch| {
             const is_ext = filematch[0] == '.';
-            if ((is_ext and ext != null and std.mem.eql(u8, ext.?, filematch))
-                or (!is_ext and std.mem.eql(u8, self.name, filematch))
-            ) {
+            if ((is_ext and ext != null and std.mem.eql(u8, ext.?, filematch)) or (!is_ext and std.mem.eql(u8, self.name, filematch))) {
                 self.syntax = syntax;
 
                 for (self.rows.items) |*row| {
diff --git a/src/Config.zig b/src/Config.zig
index b8b45a5..1f11b65 100644
--- a/src/Config.zig
+++ b/src/Config.zig
@@ -13,7 +13,7 @@ page_overlap: usize = 2,
 tab_stop: usize = 8,
 
 pub fn readConfig(allocator: Allocator) !Config {
-    var config = Config {};
+    var config = Config{};
 
     var env_map = try std.process.getEnvMap(allocator);
     defer env_map.deinit();
@@ -32,7 +32,7 @@ pub fn readConfig(allocator: Allocator) !Config {
     } else {
         // TODO: Maybe return an error instead of .?
         const home = env_map.get("HOME").?;
-        const home_config = try std.fs.path.join(allocator, &.{home, ".config"});
+        const home_config = try std.fs.path.join(allocator, &.{ home, ".config" });
         defer allocator.free(home_config);
 
         try readConfigInBaseDir(allocator, &config, home_config);
@@ -42,7 +42,7 @@ pub fn readConfig(allocator: Allocator) !Config {
 }
 
 fn readConfigInBaseDir(allocator: Allocator, config: *Config, base_dir: []const u8) !void {
-    const filename = try std.fs.path.join(allocator, &.{base_dir, config_path});
+    const filename = try std.fs.path.join(allocator, &.{ base_dir, config_path });
     defer allocator.free(filename);
 
     const file = std.fs.openFileAbsolute(filename, .{ .read = true }) catch |err| switch (err) {
diff --git a/src/Editor.zig b/src/Editor.zig
index eecbaa7..487c5ff 100644
--- a/src/Editor.zig
+++ b/src/Editor.zig
@@ -188,7 +188,7 @@ pub fn promptEx(
     defer buf.deinit();
 
     while (true) {
-        try self.setStatusMessage("{s}: {s}", .{prompt_str, buf.items});
+        try self.setStatusMessage("{s}: {s}", .{ prompt_str, buf.items });
         try self.refreshScreen();
 
         // TODO: Navigation
@@ -217,7 +217,7 @@ pub fn promptEx(
                 if (std.ascii.isSpace(key_char) or std.ascii.isGraph(key_char)) {
                     try buf.append(key_char);
                 }
-            } // else ??
+            }, // else ??
         }
 
         if (callback) |cb| {
@@ -227,7 +227,7 @@ pub fn promptEx(
 }
 
 pub fn PromptCallback(comptime Data: type, comptime Error: type) type {
-    return fn(*Editor, []const u8, Key, Data) Error!void;
+    return fn (*Editor, []const u8, Key, Data) Error!void;
 }
 
 pub fn promptYN(self: *Editor, prompt_str: []const u8) !bool {
@@ -237,8 +237,7 @@ pub fn promptYN(self: *Editor, prompt_str: []const u8) !bool {
     var response = try self.prompt(full_prompt);
     defer if (response) |str| self.allocator.free(str);
     // TODO: This can be improved
-    while (response == null
-               or (response.?[0] != 'y' and response.?[0] != 'Y' and response.?[0] != 'n' and response.?[0] != 'N')) {
+    while (response == null or (response.?[0] != 'y' and response.?[0] != 'Y' and response.?[0] != 'n' and response.?[0] != 'N')) {
         if (response) |str| self.allocator.free(str);
         response = try self.prompt(full_prompt);
     }
@@ -342,7 +341,7 @@ fn getCursorPosition(row: *usize, col: *usize) !void {
     try std_out.writeAll("\x1b[6n\r\n");
 
     const std_in = std.io.getStdIn().reader();
-    var buf = [_]u8 { undefined } ** 32;
+    var buf = [_]u8{undefined} ** 32;
     var response = std_in.readUntilDelimiter(&buf, 'R') catch |err| switch (err) {
         error.EndOfStream => return error.MisformedTerminalResponse,
         error.StreamTooLong => return error.MisformedTerminalResponse,
diff --git a/src/Row.zig b/src/Row.zig
index 633e338..a542160 100644
--- a/src/Row.zig
+++ b/src/Row.zig
@@ -162,7 +162,7 @@ pub fn updateSyntax(self: *Row, buf: *Buffer) UpdateSyntaxError!void {
         if (syntax.singleline_comment_start) |scs| {
             std.debug.assert(scs.len != 0);
             if (curr_str_quote == null and !in_comment and scs.len + i <= self.rdata.items.len) {
-                if (std.mem.eql(u8, scs, self.rdata.items[i .. (i + scs.len)])) {
+                if (std.mem.eql(u8, scs, self.rdata.items[i..(i + scs.len)])) {
                     std.mem.set(Highlight, self.hldata.items[i..], .comment);
                     break;
                 }
@@ -176,10 +176,8 @@ pub fn updateSyntax(self: *Row, buf: *Buffer) UpdateSyntaxError!void {
                 if (curr_str_quote == null) {
                     if (in_comment) {
                         self.hldata.items[i] = .comment_ml;
-                        if (mce.len + i <= self.rdata.items.len
-                            and std.mem.eql(u8, mce, self.rdata.items[i .. (i + mce.len)])
-                        ) {
-                            std.mem.set(Highlight, self.hldata.items[i .. (i + mce.len)], .comment_ml);
+                        if (mce.len + i <= self.rdata.items.len and std.mem.eql(u8, mce, self.rdata.items[i..(i + mce.len)])) {
+                            std.mem.set(Highlight, self.hldata.items[i..(i + mce.len)], .comment_ml);
                             i += mce.len;
                             in_comment = false;
                             after_sep = true;
@@ -187,15 +185,13 @@ pub fn updateSyntax(self: *Row, buf: *Buffer) UpdateSyntaxError!void {
                             i += 1;
                             continue;
                         }
-                    } else if (mcs.len + i <= self.rdata.items.len
-                                   and std.mem.eql(u8, mcs, self.rdata.items[i .. (i + mcs.len)])) {
-                        std.mem.set(Highlight, self.hldata.items[i .. (i + mcs.len)], .comment_ml);
+                    } else if (mcs.len + i <= self.rdata.items.len and std.mem.eql(u8, mcs, self.rdata.items[i..(i + mcs.len)])) {
+                        std.mem.set(Highlight, self.hldata.items[i..(i + mcs.len)], .comment_ml);
                         i += mcs.len;
                         in_comment = true;
                         continue;
                     }
                 }
-
             }
         }
 
@@ -227,8 +223,7 @@ pub fn updateSyntax(self: *Row, buf: *Buffer) UpdateSyntaxError!void {
         }
 
         if (syntax.flags.hl_numbers) {
-            if ((std.ascii.isDigit(c) and (after_sep or prev_hl == .number))
-                    or (c == '.' and prev_hl == .number)) {
+            if ((std.ascii.isDigit(c) and (after_sep or prev_hl == .number)) or (c == '.' and prev_hl == .number)) {
                 after_sep = false;
                 self.hldata.items[i] = .number;
                 i += 1;
@@ -238,10 +233,8 @@ pub fn updateSyntax(self: *Row, buf: *Buffer) UpdateSyntaxError!void {
 
         if (after_sep) {
             for (kw1) |kw| {
-                if (i + kw.len <= self.rdata.items.len
-                    and std.mem.eql(u8, kw, self.rdata.items[i .. (i + kw.len)])
-                    and (i + kw.len == self.rdata.items.len or syntax.isSeparator(self.rdata.items[i + kw.len]))) {
-                    std.mem.set(Highlight, self.hldata.items[i .. (i + kw.len)], .keyword1);
+                if (i + kw.len <= self.rdata.items.len and std.mem.eql(u8, kw, self.rdata.items[i..(i + kw.len)]) and (i + kw.len == self.rdata.items.len or syntax.isSeparator(self.rdata.items[i + kw.len]))) {
+                    std.mem.set(Highlight, self.hldata.items[i..(i + kw.len)], .keyword1);
                     i += kw.len;
                     after_sep = false;
                     continue :main_loop;
@@ -249,10 +242,8 @@ pub fn updateSyntax(self: *Row, buf: *Buffer) UpdateSyntaxError!void {
             }
 
             for (kw2) |kw| {
-                if (i + kw.len <= self.rdata.items.len
-                    and std.mem.eql(u8, kw, self.rdata.items[i .. (i + kw.len)])
-                    and (i + kw.len == self.rdata.items.len or syntax.isSeparator(self.rdata.items[i + kw.len]))) {
-                    std.mem.set(Highlight, self.hldata.items[i .. (i + kw.len)], .keyword2);
+                if (i + kw.len <= self.rdata.items.len and std.mem.eql(u8, kw, self.rdata.items[i..(i + kw.len)]) and (i + kw.len == self.rdata.items.len or syntax.isSeparator(self.rdata.items[i + kw.len]))) {
+                    std.mem.set(Highlight, self.hldata.items[i..(i + kw.len)], .keyword2);
                     i += kw.len;
                     after_sep = false;
                     continue :main_loop;
diff --git a/src/StringBuilder.zig b/src/StringBuilder.zig
index 632b1b3..a37aee6 100644
--- a/src/StringBuilder.zig
+++ b/src/StringBuilder.zig
@@ -36,7 +36,7 @@ pub fn toOwnedSlice(self: StringBuilder) []u8 {
 }
 
 pub fn writer(self: *StringBuilder) Writer {
-    return Writer { .context = self };
+    return Writer{ .context = self };
 }
 
 fn writeFn(self: *StringBuilder, chars: []const u8) Error!usize {
diff --git a/src/Syntax.zig b/src/Syntax.zig
index ce3f432..f29c7fc 100644
--- a/src/Syntax.zig
+++ b/src/Syntax.zig
@@ -5,7 +5,10 @@ const std = @import("std");
 
 const Syntax = @This();
 
-pub const database = [_]Syntax{makefile.syntax, zig.syntax};
+pub const database = [_]Syntax{
+    makefile.syntax,
+    zig.syntax,
+};
 
 pub const Flags = struct {
     hl_numbers: bool = false,
diff --git a/src/Syntax/makefile.zig b/src/Syntax/makefile.zig
index 4f73a2c..3a936e8 100644
--- a/src/Syntax/makefile.zig
+++ b/src/Syntax/makefile.zig
@@ -1,3 +1,5 @@
+// Please don't zig fmt this
+
 const Syntax = @import("../Syntax.zig");
 
 pub const syntax = Syntax{
diff --git a/src/Syntax/zig.zig b/src/Syntax/zig.zig
index 653fb1b..d0bf60c 100644
--- a/src/Syntax/zig.zig
+++ b/src/Syntax/zig.zig
@@ -1,3 +1,5 @@
+// Please don't zig fmt this
+
 const std = @import("std");
 
 const Syntax = @import("../Syntax.zig");
diff --git a/src/key.zig b/src/key.zig
index 1a68ebb..3a007fb 100644
--- a/src/key.zig
+++ b/src/key.zig
@@ -79,7 +79,7 @@ pub const Key = enum(u16) {
         const key_int = @enumToInt(key);
         if (key_int < @enumToInt(Key.space)) {
             const ch = std.ascii.toLower(@intCast(u8, key_int + 0x40));
-            const buf = [_]u8{'C', '-', ch};
+            const buf = [_]u8{ 'C', '-', ch };
             return std.fmt.formatBuf(&buf, options, writer);
         } else if (key_int < @enumToInt(Key.meta_nil)) {
             const buf = [_]u8{@intCast(u8, key_int)};
diff --git a/src/key_state.zig b/src/key_state.zig
index 19177cf..49adbf8 100644
--- a/src/key_state.zig
+++ b/src/key_state.zig
@@ -16,7 +16,7 @@ pub const Error = error{
     std.fs.File.ReadError ||
     std.fs.File.WriteError ||
     std.os.SchedYieldError;
-pub const KeyState = fn(*Editor, *Buffer, Key) Error!void;
+pub const KeyState = fn (*Editor, *Buffer, Key) Error!void;
 
 pub fn mgState(editor: *Editor, buf: *Buffer, key: Key) Error!void {
     editor.current_state = defaultState;