neurocyte/flow
neurocyte/flow
1
1
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

refactor: lots and lots of writergate changes

Browse source
This commit is contained in:
CJ van den Berg 2025-09-24 22:30:18 +02:00
parent 96e8100373
commit e6b39c274c
Signed by: neurocyte
GPG key ID: 8EB1E1BB660E3FB9
19 changed files with 437 additions and 382 deletions
Download patch file Download diff file Expand all files Collapse all files

66
src/keybind/keybind.zig
View file

@ -137,11 +137,11 @@ pub fn get_namespaces(allocator: std.mem.Allocator) ![]const []const u8 {
for (namespaces) |namespace| allocator.free(namespace);
allocator.free(namespaces);
}
var result = std.ArrayList([]const u8).init(allocator);
try result.append(try allocator.dupe(u8, "flow"));
try result.append(try allocator.dupe(u8, "emacs"));
try result.append(try allocator.dupe(u8, "vim"));
try result.append(try allocator.dupe(u8, "helix"));
var result: std.ArrayList([]const u8) = .empty;
try result.append(allocator, try allocator.dupe(u8, "flow"));
try result.append(allocator, try allocator.dupe(u8, "emacs"));
try result.append(allocator, try allocator.dupe(u8, "vim"));
try result.append(allocator, try allocator.dupe(u8, "helix"));
for (namespaces) |namespace| {
var exists = false;
for (result.items) |existing|
@ -150,9 +150,9 @@ pub fn get_namespaces(allocator: std.mem.Allocator) ![]const []const u8 {
break;
};
if (!exists)
try result.append(try allocator.dupe(u8, namespace));
try result.append(allocator, try allocator.dupe(u8, namespace));
}
return result.toOwnedSlice();
return result.toOwnedSlice(allocator);
}
pub fn get_namespace() []const u8 {
@ -198,7 +198,7 @@ fn get_mode_binding_set(mode_name: []const u8, insert_command: []const u8) LoadE
return binding_set;
}
pub const LoadError = (error{ NotFound, NotAnObject } || std.json.ParseError(std.json.Scanner) || parse_flow.ParseError || parse_vim.ParseError || std.json.ParseFromValueError);
pub const LoadError = (error{ NotFound, NotAnObject, WriteFailed } || std.json.ParseError(std.json.Scanner) || parse_flow.ParseError || parse_vim.ParseError || std.json.ParseFromValueError);
///A collection of modes that represent a switchable editor emulation
const Namespace = struct {
@ -320,7 +320,7 @@ const Command = struct {
return args.len == 1 and args[0] == .integer;
}
fn load(allocator: std.mem.Allocator, tokens: []const std.json.Value) (parse_flow.ParseError || parse_vim.ParseError)!Command {
fn load(allocator: std.mem.Allocator, tokens: []const std.json.Value) (error{WriteFailed} || parse_flow.ParseError || parse_vim.ParseError)!Command {
if (tokens.len == 0) return error.InvalidFormat;
var state: enum { command, args } = .command;
var args = std.ArrayListUnmanaged(std.json.Value){};
@ -343,11 +343,10 @@ const Command = struct {
switch (token) {
.string, .integer, .float, .bool => {},
else => {
var json = std.ArrayList(u8).init(allocator);
defer json.deinit();
std.json.stringify(token, .{}, json.writer()) catch {};
const json = try std.json.Stringify.valueAlloc(allocator, token, .{});
defer allocator.free(json);
const logger = log.logger("keybind");
logger.print_err("keybind.load", "ERROR: invalid command argument '{s}'", .{json.items});
logger.print_err("keybind.load", "ERROR: invalid command argument '{s}'", .{json});
logger.deinit();
return error.InvalidFormat;
},
@ -357,14 +356,14 @@ const Command = struct {
}
}
var args_cbor = std.ArrayListUnmanaged(u8){};
defer args_cbor.deinit(allocator);
const writer = args_cbor.writer(allocator);
var args_cbor: std.Io.Writer.Allocating = .init(allocator);
defer args_cbor.deinit();
const writer = &args_cbor.writer;
try cbor.writeArrayHeader(writer, args.items.len);
for (args.items) |arg| try cbor.writeJsonValue(writer, arg);
return .{
.command = command_,
.args = try args_cbor.toOwnedSlice(allocator),
.args = try args_cbor.toOwnedSlice(),
};
}
};
@ -426,7 +425,7 @@ const BindingSet = struct {
const KeySyntax = enum { flow, vim };
const OnMatchFailure = enum { insert, ignore };
fn load(allocator: std.mem.Allocator, namespace_name: []const u8, mode_bindings: std.json.Value, fallback: ?*const BindingSet, namespace: *Namespace) (error{OutOfMemory} || parse_flow.ParseError || parse_vim.ParseError || std.json.ParseFromValueError)!@This() {
fn load(allocator: std.mem.Allocator, namespace_name: []const u8, mode_bindings: std.json.Value, fallback: ?*const BindingSet, namespace: *Namespace) (error{ OutOfMemory, WriteFailed } || parse_flow.ParseError || parse_vim.ParseError || std.json.ParseFromValueError)!@This() {
var self: @This() = .{ .name = undefined, .selection_style = undefined };
const JsonConfig = struct {
@ -475,7 +474,7 @@ const BindingSet = struct {
return self;
}
fn load_event(self: *BindingSet, allocator: std.mem.Allocator, dest: *std.ArrayListUnmanaged(Binding), event: input.Event, bindings: []const []const std.json.Value) (parse_flow.ParseError || parse_vim.ParseError)!void {
fn load_event(self: *BindingSet, allocator: std.mem.Allocator, dest: *std.ArrayListUnmanaged(Binding), event: input.Event, bindings: []const []const std.json.Value) (error{WriteFailed} || parse_flow.ParseError || parse_vim.ParseError)!void {
_ = event;
bindings: for (bindings) |entry| {
if (entry.len < 2) {
@ -509,27 +508,26 @@ const BindingSet = struct {
errdefer allocator.free(key_events);
const cmd = entry[1];
var cmds = std.ArrayList(Command).init(allocator);
defer cmds.deinit();
var cmds: std.ArrayList(Command) = .empty;
defer cmds.deinit(allocator);
if (cmd == .string) {
try cmds.append(try Command.load(allocator, entry[1..]));
try cmds.append(allocator, try Command.load(allocator, entry[1..]));
} else {
for (entry[1..]) |cmd_entry| {
if (cmd_entry != .array) {
var json = std.ArrayList(u8).init(allocator);
defer json.deinit();
std.json.stringify(cmd_entry, .{}, json.writer()) catch {};
const json = try std.json.Stringify.valueAlloc(allocator, cmd_entry, .{});
defer allocator.free(json);
const logger = log.logger("keybind");
logger.print_err("keybind.load", "ERROR: invalid command definition {s}", .{json.items});
logger.print_err("keybind.load", "ERROR: invalid command definition {s}", .{json});
logger.deinit();
continue :bindings;
}
try cmds.append(try Command.load(allocator, cmd_entry.array.items));
try cmds.append(allocator, try Command.load(allocator, cmd_entry.array.items));
}
}
try dest.append(allocator, .{
.key_events = key_events,
.commands = try cmds.toOwnedSlice(),
.commands = try cmds.toOwnedSlice(allocator),
});
}
}
@ -564,13 +562,13 @@ const BindingSet = struct {
for (self.press.items) |binding| {
const cmd = binding.commands[0].command;
var hint = if (hints_map.get(cmd)) |previous|
std.ArrayList(u8).fromOwnedSlice(allocator, previous)
var hint: std.Io.Writer.Allocating = if (hints_map.get(cmd)) |previous|
.initOwnedSlice(allocator, previous)
else
std.ArrayList(u8).init(allocator);
.init(allocator);
defer hint.deinit();
const writer = hint.writer();
if (hint.items.len > 0) try writer.writeAll(", ");
const writer = &hint.writer;
if (hint.written().len > 0) try writer.writeAll(", ");
const count = binding.key_events.len;
for (binding.key_events, 0..) |key_, n| {
var key = key_;
@ -578,7 +576,7 @@ const BindingSet = struct {
switch (self.syntax) {
// .flow => {
else => {
try writer.print("{}", .{key});
try writer.print("{f}", .{key});
if (n < count - 1)
try writer.writeAll(" ");
},

6
src/keybind/parse_flow.zig
View file

@ -21,7 +21,7 @@ fn parse_error(comptime format: anytype, args: anytype) ParseError {
pub fn parse_key_events(allocator: std.mem.Allocator, str: []const u8) ParseError![]input.KeyEvent {
parse_error_reset();
if (str.len == 0) return parse_error("empty", .{});
var result_events = std.ArrayList(input.KeyEvent).init(allocator);
var result_events: std.ArrayList(input.KeyEvent) = .empty;
var iter_sequence = std.mem.tokenizeScalar(u8, str, ' ');
while (iter_sequence.next()) |item| {
var key: ?input.Key = null;
@ -65,11 +65,11 @@ pub fn parse_key_events(allocator: std.mem.Allocator, str: []const u8) ParseErro
if (key == null) return parse_error("unknown key '{s}' in '{s}'", .{ part, str });
}
if (key) |k|
try result_events.append(input.KeyEvent.from_key_modset(k, mods))
try result_events.append(allocator, input.KeyEvent.from_key_modset(k, mods))
else
return parse_error("no key defined in '{s}'", .{str});
}
return result_events.toOwnedSlice();
return result_events.toOwnedSlice(allocator);
}
pub const name_map = blk: {

42
src/keybind/parse_vim.zig
View file

@ -81,8 +81,8 @@ pub fn parse_key_events(allocator: std.mem.Allocator, str: []const u8) ParseErro
var state: State = .base;
var function_key_number: u8 = 0;
var modifiers: input.Mods = 0;
var result = std.ArrayList(input.KeyEvent).init(allocator);
defer result.deinit();
var result: std.ArrayList(input.KeyEvent) = .empty;
defer result.deinit(allocator);
var i: usize = 0;
while (i < str.len) {
@ -100,7 +100,7 @@ pub fn parse_key_events(allocator: std.mem.Allocator, str: []const u8) ParseErro
'0'...'9',
'!', '@', '#', '$', '%', '^', '&', '*', '(', ')',
'`', '~', '-', '_', '=', '+', '[', ']', '{', '}', '\\', '|', ':', ';', '\'', '"', ',', '.', '/', '?', => {
try result.append(from_key(str[i]));
try result.append(allocator, from_key(str[i]));
i += 1;
},
else => return parse_error(error.InvalidInitialCharacter, "str: {s}, i: {} c: {c}", .{ str, i, str[i] }),
@ -216,7 +216,7 @@ pub fn parse_key_events(allocator: std.mem.Allocator, str: []const u8) ParseErro
},
.insert => {
if (std.mem.indexOf(u8, str[i..], "Insert") == 0) {
try result.append(from_key_mods(input.key.insert, modifiers));
try result.append(allocator, from_key_mods(input.key.insert, modifiers));
modifiers = 0;
state = .escape_sequence_end;
i += 4;
@ -224,7 +224,7 @@ pub fn parse_key_events(allocator: std.mem.Allocator, str: []const u8) ParseErro
},
.end => {
if (std.mem.indexOf(u8, str[i..], "End") == 0) {
try result.append(from_key_mods(input.key.end, modifiers));
try result.append(allocator, from_key_mods(input.key.end, modifiers));
modifiers = 0;
state = .escape_sequence_end;
i += 3;
@ -232,7 +232,7 @@ pub fn parse_key_events(allocator: std.mem.Allocator, str: []const u8) ParseErro
},
.home => {
if (std.mem.indexOf(u8, str[i..], "Home") == 0) {
try result.append(from_key_mods(input.key.home, modifiers));
try result.append(allocator, from_key_mods(input.key.home, modifiers));
modifiers = 0;
state = .escape_sequence_end;
i += 4;
@ -240,7 +240,7 @@ pub fn parse_key_events(allocator: std.mem.Allocator, str: []const u8) ParseErro
},
.bs => {
if (std.mem.indexOf(u8, str[i..], "BS") == 0) {
try result.append(from_key_mods(input.key.backspace, modifiers));
try result.append(allocator, from_key_mods(input.key.backspace, modifiers));
modifiers = 0;
state = .escape_sequence_end;
i += 2;
@ -248,7 +248,7 @@ pub fn parse_key_events(allocator: std.mem.Allocator, str: []const u8) ParseErro
},
.cr => {
if (std.mem.indexOf(u8, str[i..], "CR") == 0) {
try result.append(from_key_mods(input.key.enter, modifiers));
try result.append(allocator, from_key_mods(input.key.enter, modifiers));
modifiers = 0;
state = .escape_sequence_end;
i += 2;
@ -256,7 +256,7 @@ pub fn parse_key_events(allocator: std.mem.Allocator, str: []const u8) ParseErro
},
.space => {
if (std.mem.indexOf(u8, str[i..], "Space") == 0) {
try result.append(from_key_mods(input.key.space, modifiers));
try result.append(allocator, from_key_mods(input.key.space, modifiers));
modifiers = 0;
state = .escape_sequence_end;
i += 5;
@ -264,7 +264,7 @@ pub fn parse_key_events(allocator: std.mem.Allocator, str: []const u8) ParseErro
},
.del => {
if (std.mem.indexOf(u8, str[i..], "Del") == 0) {
try result.append(from_key_mods(input.key.delete, modifiers));
try result.append(allocator, from_key_mods(input.key.delete, modifiers));
modifiers = 0;
state = .escape_sequence_end;
i += 3;
@ -272,7 +272,7 @@ pub fn parse_key_events(allocator: std.mem.Allocator, str: []const u8) ParseErro
},
.tab => {
if (std.mem.indexOf(u8, str[i..], "Tab") == 0) {
try result.append(from_key_mods(input.key.tab, modifiers));
try result.append(allocator, from_key_mods(input.key.tab, modifiers));
modifiers = 0;
state = .escape_sequence_end;
i += 3;
@ -280,7 +280,7 @@ pub fn parse_key_events(allocator: std.mem.Allocator, str: []const u8) ParseErro
},
.up => {
if (std.mem.indexOf(u8, str[i..], "Up") == 0) {
try result.append(from_key_mods(input.key.up, modifiers));
try result.append(allocator, from_key_mods(input.key.up, modifiers));
modifiers = 0;
state = .escape_sequence_end;
i += 2;
@ -288,7 +288,7 @@ pub fn parse_key_events(allocator: std.mem.Allocator, str: []const u8) ParseErro
},
.esc => {
if (std.mem.indexOf(u8, str[i..], "Esc") == 0) {
try result.append(from_key_mods(input.key.escape, modifiers));
try result.append(allocator, from_key_mods(input.key.escape, modifiers));
modifiers = 0;
state = .escape_sequence_end;
i += 3;
@ -296,7 +296,7 @@ pub fn parse_key_events(allocator: std.mem.Allocator, str: []const u8) ParseErro
},
.down => {
if (std.mem.indexOf(u8, str[i..], "Down") == 0) {
try result.append(from_key_mods(input.key.down, modifiers));
try result.append(allocator, from_key_mods(input.key.down, modifiers));
modifiers = 0;
state = .escape_sequence_end;
i += 4;
@ -304,7 +304,7 @@ pub fn parse_key_events(allocator: std.mem.Allocator, str: []const u8) ParseErro
},
.left => {
if (std.mem.indexOf(u8, str[i..], "Left") == 0) {
try result.append(from_key_mods(input.key.left, modifiers));
try result.append(allocator, from_key_mods(input.key.left, modifiers));
modifiers = 0;
state = .escape_sequence_end;
i += 4;
@ -312,7 +312,7 @@ pub fn parse_key_events(allocator: std.mem.Allocator, str: []const u8) ParseErro
},
.right => {
if (std.mem.indexOf(u8, str[i..], "Right") == 0) {
try result.append(from_key_mods(input.key.right, modifiers));
try result.append(allocator, from_key_mods(input.key.right, modifiers));
modifiers = 0;
state = .escape_sequence_end;
i += 5;
@ -320,7 +320,7 @@ pub fn parse_key_events(allocator: std.mem.Allocator, str: []const u8) ParseErro
},
.less_than => {
if (std.mem.indexOf(u8, str[i..], "LT") == 0) {
try result.append(from_key_mods('<', modifiers));
try result.append(allocator, from_key_mods('<', modifiers));
modifiers = 0;
state = .escape_sequence_end;
i += 2;
@ -328,7 +328,7 @@ pub fn parse_key_events(allocator: std.mem.Allocator, str: []const u8) ParseErro
},
.greater_than => {
if (std.mem.indexOf(u8, str[i..], "GT") == 0) {
try result.append(from_key_mods('>', modifiers));
try result.append(allocator, from_key_mods('>', modifiers));
modifiers = 0;
state = .escape_sequence_end;
i += 2;
@ -345,7 +345,7 @@ pub fn parse_key_events(allocator: std.mem.Allocator, str: []const u8) ParseErro
},
'>' => {
const function_key = input.key.f1 - 1 + function_key_number;
try result.append(from_key_mods(function_key, modifiers));
try result.append(allocator, from_key_mods(function_key, modifiers));
modifiers = 0;
function_key_number = 0;
state = .base;
@ -371,7 +371,7 @@ pub fn parse_key_events(allocator: std.mem.Allocator, str: []const u8) ParseErro
'0'...'9',
'`', '-', '=', '[', ']', '\\', ':', ';', '\'', ',', '.', '/',
=> {
try result.append(from_key_mods(str[i], modifiers));
try result.append(allocator, from_key_mods(str[i], modifiers));
modifiers = 0;
state = .escape_sequence_end;
i += 1;
@ -405,5 +405,5 @@ pub fn parse_key_events(allocator: std.mem.Allocator, str: []const u8) ParseErro
},
}
}
return result.toOwnedSlice();
return result.toOwnedSlice(allocator);
}