helix

diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs
index 7e968482..25875d45 100644
--- a/helix-term/src/application.rs
+++ b/helix-term/src/application.rs

@@ -63,6 +63,7 @@ type Terminal = tui::terminal::Terminal<TerminalBackend>;

pub struct Application {

compositor: Compositor,

+ keymaps: Keymaps,

terminal: Terminal,

pub editor: Editor,

@@ -156,7 +157,8 @@ impl Application {

let keys = Box::new(Map::new(Arc::clone(&config), |config: &Config| {

&config.keys

}));

- let editor_view = Box::new(ui::EditorView::new(Keymaps::new(keys)));

+ let keymaps = Keymaps::new(keys);

+ let editor_view = Box::new(ui::EditorView::default());

compositor.push(editor_view);

if args.load_tutor {

@@ -241,6 +243,7 @@ impl Application {

.context("build signal handler")?;

let app = Self {

+ keymaps,

compositor,

terminal,

editor,

@@ -261,6 +264,7 @@ impl Application {

async fn render(&mut self) {

let mut cx = crate::compositor::Context {

+ keymaps: &mut self.keymaps,

editor: &mut self.editor,

jobs: &mut self.jobs,

scroll: None,

@@ -521,6 +525,7 @@ impl Application {

pub async fn handle_idle_timeout(&mut self) {

let mut cx = crate::compositor::Context {

+ keymaps: &mut self.keymaps,

editor: &mut self.editor,

jobs: &mut self.jobs,

scroll: None,

@@ -641,6 +646,7 @@ impl Application {

event: Result<CrosstermEvent, crossterm::ErrorKind>,

) {

let mut cx = crate::compositor::Context {

+ keymaps: &mut self.keymaps,

editor: &mut self.editor,

jobs: &mut self.jobs,

scroll: None,

diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs
index 1bd73652..f77e27a2 100644
--- a/helix-term/src/commands.rs
+++ b/helix-term/src/commands.rs

@@ -53,7 +53,7 @@ use crate::{

compositor::{self, Component, Compositor},

filter_picker_entry,

job::Callback,

- keymap::ReverseKeymap,

+ keymap::{Keymaps, ReverseKeymap},

ui::{

self, editor::InsertEvent, lsp::SignatureHelp, overlay::overlaid, CompletionItem, Picker,

Popup, Prompt, PromptEvent,

@@ -81,6 +81,8 @@ use tokio_stream::wrappers::UnboundedReceiverStream;

pub type OnKeyCallback = Box<dyn FnOnce(&mut Context, KeyEvent)>;

pub struct Context<'a> {

+ pub keymaps: &'a mut Keymaps,

pub register: Option<char>,

pub count: Option<NonZeroUsize>,

pub editor: &'a mut Editor,

@@ -196,6 +198,7 @@ impl MappableCommand {

let args: Vec<Cow<str>> = args.iter().map(Cow::from).collect();

if let Some(command) = typed::TYPABLE_COMMAND_MAP.get(name.as_str()) {

let mut cx = compositor::Context {

+ keymaps: cx.keymaps,

editor: cx.editor,

jobs: cx.jobs,

scroll: None,

@@ -2716,9 +2719,8 @@ pub fn command_palette(cx: &mut Context) {

cx.callback = Some(Box::new(

move |compositor: &mut Compositor, cx: &mut compositor::Context| {

- let keymap = compositor.find::<ui::EditorView>().unwrap().keymaps.map()

- [&cx.editor.mode]

- .reverse_map();

+ let keymap =

+ cx.keymaps.map()[&crate::keymap::Domain::Mode(cx.editor.mode)].reverse_map();

let mut commands: Vec<MappableCommand> = MappableCommand::STATIC_COMMAND_LIST.into();

commands.extend(typed::TYPABLE_COMMAND_LIST.iter().map(|cmd| {

@@ -2733,6 +2735,7 @@ pub fn command_palette(cx: &mut Context) {

let mut ctx = Context {

count,

+ keymaps: cx.keymaps,

editor: cx.editor,

callback: None,

on_next_key_callback: None,

diff --git a/helix-term/src/compositor.rs b/helix-term/src/compositor.rs
index bcb3e449..904d22ba 100644
--- a/helix-term/src/compositor.rs
+++ b/helix-term/src/compositor.rs

@@ -15,12 +15,13 @@ pub enum EventResult {

Consumed(Option<Callback>),

}

-use crate::job::Jobs;

+use crate::{job::Jobs, keymap::Keymaps};

use helix_view::Editor;

pub use helix_view::input::Event;

pub struct Context<'a> {

+ pub keymaps: &'a mut Keymaps,

pub editor: &'a mut Editor,

pub scroll: Option<usize>,

pub jobs: &'a mut Jobs,

diff --git a/helix-term/src/ui/editor.rs b/helix-term/src/ui/editor.rs
index 5b5cda93..515297c3 100644
--- a/helix-term/src/ui/editor.rs
+++ b/helix-term/src/ui/editor.rs

@@ -3,7 +3,7 @@ use crate::{

compositor::{Component, Context, Event, EventResult},

job::{self, Callback},

key,

- keymap::{KeymapResult, Keymaps},

+ keymap::KeymapResult,

ui::{

document::{render_document, LinePos, TextRenderer, TranslatedPosition},

Completion, ProgressSpinners,

@@ -37,7 +37,6 @@ use super::{completion::CompletionItem, statusline};

use super::{document::LineDecoration, lsp::SignatureHelp};

pub struct EditorView {

- pub keymaps: Keymaps,

on_next_key: Option<OnKeyCallback>,

pseudo_pending: Vec<KeyEvent>,

pub(crate) last_insert: (commands::MappableCommand, Vec<InsertEvent>),

@@ -58,14 +57,7 @@ pub enum InsertEvent {

impl Default for EditorView {

fn default() -> Self {

- Self::new(Keymaps::default())

- }

-impl EditorView {

- pub fn new(keymaps: Keymaps) -> Self {

Self {

- keymaps,

on_next_key: None,

pseudo_pending: Vec::new(),

last_insert: (commands::MappableCommand::normal_mode, Vec::new()),

@@ -73,7 +65,9 @@ impl EditorView {

spinners: ProgressSpinners::default(),

}

+impl EditorView {

pub fn spinners_mut(&mut self) -> &mut ProgressSpinners {

&mut self.spinners

}

@@ -786,7 +780,7 @@ impl EditorView {

}

- /// Handle events by looking them up in `self.keymaps`. Returns None

+ /// Handle events by looking them up in `cxt.keymaps`. Returns None

/// if event was handled (a command was executed or a subkeymap was

/// activated). Only KeymapResult::{NotFound, Cancelled} is returned

/// otherwise.

@@ -797,9 +791,9 @@ impl EditorView {

event: KeyEvent,

) -> Option<KeymapResult> {

let mut last_mode = mode;

- self.pseudo_pending.extend(self.keymaps.pending());

- let key_result = self.keymaps.get(mode, event);

- cxt.editor.autoinfo = self.keymaps.sticky().map(|node| node.infobox());

+ self.pseudo_pending.extend(cxt.keymaps.pending());

+ let key_result = cxt.keymaps.get(mode, event);

+ cxt.editor.autoinfo = cxt.keymaps.sticky().map(|node| node.infobox());

let mut execute_command = |command: &commands::MappableCommand| {

command.execute(cxt);

@@ -864,7 +858,7 @@ impl EditorView {

Some(ch) => commands::insert::insert_char(cx, ch),

None => {

if let KeymapResult::Matched(command) =

- self.keymaps.get(Mode::Insert, ev)

+ cx.keymaps.get_by_mode(Mode::Insert, ev)

{

command.execute(cx);

}

@@ -886,7 +880,7 @@ impl EditorView {

std::num::NonZeroUsize::new(cxt.editor.count.map_or(i, |c| c.get() * 10 + i));

}

// special handling for repeat operator

- (key!('.'), _) if self.keymaps.pending().is_empty() => {

+ (key!('.'), _) if cxt.keymaps.pending().is_empty() => {

for _ in 0..cxt.editor.count.map_or(1, NonZeroUsize::into) {

// first execute whatever put us into insert mode

self.last_insert.0.execute(cxt);

@@ -944,7 +938,7 @@ impl EditorView {

cxt.register = cxt.editor.selected_register.take();

self.handle_keymap_event(mode, cxt, event);

- if self.keymaps.pending().is_empty() {

+ if cxt.keymaps.pending().is_empty() {

cxt.editor.count = None

} else {

cxt.editor.selected_register = cxt.register.take();

@@ -1225,6 +1219,7 @@ impl Component for EditorView {

context: &mut crate::compositor::Context,

) -> EventResult {

let mut cx = commands::Context {

+ keymaps: context.keymaps,

editor: context.editor,

count: None,

@@ -1280,6 +1275,7 @@ impl Component for EditorView {

let res = {

// use a fake context here

let mut cx = Context {

+ keymaps: cx.keymaps,

editor: cx.editor,

jobs: cx.jobs,

scroll: None,

@@ -1445,7 +1441,7 @@ impl Component for EditorView {

if let Some(count) = cx.editor.count {

disp.push_str(&count.to_string())

}

- for key in self.keymaps.pending() {

+ for key in cx.keymaps.pending() {

disp.push_str(&key.key_sequence_format());

}

for key in &self.pseudo_pending {