825 lines
30 KiB
Zig
825 lines
30 KiB
Zig
//TODO figure out how keybindings should be configured
|
|
|
|
//TODO figure out how to handle bindings that can take a numerical prefix
|
|
|
|
const std = @import("std");
|
|
const tp = @import("thespian");
|
|
const cbor = @import("cbor");
|
|
const builtin = @import("builtin");
|
|
|
|
const renderer = @import("renderer");
|
|
const key = @import("renderer").input.key;
|
|
const mod = @import("renderer").input.modifier;
|
|
const event_type = @import("renderer").input.event_type;
|
|
const command = @import("command");
|
|
const EventHandler = @import("EventHandler");
|
|
|
|
pub const mode = struct {
|
|
pub const input = struct {
|
|
pub const flow = Handler("flow", "normal");
|
|
pub const home = Handler("home", "normal");
|
|
pub const vim = struct {
|
|
pub const normal = Handler("vim", "normal");
|
|
pub const insert = Handler("vim", "insert");
|
|
pub const visual = Handler("vim", "visual");
|
|
};
|
|
pub const helix = struct {
|
|
pub const normal = Handler("helix", "normal");
|
|
pub const insert = Handler("helix", "insert");
|
|
pub const visual = Handler("helix", "select");
|
|
};
|
|
};
|
|
pub const overlay = struct {
|
|
pub const palette = Handler("overlay", "palette");
|
|
};
|
|
pub const mini = struct {
|
|
pub const goto = Handler("mini", "goto");
|
|
pub const move_to_char = Handler("mini", "move_to_char");
|
|
pub const file_browser = Handler("mini", "file_browser");
|
|
pub const find_in_files = Handler("mini", "find_in_files");
|
|
pub const find = Handler("mini", "find");
|
|
};
|
|
};
|
|
|
|
fn Handler(namespace_name: []const u8, mode_name: []const u8) type {
|
|
return struct {
|
|
allocator: std.mem.Allocator,
|
|
bindings: *Bindings,
|
|
pub fn create(allocator: std.mem.Allocator, _: anytype) !EventHandler {
|
|
const self: *@This() = try allocator.create(@This());
|
|
self.* = .{
|
|
.allocator = allocator,
|
|
.bindings = try Bindings.init(allocator),
|
|
};
|
|
try self.bindings.loadJson(@embedFile("keybindings.json"));
|
|
try self.bindings.selectNamespace(namespace_name);
|
|
try self.bindings.selectMode(mode_name);
|
|
return EventHandler.to_owned(self);
|
|
}
|
|
pub fn deinit(self: *@This()) void {
|
|
self.bindings.deinit();
|
|
self.allocator.destroy(self);
|
|
}
|
|
pub fn receive(self: *@This(), from: tp.pid_ref, m: tp.message) error{Exit}!bool {
|
|
return self.bindings.activeMode().receive(from, m);
|
|
}
|
|
pub const hints = KeybindHints.initComptime(.{});
|
|
};
|
|
}
|
|
|
|
pub const Mode = struct {
|
|
input_handler: EventHandler,
|
|
event_handler: ?EventHandler = null,
|
|
|
|
name: []const u8 = "",
|
|
line_numbers: enum { absolute, relative } = .absolute,
|
|
keybind_hints: ?*const KeybindHints = null,
|
|
cursor_shape: renderer.CursorShape = .block,
|
|
|
|
pub fn deinit(self: *Mode) void {
|
|
self.input_handler.deinit();
|
|
if (self.event_handler) |eh| eh.deinit();
|
|
}
|
|
};
|
|
|
|
pub const KeybindHints = std.static_string_map.StaticStringMap([]const u8);
|
|
|
|
//A single key event, such as Ctrl-E
|
|
const KeyEvent = struct {
|
|
key: u32 = 0, //keypress value
|
|
event_type: usize = event_type.PRESS,
|
|
modifiers: u32 = 0,
|
|
|
|
fn eql(self: @This(), other: @This()) bool {
|
|
return std.meta.eql(self, other);
|
|
}
|
|
|
|
fn toString(self: @This(), allocator: std.mem.Allocator) String {
|
|
//TODO implement
|
|
_ = self;
|
|
_ = allocator;
|
|
return "";
|
|
}
|
|
};
|
|
|
|
fn peek(str: []const u8, i: usize) !u8 {
|
|
if (i + 1 < str.len) {
|
|
return str[i + 1];
|
|
} else return error.outOfBounds;
|
|
}
|
|
|
|
const Sequence = std.ArrayList(KeyEvent);
|
|
|
|
pub fn parseKeySequence(result: *Sequence, str: []const u8) !void {
|
|
const State = enum {
|
|
base,
|
|
escape_sequence_start,
|
|
escape_sequence_delimiter,
|
|
char_or_key_or_modifier,
|
|
modifier,
|
|
escape_sequence_end,
|
|
function_key,
|
|
tab,
|
|
space,
|
|
del,
|
|
cr,
|
|
esc,
|
|
up,
|
|
down,
|
|
left,
|
|
right,
|
|
};
|
|
var state: State = .base;
|
|
var function_key_number: u8 = 0;
|
|
var modifiers: u32 = 0;
|
|
|
|
var i: usize = 0;
|
|
while (i < str.len) {
|
|
switch (state) {
|
|
.base => {
|
|
switch (str[i]) {
|
|
'<' => {
|
|
state = .escape_sequence_start;
|
|
i += 1;
|
|
},
|
|
'a'...'z', ';', '0'...'9' => {
|
|
try result.append(.{ .key = str[i] });
|
|
i += 1;
|
|
},
|
|
else => {
|
|
return error.parseBase;
|
|
},
|
|
}
|
|
},
|
|
.escape_sequence_start => {
|
|
switch (str[i]) {
|
|
'A' => {
|
|
state = .modifier;
|
|
},
|
|
'C' => {
|
|
switch (try peek(str, i)) {
|
|
'R' => {
|
|
state = .cr;
|
|
},
|
|
'-' => {
|
|
state = .modifier;
|
|
},
|
|
else => {
|
|
return error.parseEscapeSequenceStartC;
|
|
},
|
|
}
|
|
},
|
|
'S' => {
|
|
switch (try peek(str, i)) {
|
|
'-' => {
|
|
state = .modifier;
|
|
},
|
|
'p' => {
|
|
state = .space;
|
|
},
|
|
else => return error.parseEscapeSequenceStartS,
|
|
}
|
|
},
|
|
'F' => {
|
|
state = .function_key;
|
|
i += 1;
|
|
},
|
|
'T' => {
|
|
state = .tab;
|
|
},
|
|
'U' => {
|
|
state = .up;
|
|
},
|
|
'L' => {
|
|
state = .left;
|
|
},
|
|
'R' => {
|
|
state = .right;
|
|
},
|
|
'E' => {
|
|
state = .esc;
|
|
},
|
|
'D' => {
|
|
switch (try peek(str, i)) {
|
|
'o' => {
|
|
state = .down;
|
|
},
|
|
'-' => {
|
|
state = .modifier;
|
|
},
|
|
'e' => {
|
|
state = .del;
|
|
},
|
|
else => return error.parseEscapeSequenceStartD,
|
|
}
|
|
},
|
|
else => {
|
|
std.debug.print("str: {s}, i: {}\n", .{ str, i });
|
|
return error.parseEscapeSequenceStart;
|
|
},
|
|
}
|
|
},
|
|
.cr => {
|
|
if (std.mem.indexOf(u8, str[i..], "CR") == 0) {
|
|
try result.append(.{ .key = key.ENTER, .modifiers = modifiers });
|
|
modifiers = 0;
|
|
state = .escape_sequence_end;
|
|
i += 2;
|
|
} else return error.parseCR;
|
|
},
|
|
.space => {
|
|
if (std.mem.indexOf(u8, str[i..], "Space") == 0) {
|
|
try result.append(.{ .key = key.SPACE, .modifiers = modifiers });
|
|
modifiers = 0;
|
|
state = .escape_sequence_end;
|
|
i += 5;
|
|
} else {
|
|
std.debug.print("str: {s}, i: {}, char: {}\n", .{ str, i, str[i] });
|
|
return error.parseSpace;
|
|
}
|
|
},
|
|
.del => {
|
|
if (std.mem.indexOf(u8, str[i..], "Del") == 0) {
|
|
try result.append(.{ .key = key.DEL, .modifiers = modifiers });
|
|
modifiers = 0;
|
|
state = .escape_sequence_end;
|
|
i += 3;
|
|
} else return error.parseDel;
|
|
},
|
|
.tab => {
|
|
if (std.mem.indexOf(u8, str[i..], "Tab") == 0) {
|
|
try result.append(.{ .key = key.TAB, .modifiers = modifiers });
|
|
modifiers = 0;
|
|
state = .escape_sequence_end;
|
|
i += 3;
|
|
} else return error.parseTab;
|
|
},
|
|
.up => {
|
|
if (std.mem.indexOf(u8, str[i..], "Up") == 0) {
|
|
try result.append(.{ .key = key.UP, .modifiers = modifiers });
|
|
modifiers = 0;
|
|
state = .escape_sequence_end;
|
|
i += 2;
|
|
} else return error.parseSpace;
|
|
},
|
|
.esc => {
|
|
if (std.mem.indexOf(u8, str[i..], "Esc") == 0) {
|
|
try result.append(.{ .key = key.ESC, .modifiers = modifiers });
|
|
modifiers = 0;
|
|
state = .escape_sequence_end;
|
|
i += 3;
|
|
} else return error.parseEsc;
|
|
},
|
|
.down => {
|
|
if (std.mem.indexOf(u8, str[i..], "Down") == 0) {
|
|
try result.append(.{ .key = key.DOWN, .modifiers = modifiers });
|
|
modifiers = 0;
|
|
state = .escape_sequence_end;
|
|
i += 4;
|
|
} else return error.parseDown;
|
|
},
|
|
.left => {
|
|
if (std.mem.indexOf(u8, str[i..], "Left") == 0) {
|
|
try result.append(.{ .key = key.LEFT, .modifiers = modifiers });
|
|
modifiers = 0;
|
|
state = .escape_sequence_end;
|
|
i += 4;
|
|
} else return error.parseLeft;
|
|
},
|
|
.right => {
|
|
if (std.mem.indexOf(u8, str[i..], "Right") == 0) {
|
|
try result.append(.{ .key = key.RIGHT, .modifiers = modifiers });
|
|
modifiers = 0;
|
|
state = .escape_sequence_end;
|
|
i += 5;
|
|
} else return error.parseRight;
|
|
},
|
|
.function_key => {
|
|
switch (str[i]) {
|
|
'0'...'9' => {
|
|
function_key_number *= 10;
|
|
function_key_number += str[i] - '0';
|
|
if (function_key_number < 1 or function_key_number > 35) {
|
|
std.debug.print("function_key_number: {}\n", .{function_key_number});
|
|
return error.FunctionKeyNumber;
|
|
}
|
|
i += 1;
|
|
},
|
|
'>' => {
|
|
const function_key = key.F01 - 1 + function_key_number;
|
|
try result.append(.{ .key = function_key, .modifiers = modifiers });
|
|
modifiers = 0;
|
|
function_key_number = 0;
|
|
state = .base;
|
|
i += 1;
|
|
},
|
|
else => return error.parseFunctionKey,
|
|
}
|
|
},
|
|
.escape_sequence_delimiter => {
|
|
switch (str[i]) {
|
|
'-' => {
|
|
state = .char_or_key_or_modifier;
|
|
i += 1;
|
|
},
|
|
else => {
|
|
return error.parseEscapeSequenceDelimiter;
|
|
},
|
|
}
|
|
},
|
|
.char_or_key_or_modifier => {
|
|
switch (str[i]) {
|
|
'a'...'z', ';', '0'...'9' => {
|
|
try result.append(.{ .key = str[i], .modifiers = modifiers });
|
|
modifiers = 0;
|
|
state = .escape_sequence_end;
|
|
i += 1;
|
|
},
|
|
else => {
|
|
state = .escape_sequence_start;
|
|
},
|
|
}
|
|
},
|
|
.modifier => {
|
|
modifiers |= switch (str[i]) {
|
|
'A' => mod.ALT,
|
|
'C' => mod.CTRL,
|
|
'D' => mod.SUPER,
|
|
'S' => mod.SHIFT,
|
|
else => return error.parseModifier,
|
|
};
|
|
|
|
state = .escape_sequence_delimiter;
|
|
i += 1;
|
|
},
|
|
.escape_sequence_end => {
|
|
switch (str[i]) {
|
|
'>' => {
|
|
state = .base;
|
|
i += 1;
|
|
},
|
|
else => {
|
|
return error.parseEscapeSequenceEnd;
|
|
},
|
|
}
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
const String = std.ArrayList(u8);
|
|
|
|
//An association of an command with a triggering key chord
|
|
const Binding = struct {
|
|
keys: Sequence,
|
|
command: String,
|
|
args: std.ArrayList(u8),
|
|
|
|
fn len(self: Binding) usize {
|
|
return self.keys.items.len;
|
|
}
|
|
|
|
fn execute(self: @This()) !void {
|
|
try command.executeName(self.command.items, .{ .args = .{ .buf = self.args.items } });
|
|
}
|
|
|
|
const MatchResult = enum { match_impossible, match_possible, matched };
|
|
|
|
fn match(self: *const @This(), keys: []const KeyEvent) MatchResult {
|
|
return matchKeySequence(self.keys.items, keys);
|
|
}
|
|
|
|
fn matchKeySequence(self: []const KeyEvent, keys: []const KeyEvent) MatchResult {
|
|
if (self.len == 0) {
|
|
return .match_impossible;
|
|
}
|
|
for (keys, 0..) |key_event, i| {
|
|
if (!key_event.eql(self[i])) {
|
|
return .match_impossible;
|
|
}
|
|
}
|
|
|
|
if (keys.len >= self.len) {
|
|
return .matched;
|
|
} else {
|
|
return .match_possible;
|
|
}
|
|
}
|
|
|
|
fn init(allocator: std.mem.Allocator) @This() {
|
|
return .{
|
|
.keys = Sequence.init(allocator),
|
|
.command = String.init(allocator),
|
|
.args = std.ArrayList(u8).init(allocator),
|
|
};
|
|
}
|
|
|
|
fn deinit(self: *const @This()) void {
|
|
self.keys.deinit();
|
|
self.command.deinit();
|
|
self.args.deinit();
|
|
}
|
|
};
|
|
|
|
const Hint = struct {
|
|
keys: []const u8,
|
|
command: []const u8,
|
|
description: []const u8,
|
|
};
|
|
|
|
//A Collection of keybindings
|
|
const BindingSet = struct {
|
|
allocator: std.mem.Allocator,
|
|
bindings: std.ArrayList(Binding),
|
|
on_match_failure: OnMatchFailure = .ignore,
|
|
current_sequence: std.ArrayList(KeyEvent),
|
|
current_sequence_egc: std.ArrayList(u8),
|
|
last_key_event_timestamp_ms: i64 = 0,
|
|
input_buffer: std.ArrayList(u8),
|
|
|
|
const OnMatchFailure = enum { insert, ignore };
|
|
|
|
const JsonConfig = struct {
|
|
bindings: []const []const []const u8,
|
|
on_match_failure: OnMatchFailure,
|
|
|
|
fn toMode(self: *const @This(), allocator: std.mem.Allocator) !*BindingSet {
|
|
var result = try init(allocator);
|
|
result.on_match_failure = self.on_match_failure;
|
|
var state: enum { key_event, command, args } = .key_event;
|
|
for (self.bindings) |entry| {
|
|
var binding = Binding.init(allocator);
|
|
var args = std.ArrayList(String).init(allocator);
|
|
defer {
|
|
for (args.items) |arg| arg.deinit();
|
|
args.deinit();
|
|
}
|
|
for (entry) |token| {
|
|
switch (state) {
|
|
.key_event => {
|
|
try parseKeySequence(&binding.keys, token);
|
|
state = .command;
|
|
},
|
|
.command => {
|
|
binding.command = String.init(allocator);
|
|
try binding.command.appendSlice(token);
|
|
state = .args;
|
|
},
|
|
.args => {
|
|
var arg = String.init(allocator);
|
|
try arg.appendSlice(token);
|
|
try args.append(arg);
|
|
},
|
|
}
|
|
}
|
|
var args_cbor = std.ArrayList(u8).init(allocator);
|
|
defer args_cbor.deinit();
|
|
const writer = args_cbor.writer();
|
|
try cbor.writeArrayHeader(writer, args.items.len);
|
|
for (args.items) |arg| try cbor.writeValue(writer, arg.items);
|
|
try binding.args.appendSlice(args_cbor.items);
|
|
try result.bindings.append(binding);
|
|
}
|
|
return result;
|
|
}
|
|
};
|
|
|
|
fn hints(self: *@This()) ![]const Hint {
|
|
if (self.hints == null) {
|
|
self.hints = try std.ArrayList(Hint).init(self.allocator);
|
|
}
|
|
|
|
if (self.hints.?.len == self.bindings.items.len) {
|
|
return self.hints.?.items;
|
|
} else {
|
|
self.hints.?.clearRetainingCapacity();
|
|
for (self.bindings.items) |binding| {
|
|
const hint: Hint = .{
|
|
.keys = binding.KeyEvent.toString(self.allocator),
|
|
.command = binding.command,
|
|
.description = "", //TODO lookup command description here
|
|
};
|
|
try self.hints.?.append(hint);
|
|
}
|
|
return self.hints.?.items;
|
|
}
|
|
}
|
|
|
|
fn init(allocator: std.mem.Allocator) !*@This() {
|
|
const self = try allocator.create(@This());
|
|
self.* = .{
|
|
.allocator = allocator,
|
|
.current_sequence = try std.ArrayList(KeyEvent).initCapacity(allocator, 16),
|
|
.current_sequence_egc = try std.ArrayList(u8).initCapacity(allocator, 16),
|
|
.last_key_event_timestamp_ms = std.time.milliTimestamp(),
|
|
.input_buffer = try std.ArrayList(u8).initCapacity(allocator, 16),
|
|
.bindings = std.ArrayList(Binding).init(allocator),
|
|
};
|
|
return self;
|
|
}
|
|
|
|
fn deinit(self: *const BindingSet) void {
|
|
for (self.bindings.items) |binding| {
|
|
binding.deinit();
|
|
}
|
|
self.bindings.deinit();
|
|
self.current_sequence.deinit();
|
|
self.current_sequence_egc.deinit();
|
|
self.input_buffer.deinit();
|
|
self.allocator.destroy(self);
|
|
}
|
|
|
|
// fn parseBindingList(self: *@This(), str: []const u8) !void {
|
|
// var iter = std.mem.tokenizeAny(u8, str, &.{'\n'});
|
|
// while (iter.next()) |token| {
|
|
// try self.bindings.append(try parseBinding(self.allocator, token));
|
|
// }
|
|
// }
|
|
|
|
fn cmd(self: *@This(), name_: []const u8, ctx: command.Context) tp.result {
|
|
try self.flushInputBuffer();
|
|
self.last_cmd = name_;
|
|
if (builtin.is_test == false) {
|
|
try command.executeName(name_, ctx);
|
|
}
|
|
}
|
|
|
|
const max_key_sequence_time_interval = 750;
|
|
const max_input_buffer_size = 1024;
|
|
|
|
fn insertBytes(self: *@This(), bytes: []const u8) !void {
|
|
if (self.input_buffer.items.len + 4 > max_input_buffer_size)
|
|
try self.flushInputBuffer();
|
|
try self.input_buffer.appendSlice(bytes);
|
|
}
|
|
|
|
fn flushInputBuffer(self: *@This()) !void {
|
|
const Static = struct {
|
|
var insert_chars_id: ?command.ID = null;
|
|
};
|
|
if (self.input_buffer.items.len > 0) {
|
|
defer self.input_buffer.clearRetainingCapacity();
|
|
const id = Static.insert_chars_id orelse
|
|
command.get_id_cache("insert_chars", &Static.insert_chars_id) orelse {
|
|
return tp.exit_error(error.InputTargetNotFound, null);
|
|
};
|
|
if (builtin.is_test == false) {
|
|
try command.execute(id, command.fmt(.{self.input_buffer.items}));
|
|
}
|
|
}
|
|
}
|
|
|
|
fn receive(self: *@This(), _: tp.pid_ref, m: tp.message) error{Exit}!bool {
|
|
var evtype: u32 = 0;
|
|
var keypress: u32 = 0;
|
|
var egc: u32 = 0;
|
|
var modifiers: u32 = 0;
|
|
var text: []const u8 = "";
|
|
|
|
if (try m.match(.{
|
|
"I",
|
|
tp.extract(&evtype),
|
|
tp.extract(&keypress),
|
|
tp.extract(&egc),
|
|
tp.string,
|
|
tp.extract(&modifiers),
|
|
})) {
|
|
self.registerKeyEvent(@intCast(egc), .{
|
|
.event_type = evtype,
|
|
.key = keypress,
|
|
.modifiers = modifiers,
|
|
}) catch |e| return tp.exit_error(e, @errorReturnTrace());
|
|
} else if (try m.match(.{"F"})) {
|
|
self.flushInputBuffer() catch |e| return tp.exit_error(e, @errorReturnTrace());
|
|
} else if (try m.match(.{ "system_clipboard", tp.extract(&text) })) {
|
|
self.flushInputBuffer() catch |e| return tp.exit_error(e, @errorReturnTrace());
|
|
self.insertBytes(text) catch |e| return tp.exit_error(e, @errorReturnTrace());
|
|
self.flushInputBuffer() catch |e| return tp.exit_error(e, @errorReturnTrace());
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//register a key press and try to match it with a binding
|
|
fn registerKeyEvent(self: *BindingSet, egc: u8, event: KeyEvent) !void {
|
|
|
|
//clear key history if enough time has passed since last key press
|
|
const timestamp = std.time.milliTimestamp();
|
|
if (self.last_key_event_timestamp_ms - timestamp > max_key_sequence_time_interval) {
|
|
try self.abortCurrentSequence(.timeout, egc, event);
|
|
}
|
|
self.last_key_event_timestamp_ms = timestamp;
|
|
|
|
try self.current_sequence.append(event);
|
|
try self.current_sequence_egc.append(egc);
|
|
|
|
var all_matches_impossible = true;
|
|
for (self.bindings.items) |binding| blk: {
|
|
switch (binding.match(self.current_sequence.items)) {
|
|
.matched => {
|
|
if (!builtin.is_test) {
|
|
try binding.execute();
|
|
}
|
|
self.current_sequence.clearRetainingCapacity();
|
|
self.current_sequence_egc.clearRetainingCapacity();
|
|
break :blk;
|
|
},
|
|
.match_possible => {
|
|
all_matches_impossible = false;
|
|
},
|
|
.match_impossible => {},
|
|
}
|
|
}
|
|
if (all_matches_impossible) {
|
|
try self.abortCurrentSequence(.match_impossible, egc, event);
|
|
}
|
|
}
|
|
|
|
const AbortType = enum { timeout, match_impossible };
|
|
fn abortCurrentSequence(self: *@This(), abort_type: AbortType, egc: u8, key_event: KeyEvent) anyerror!void {
|
|
_ = egc;
|
|
_ = key_event;
|
|
if (abort_type == .match_impossible) {
|
|
switch (self.on_match_failure) {
|
|
.insert => {
|
|
try self.insertBytes(self.current_sequence_egc.items);
|
|
self.current_sequence_egc.clearRetainingCapacity();
|
|
self.current_sequence.clearRetainingCapacity();
|
|
},
|
|
.ignore => {
|
|
self.current_sequence.clearRetainingCapacity();
|
|
self.current_sequence_egc.clearRetainingCapacity();
|
|
},
|
|
// .fallback_mode => |fallback_mode_name| {
|
|
// _ = fallback_mode_name;
|
|
// @panic("This feature not supported yet");
|
|
//const fallback_mode = self.activeNamespace().get(fallback_mode_name).?;
|
|
//try self.registerKeyEvent(fallback_mode, egc, key_event);
|
|
// },
|
|
}
|
|
} else if (abort_type == .timeout) {
|
|
try self.insertBytes(self.current_sequence_egc.items);
|
|
self.current_sequence_egc.clearRetainingCapacity();
|
|
self.current_sequence.clearRetainingCapacity();
|
|
}
|
|
}
|
|
};
|
|
|
|
//A collection of various modes under a single namespace, such as "vim" or "emacs"
|
|
const Namespace = HashMap(*BindingSet);
|
|
const HashMap = std.StringArrayHashMap;
|
|
|
|
//Data structure for mapping key events to keybindings
|
|
const Bindings = struct {
|
|
allocator: std.mem.Allocator,
|
|
active_namespace: usize,
|
|
active_mode: usize,
|
|
namespaces: HashMap(Namespace),
|
|
|
|
//lists namespaces
|
|
fn listNamespaces(self: *const @This()) []const []const u8 {
|
|
return self.namespaces.keys();
|
|
}
|
|
|
|
fn selectNamespace(self: *Bindings, namespace_name: []const u8) error{NotFound}!void {
|
|
for (self.namespaces.keys(), 0..) |name, i| {
|
|
if (std.mem.eql(u8, name, namespace_name)) {
|
|
self.active_namespace = i;
|
|
return;
|
|
}
|
|
}
|
|
return error.NotFound;
|
|
}
|
|
|
|
fn activeNamespace(self: *const Bindings) Namespace {
|
|
return self.namespaces.values()[self.active_namespace];
|
|
}
|
|
|
|
fn selectMode(self: *Bindings, mode_name: []const u8) error{NotFound}!void {
|
|
const namespace = self.activeNamespace();
|
|
for (namespace.keys(), 0..) |name, i| {
|
|
if (std.mem.eql(u8, name, mode_name)) {
|
|
self.active_mode = i;
|
|
return;
|
|
}
|
|
}
|
|
return error.NotFound;
|
|
}
|
|
|
|
fn activeMode(self: *Bindings) *BindingSet {
|
|
return self.activeNamespace().values()[self.active_mode];
|
|
}
|
|
|
|
fn init(allocator: std.mem.Allocator) !*Bindings {
|
|
const self: *@This() = try allocator.create(@This());
|
|
self.* = .{
|
|
.allocator = allocator,
|
|
.active_namespace = 0,
|
|
.active_mode = 0,
|
|
.namespaces = std.StringArrayHashMap(Namespace).init(allocator),
|
|
};
|
|
return self;
|
|
}
|
|
|
|
fn addMode(self: *@This(), namespace_name: []const u8, mode_name: []const u8, mode_bindings: *BindingSet) !void {
|
|
const namespace = self.namespaces.getPtr(namespace_name) orelse blk: {
|
|
try self.namespaces.putNoClobber(try self.allocator.dupe(u8, namespace_name), Namespace.init(self.allocator));
|
|
break :blk self.namespaces.getPtr(namespace_name).?;
|
|
};
|
|
try namespace.putNoClobber(try self.allocator.dupe(u8, mode_name), mode_bindings);
|
|
}
|
|
|
|
fn deinit(self: *Bindings) void {
|
|
for (self.namespaces.values()) |*namespace| {
|
|
for (namespace.values()) |mode_bindings|
|
|
mode_bindings.deinit();
|
|
for (namespace.keys()) |mode_name|
|
|
self.allocator.free(mode_name);
|
|
namespace.deinit();
|
|
}
|
|
for (self.namespaces.keys()) |namespace|
|
|
self.allocator.free(namespace);
|
|
self.namespaces.deinit();
|
|
self.allocator.destroy(self);
|
|
}
|
|
|
|
fn loadJson(self: *@This(), json_string: []const u8) !void {
|
|
const parsed = try std.json.parseFromSlice(std.json.Value, self.allocator, json_string, .{});
|
|
defer parsed.deinit();
|
|
if (parsed.value != .object) return error.notObject;
|
|
for (parsed.value.object.values(), 0..) |namespace, i| {
|
|
if (namespace != .object) return error.namespaceNotObject;
|
|
for (namespace.object.values(), 0..) |mode_bindings, j| {
|
|
const mode_config = try std.json.parseFromValue(BindingSet.JsonConfig, self.allocator, mode_bindings, .{});
|
|
defer mode_config.deinit();
|
|
const parsed_mode = try mode_config.value.toMode(self.allocator);
|
|
try self.addMode(parsed.value.object.keys()[i], namespace.object.keys()[j], parsed_mode);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
const expectEqual = std.testing.expectEqual;
|
|
|
|
const parse_test_cases = .{
|
|
//input, expected
|
|
.{ "j", &.{KeyEvent{ .key = 'j' }} },
|
|
.{ "jk", &.{ KeyEvent{ .key = 'j' }, KeyEvent{ .key = 'k' } } },
|
|
.{ "<Space>", &.{KeyEvent{ .key = key.SPACE }} },
|
|
.{ "<C-x><C-c>", &.{ KeyEvent{ .key = 'x', .modifiers = mod.CTRL }, KeyEvent{ .key = 'c', .modifiers = mod.CTRL } } },
|
|
.{ "<A-x><Tab>", &.{ KeyEvent{ .key = 'x', .modifiers = mod.ALT }, KeyEvent{ .key = key.TAB } } },
|
|
.{ "<S-A-x><D-Del>", &.{ KeyEvent{ .key = 'x', .modifiers = mod.ALT | mod.SHIFT }, KeyEvent{ .key = key.DEL, .modifiers = mod.SUPER } } },
|
|
};
|
|
|
|
test "parse" {
|
|
const alloc = std.testing.allocator;
|
|
inline for (parse_test_cases) |case| {
|
|
var parsed = Sequence.init(alloc);
|
|
defer parsed.deinit();
|
|
try parseKeySequence(&parsed, case[0]);
|
|
const expected: []const KeyEvent = case[1];
|
|
const actual: []const KeyEvent = parsed.items;
|
|
try expectEqual(expected.len, actual.len);
|
|
for (expected, 0..) |expected_event, i| {
|
|
try expectEqual(expected_event, actual[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
const match_test_cases = .{
|
|
//input, binding, expected_result
|
|
.{ "j", "j", .matched },
|
|
.{ "j", "jk", .match_possible },
|
|
.{ "kjk", "jk", .match_impossible },
|
|
.{ "k<C-v>", "<C-x><C-c>", .match_impossible },
|
|
.{ "<C-x>c", "<C-x><C-c>", .match_impossible },
|
|
.{ "<C-x><C-c>", "<C-x><C-c>", .matched },
|
|
.{ "<C-x><A-a>", "<C-x><A-a><Tab>", .match_possible },
|
|
.{ "<C-o>", "<C-o>", .matched },
|
|
};
|
|
|
|
test "match" {
|
|
const alloc = std.testing.allocator;
|
|
inline for (match_test_cases) |case| {
|
|
var input = Sequence.init(alloc);
|
|
defer input.deinit();
|
|
var binding = Sequence.init(alloc);
|
|
defer binding.deinit();
|
|
|
|
try parseKeySequence(&input, case[0]);
|
|
try parseKeySequence(&binding, case[1]);
|
|
try expectEqual(case[2], Binding.matchKeySequence(binding.items, input.items));
|
|
}
|
|
}
|
|
|
|
test "json" {
|
|
const alloc = std.testing.allocator;
|
|
var bindings = try Bindings.init(alloc);
|
|
defer bindings.deinit();
|
|
try bindings.loadJson(@embedFile("keybindings.json"));
|
|
const mode_binding_set = bindings.activeMode();
|
|
try mode_binding_set.registerKeyEvent('j', .{ .key = 'j' });
|
|
try mode_binding_set.registerKeyEvent('k', .{ .key = 'k' });
|
|
try mode_binding_set.registerKeyEvent('g', .{ .key = 'g' });
|
|
try mode_binding_set.registerKeyEvent('i', .{ .key = 'i' });
|
|
try mode_binding_set.registerKeyEvent(0, .{ .key = 'i', .modifiers = mod.CTRL });
|
|
}
|