vimamsa 0.1.26 → 0.1.27
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/.github/workflows/appimage.yml +93 -0
- data/.gitignore +4 -1
- data/Dockerfile +7 -4
- data/README.md +62 -16
- data/custom_example.rb +43 -13
- data/doc/TODO.md +461 -0
- data/doc/bundling_plan.md +569 -0
- data/doc/key_bindings_report_plan.md +168 -0
- data/doc/missing_vim_bindings.md +71 -0
- data/doc/modules_settings_plan.md +433 -0
- data/doc/refactor_dedup_plan.md +117 -0
- data/doc/unused_code_plan.md +120 -0
- data/doc/vim_compatibility_plan.md +296 -0
- data/doc/vimlike_vim_conflicts.md +254 -0
- data/doc/vm_snapshots_plan.md +146 -0
- data/exe/run_tests.rb +117 -3
- data/exe/vimamsa +24 -4
- data/fonts/OFL-Oxanium.txt +93 -0
- data/fonts/Oxanium[wght].ttf +0 -0
- data/icon.png +0 -0
- data/img/demo.gif +0 -0
- data/lang/hyperplaintext.lang +6 -0
- data/lib/vimamsa/ack.rb +11 -1
- data/lib/vimamsa/actions.rb +4 -1
- data/lib/vimamsa/appimage_env.rb +35 -0
- data/lib/vimamsa/audio.rb +2 -5
- data/lib/vimamsa/bookmarks.rb +302 -0
- data/lib/vimamsa/buffer.rb +593 -82
- data/lib/vimamsa/buffer_changetext.rb +102 -42
- data/lib/vimamsa/buffer_cursor.rb +7 -0
- data/lib/vimamsa/buffer_list.rb +4 -0
- data/lib/vimamsa/buffer_manager.rb +4 -1
- data/lib/vimamsa/bundled_fonts.rb +32 -0
- data/lib/vimamsa/clipboard.rb +3 -0
- data/lib/vimamsa/conf.rb +59 -3
- data/lib/vimamsa/constants.rb +3 -0
- data/lib/vimamsa/crash_handler.rb +149 -0
- data/lib/vimamsa/debug.rb +4 -1
- data/lib/vimamsa/desktop_install.rb +96 -0
- data/lib/vimamsa/diff_buffer.rb +39 -10
- data/lib/vimamsa/easy_jump.rb +3 -0
- data/lib/vimamsa/editor.rb +263 -57
- data/lib/vimamsa/encrypt.rb +78 -29
- data/lib/vimamsa/file_finder.rb +4 -19
- data/lib/vimamsa/file_history.rb +3 -0
- data/lib/vimamsa/file_manager.rb +30 -15
- data/lib/vimamsa/fold.rb +226 -0
- data/lib/vimamsa/gui.rb +520 -106
- data/lib/vimamsa/gui_command_line.rb +208 -0
- data/lib/vimamsa/gui_dialog.rb +94 -42
- data/lib/vimamsa/gui_file_panel.rb +356 -25
- data/lib/vimamsa/gui_form_generator.rb +59 -35
- data/lib/vimamsa/gui_func_panel.rb +67 -22
- data/lib/vimamsa/gui_image.rb +3 -0
- data/lib/vimamsa/gui_keylog_panel.rb +246 -0
- data/lib/vimamsa/gui_menu.rb +23 -11
- data/lib/vimamsa/gui_select_window.rb +19 -48
- data/lib/vimamsa/gui_settings.rb +78 -37
- data/lib/vimamsa/gui_sourceview.rb +273 -19
- data/lib/vimamsa/gui_sourceview_autocomplete.rb +319 -90
- data/lib/vimamsa/gui_text.rb +63 -2
- data/lib/vimamsa/gui_theme.rb +606 -0
- data/lib/vimamsa/hook.rb +3 -0
- data/lib/vimamsa/hyper_plain_text.rb +3 -0
- data/lib/vimamsa/key_actions.rb +112 -13
- data/lib/vimamsa/key_binding_tree.rb +242 -215
- data/lib/vimamsa/key_bindings_notepad.rb +43 -0
- data/lib/vimamsa/key_bindings_report.rb +261 -0
- data/lib/vimamsa/key_bindings_vim.rb +354 -0
- data/lib/vimamsa/key_bindings_vimlike.rb +65 -9
- data/lib/vimamsa/langservp.rb +271 -54
- data/lib/vimamsa/macro.rb +3 -0
- data/lib/vimamsa/main.rb +14 -8
- data/lib/vimamsa/rbvma.rb +26 -1
- data/lib/vimamsa/search.rb +3 -0
- data/lib/vimamsa/search_replace.rb +11 -10
- data/lib/vimamsa/string_util.rb +120 -40
- data/lib/vimamsa/terminal.rb +3 -0
- data/lib/vimamsa/test_framework.rb +28 -2
- data/lib/vimamsa/tests.rb +3 -0
- data/lib/vimamsa/text_objects.rb +353 -0
- data/lib/vimamsa/text_transforms.rb +14 -0
- data/lib/vimamsa/util.rb +46 -7
- data/lib/vimamsa/version.rb +1 -1
- data/lib/vimamsa.rb +0 -1
- data/modules/color_highlight/color_highlight.rb +118 -0
- data/modules/color_highlight/color_highlight_info.rb +3 -0
- data/modules/dictation/dictation.rb +1054 -0
- data/modules/dictation/dictation_info.rb +3 -0
- data/modules/dictation/whisper_worker.py +273 -0
- data/modules/ollama/ollama.rb +107 -0
- data/modules/ollama/ollama_info.rb +3 -0
- data/modules/tts/tts.rb +119 -0
- data/modules/tts/tts_info.rb +3 -0
- data/run_e2e_vm.sh +28 -0
- data/run_tests_vm.sh +130 -0
- data/scripts/appimage/AppRun +54 -0
- data/scripts/appimage/Dockerfile +18 -0
- data/scripts/appimage/build.sh +19 -0
- data/scripts/appimage/build_in_container.sh +192 -0
- data/scripts/appimage/smoke_test.sh +27 -0
- data/scripts/demo/demo_steps.txt +59 -0
- data/scripts/demo/record_demo.rb +177 -0
- data/scripts/demo/shapes.rb +28 -0
- data/styles/134272-molokai.xml +3 -0
- data/styles/molokai_cyber.xml +48 -0
- data/styles/molokai_edit.xml +1 -0
- data/tests/support/virtual_keyboard.rb +254 -0
- data/tests/support/virtual_mic.rb +67 -0
- data/tests/test_ack.rb +22 -0
- data/tests/test_auto_format.rb +122 -0
- data/tests/test_autocomplete.rb +211 -0
- data/tests/test_autosave.rb +145 -0
- data/tests/test_basic_editing.rb +33 -3
- data/tests/test_bookmarks.rb +206 -0
- data/tests/test_bracket_match.rb +85 -0
- data/tests/test_bundling.rb +92 -0
- data/tests/test_color_highlight.rb +92 -0
- data/tests/test_command_line.rb +79 -0
- data/tests/test_command_line_file.rb +27 -0
- data/tests/test_context_menu_file.rb +129 -0
- data/tests/test_copy_paste.rb +80 -0
- data/tests/test_crash_handler.rb +39 -0
- data/tests/test_custom_two_phase.rb +92 -0
- data/tests/test_dialog_callback_errors.rb +44 -0
- data/tests/test_dictation.rb +294 -0
- data/tests/test_diff_buffer_name.rb +51 -0
- data/tests/test_double_click.rb +41 -0
- data/tests/test_drag_selection.rb +125 -0
- data/tests/test_e2e_cmdline.rb +116 -0
- data/tests/test_e2e_dictation.rb +98 -0
- data/tests/test_e2e_replace_char.rb +58 -0
- data/tests/test_extract_file_links.rb +55 -0
- data/tests/test_file_format.rb +217 -0
- data/tests/test_file_manager.rb +72 -0
- data/tests/test_file_panel.rb +269 -0
- data/tests/test_flash.rb +78 -0
- data/tests/test_fold.rb +111 -0
- data/tests/test_font_refresh.rb +56 -0
- data/tests/test_func_panel.rb +68 -0
- data/tests/test_grep_apply.rb +46 -0
- data/tests/test_gtk_sync.rb +126 -0
- data/tests/test_hpt_highlight_visible.rb +75 -0
- data/tests/test_hpt_link_highlight.rb +82 -0
- data/tests/test_jump_to_file.rb +41 -0
- data/tests/test_key_bindings.rb +208 -0
- data/tests/test_keylog_panel.rb +101 -0
- data/tests/test_lsp_clangd.rb +281 -0
- data/tests/test_lsp_jump.rb +87 -0
- data/tests/test_lsp_position_encoding.rb +49 -0
- data/tests/test_lsp_symbols.rb +68 -0
- data/tests/test_macro.rb +137 -0
- data/tests/test_markdown_highlight.rb +57 -0
- data/tests/test_mode_badge.rb +41 -0
- data/tests/test_notepad_bindings.rb +67 -0
- data/tests/test_popup_queue.rb +51 -0
- data/tests/test_random_edit.rb +109 -0
- data/tests/test_revert.rb +127 -0
- data/tests/test_startup_file.rb +58 -0
- data/tests/test_status_area.rb +50 -0
- data/tests/test_text_objects.rb +163 -0
- data/tests/test_text_transforms.rb +329 -0
- data/tests/test_tts.rb +68 -0
- data/tests/test_vim_bindings.rb +252 -0
- data/tests/test_vim_conflicts.rb +63 -0
- data/tests/test_window_layout.rb +219 -0
- data/vimamsa.gemspec +3 -1
- data/vm_guest_run.sh +109 -0
- metadata +112 -10
|
@@ -0,0 +1,43 @@
|
|
|
1
|
+
# Notepad scheme: ordinary non-modal editing (gedit/notepad style).
|
|
2
|
+
# Inherits all modes, infrastructure and bindings from the vimlike scheme,
|
|
3
|
+
# then overrides so the editor stays permanently in insert mode.
|
|
4
|
+
# Selected via cnf.keybindings.scheme = "notepad" (applied on restart).
|
|
5
|
+
require "vimamsa/key_bindings_vimlike"
|
|
6
|
+
|
|
7
|
+
module Vimamsa
|
|
8
|
+
vma.kbd.set_default_mode(:insert)
|
|
9
|
+
vma.kbd.__set_mode(:insert)
|
|
10
|
+
|
|
11
|
+
# esc never leaves insert mode: clear selection, dismiss autocomplete popup
|
|
12
|
+
reg_act(:notepad_escape, proc {
|
|
13
|
+
buf.end_selection
|
|
14
|
+
v = vma.buf.view
|
|
15
|
+
v.hide_completions if v.respond_to?(:hide_completions)
|
|
16
|
+
}, "Clear selection and dismiss popups")
|
|
17
|
+
|
|
18
|
+
# Replaces the "I esc" leaf of vimlike's "I esc || I ctrl!" => :prev_mode
|
|
19
|
+
bindkey "I esc", :notepad_escape
|
|
20
|
+
# In vimlike, releasing bare ctrl in insert mode returns to command mode.
|
|
21
|
+
# Harmless here (mode stack is [:insert], to_previous_mode won't pop) but
|
|
22
|
+
# remove it so ctrl-release doesn't dispatch a pointless action.
|
|
23
|
+
unbindkey "I ctrl!"
|
|
24
|
+
|
|
25
|
+
add_keys "notepad", {
|
|
26
|
+
# Rebinds over conflicting vimlike insert-mode bindings
|
|
27
|
+
# (bindkey on an existing chord overwrites the leaf)
|
|
28
|
+
"I ctrl-f" => :find_in_buffer, # was move FORWARD_CHAR
|
|
29
|
+
"I ctrl-h" => :gui_search_replace, # was autocp trigger (ctrl-space remains)
|
|
30
|
+
"I ctrl-n" => :buf_new, # was move_next_line
|
|
31
|
+
"I ctrl-a" => :select_all, # was jump_beginning_of_line
|
|
32
|
+
"I ctrl-q" => :quit,
|
|
33
|
+
"I ctrl-shift-z || I ctrl-shift-Z" => :redo, # shift+z may arrive uppercase
|
|
34
|
+
"I delete" => :insert_delete,
|
|
35
|
+
|
|
36
|
+
"I home" => "buf.end_selection; buf.jump(BEGINNING_OF_LINE)",
|
|
37
|
+
"I end" => "buf.end_selection; buf.jump(END_OF_LINE)",
|
|
38
|
+
"I shift-home" => "buf.continue_selection; buf.jump(BEGINNING_OF_LINE)",
|
|
39
|
+
"I shift-end" => "buf.continue_selection; buf.jump(END_OF_LINE)",
|
|
40
|
+
"I ctrl-home" => :jump_to_start_of_buffer,
|
|
41
|
+
"I ctrl-end" => :jump_to_end_of_buffer,
|
|
42
|
+
}
|
|
43
|
+
end # module Vimamsa
|
|
@@ -0,0 +1,261 @@
|
|
|
1
|
+
|
|
2
|
+
module Vimamsa
|
|
3
|
+
# Editor-side reports of the key binding tree contents, shown as buffers.
|
|
4
|
+
# Kept out of key_binding_tree.rb so the tree stays free of editor/GUI calls.
|
|
5
|
+
|
|
6
|
+
def show_free_key_bindings()
|
|
7
|
+
kbd_s = "❙Free key binding slots❙\n"
|
|
8
|
+
kbd_s << "\n⦁[Mode] <prefix> : <free keys>⦁\n"
|
|
9
|
+
kbd_s << "[B]=Browse, [C]=Command, [I]=Insert, [V]=Visual\n"
|
|
10
|
+
kbd_s << "Free = not yet bound under that prefix\n"
|
|
11
|
+
kbd_s << "===============================================\n"
|
|
12
|
+
kbd_s << vma.kbd.get_free_bindings
|
|
13
|
+
kbd_s << "\n"
|
|
14
|
+
b = create_new_buffer(kbd_s, "free-key-bindings")
|
|
15
|
+
gui_set_file_lang(b.id, "hyperplaintext")
|
|
16
|
+
end
|
|
17
|
+
|
|
18
|
+
def show_key_bindings()
|
|
19
|
+
kbd_s = "❙Key bindings❙\n"
|
|
20
|
+
kbd_s << "\n⦁[Mode] <keys> : <action>⦁\n"
|
|
21
|
+
done = []
|
|
22
|
+
|
|
23
|
+
kbd_s << "[B]=Browse, [C]=Command, [I]=Insert, [V]=Visual\n"
|
|
24
|
+
kbd_s << "<key>!: Press <key> once, release before pressing any other keys\n"
|
|
25
|
+
kbd_s << "===============================================\n"
|
|
26
|
+
kbd_s << "◼ Basic\n"
|
|
27
|
+
kbd_s << "◼◼ Command mode\n"
|
|
28
|
+
|
|
29
|
+
x = vma.kbd.get_by_keywords(modes: ["C"], keywords: ["intro"])
|
|
30
|
+
done.concat(x.lines); kbd_s << x
|
|
31
|
+
|
|
32
|
+
kbd_s << "\n"
|
|
33
|
+
kbd_s << "◼◼ Insert mode\n"
|
|
34
|
+
x = vma.kbd.get_by_keywords(modes: ["I"], keywords: ["intro"])
|
|
35
|
+
done.concat(x.lines); kbd_s << x
|
|
36
|
+
kbd_s << "\n"
|
|
37
|
+
kbd_s << "◼◼ Visual mode\n"
|
|
38
|
+
x = vma.kbd.get_by_keywords(modes: ["V"], keywords: ["intro"])
|
|
39
|
+
done.concat(x.lines); kbd_s << x
|
|
40
|
+
kbd_s << "\n"
|
|
41
|
+
|
|
42
|
+
kbd_s << "◼ Hyper Plaintext\n"
|
|
43
|
+
x = vma.kbd.get_by_keywords(modes: ["C"], keywords: ["hyperplaintext"])
|
|
44
|
+
x2 = vma.kbd.get_by_keywords(modes: ["V"], keywords: ["hyperplaintext"])
|
|
45
|
+
done.concat(x.lines); kbd_s << x << "\n" << x2
|
|
46
|
+
kbd_s << "\n"
|
|
47
|
+
|
|
48
|
+
kbd_s << "◼ Core\n"
|
|
49
|
+
x = vma.kbd.get_by_keywords(modes: [], keywords: ["core"])
|
|
50
|
+
x << vma.kbd.get_by_keywords(modes: ["X"], keywords: ["intro"])
|
|
51
|
+
|
|
52
|
+
done.concat(x.lines); kbd_s << x
|
|
53
|
+
kbd_s << "\n"
|
|
54
|
+
|
|
55
|
+
kbd_s << "◼ Debug / Experimental\n"
|
|
56
|
+
x = vma.kbd.get_by_keywords(modes: [], keywords: ["experimental"])
|
|
57
|
+
done.concat(x.lines); kbd_s << x
|
|
58
|
+
kbd_s << "\n"
|
|
59
|
+
|
|
60
|
+
kbd_s << "◼ Others\n"
|
|
61
|
+
# x = vma.kbd.get_by_keywords(modes: [], keywords:["experimental"])
|
|
62
|
+
# x = vma.kbd.to_s
|
|
63
|
+
x = vma.kbd.get_by_keywords(modes: [], keywords: [])
|
|
64
|
+
done << x.lines - done
|
|
65
|
+
kbd_s << (x.lines - done).join
|
|
66
|
+
kbd_s << "\n"
|
|
67
|
+
|
|
68
|
+
kbd_s << "===============================================\n"
|
|
69
|
+
b = create_new_buffer(kbd_s, "key-bindings")
|
|
70
|
+
gui_set_file_lang(b.id, "hyperplaintext")
|
|
71
|
+
end
|
|
72
|
+
|
|
73
|
+
# ── Vim keymap vs vimlike keymap ─────────────────────────────────────────────
|
|
74
|
+
|
|
75
|
+
# Build a separate KeyBindingTree from a keymap scheme file ("vim", "vimlike")
|
|
76
|
+
# without changing the running editor. A scheme file binds into vma.kbd,
|
|
77
|
+
# registers actions in vma.actions, defines helper methods and sets the
|
|
78
|
+
# cnf.mode cursor colors; all of these are swapped out or restored here.
|
|
79
|
+
def load_scheme_kbd(scheme)
|
|
80
|
+
file = File.join(__dir__, "key_bindings_#{scheme}.rb")
|
|
81
|
+
ed = vma
|
|
82
|
+
saved_kbd, saved_actions = ed.kbd, ed.actions
|
|
83
|
+
names = Vimamsa.instance_methods(false) + Vimamsa.private_instance_methods(false)
|
|
84
|
+
saved_methods = names.to_h { |n| [n, Vimamsa.instance_method(n)] }
|
|
85
|
+
color_modes = %w[command default visual replace browse insert inactive]
|
|
86
|
+
saved_colors = color_modes.to_h { |m| [m, cnf.mode.send(m).cursor.background!] }
|
|
87
|
+
acts = ActionList.new
|
|
88
|
+
kbd = KeyBindingTree.new(actions: acts)
|
|
89
|
+
kbd.error_handler = proc { |_msg| }
|
|
90
|
+
begin
|
|
91
|
+
ed.kbd = kbd
|
|
92
|
+
ed.instance_variable_set(:@actions, acts)
|
|
93
|
+
load file
|
|
94
|
+
ensure
|
|
95
|
+
ed.kbd = saved_kbd
|
|
96
|
+
ed.instance_variable_set(:@actions, saved_actions)
|
|
97
|
+
saved_methods.each { |n, um|
|
|
98
|
+
Vimamsa.send(:define_method, n, um) if Vimamsa.instance_method(n) != um
|
|
99
|
+
}
|
|
100
|
+
saved_colors.each { |m, v| cnf.mode.send(m).cursor.background = v }
|
|
101
|
+
end
|
|
102
|
+
kbd
|
|
103
|
+
end
|
|
104
|
+
|
|
105
|
+
# Every binding of a tree as [mode, keys, action]; keys is an Array of key
|
|
106
|
+
# names, with "(eval_rule)" appended where the binding has one.
|
|
107
|
+
def kbd_leaf_bindings(kbd)
|
|
108
|
+
out = []
|
|
109
|
+
stack = kbd.root.children.map { |m| [m, m.key_name, []] }
|
|
110
|
+
while (x = stack.pop)
|
|
111
|
+
st, mode, path = x
|
|
112
|
+
st.children.each { |c|
|
|
113
|
+
p = path + [c.eval_rule.empty? ? c.key_name : "#{c.key_name}(#{c.eval_rule})"]
|
|
114
|
+
out << [mode, p, c.action] if !c.action.nil?
|
|
115
|
+
stack << [c, mode, p] if c.children.any?
|
|
116
|
+
}
|
|
117
|
+
end
|
|
118
|
+
out.sort_by { |m, k, _a| [m, k.join(" ")] }
|
|
119
|
+
end
|
|
120
|
+
|
|
121
|
+
# Compare each binding of the vim keymap with the vimlike keymap (tree
|
|
122
|
+
# `other`, default: a fresh vimlike tree with no module or custom.rb
|
|
123
|
+
# bindings). Returns rows {mode:, keys:, action:, status:, why:, other:}:
|
|
124
|
+
# :shared same keys, same action
|
|
125
|
+
# :missing vimlike has nothing there, so the binding could be added
|
|
126
|
+
# :conflict vimlike uses the keys differently; why is one of
|
|
127
|
+
# :same_keys same keys bound to another action
|
|
128
|
+
# :shorter a shorter vimlike binding runs first (other = its keys)
|
|
129
|
+
# :prefix vimlike has longer bindings starting with these keys
|
|
130
|
+
# :wildcard a vimlike "<char>" binding takes the key
|
|
131
|
+
def vim_binding_conflicts(other = nil)
|
|
132
|
+
other ||= load_scheme_kbd("vimlike")
|
|
133
|
+
vim = load_scheme_kbd("vim")
|
|
134
|
+
kbd_leaf_bindings(vim).map { |mode, keys, action|
|
|
135
|
+
row = { mode: mode, keys: keys, action: kbd_action_code(action, vim.actions) }
|
|
136
|
+
row.merge(vim_binding_status(other, mode, keys, action, vim.actions))
|
|
137
|
+
}
|
|
138
|
+
end
|
|
139
|
+
|
|
140
|
+
# What an action runs, as text, so bindings can be compared and listed:
|
|
141
|
+
# the code of a String action or the body of a one-line proc. A registered
|
|
142
|
+
# action whose code isn't one line is ":name"; an unnamed multi-line proc is
|
|
143
|
+
# its first source line. "vma.buf" counts as "buf".
|
|
144
|
+
def kbd_action_code(action, acts = nil)
|
|
145
|
+
a = action
|
|
146
|
+
if a.class == Symbol
|
|
147
|
+
reg = acts&.[](a) || vma.actions[a]
|
|
148
|
+
return ":#{a}" if reg.nil? || reg.method.class != Proc
|
|
149
|
+
return ":#{a}" if kbd_proc_code(reg.method).nil?
|
|
150
|
+
a = reg.method
|
|
151
|
+
end
|
|
152
|
+
code = a.class == Proc ? (kbd_proc_code(a) || kbd_proc_first_line(a)) : a.to_s
|
|
153
|
+
code.gsub(/\bvma\.buf\b/, "buf").gsub(/\s+/, " ").strip
|
|
154
|
+
end
|
|
155
|
+
|
|
156
|
+
def kbd_proc_source(pr)
|
|
157
|
+
file, line = pr.source_location
|
|
158
|
+
@kbd_src_lines ||= {}
|
|
159
|
+
lines = (@kbd_src_lines[file] ||= (File.readlines(file) rescue []))
|
|
160
|
+
lines[line - 1].to_s
|
|
161
|
+
end
|
|
162
|
+
|
|
163
|
+
# Body of a proc written on one line, or nil
|
|
164
|
+
def kbd_proc_code(pr)
|
|
165
|
+
m = kbd_proc_source(pr).match(/proc\s*\{\s*(.*?)\s*\}/)
|
|
166
|
+
m && m[1]
|
|
167
|
+
end
|
|
168
|
+
|
|
169
|
+
def kbd_proc_first_line(pr)
|
|
170
|
+
"proc: " + kbd_proc_source(pr).strip.sub(/\A"[^"]*"\s*=>\s*/, "")
|
|
171
|
+
end
|
|
172
|
+
|
|
173
|
+
def vim_binding_status(kbd, mode, keys, action, vim_acts = nil)
|
|
174
|
+
node = kbd.root.children.find { |m| m.key_name == mode }
|
|
175
|
+
return { status: :missing } if node.nil?
|
|
176
|
+
path = []
|
|
177
|
+
keys.each_with_index { |k, i|
|
|
178
|
+
m = /\A(.+)\((.*)\)\z/.match(k)
|
|
179
|
+
name, rule = m ? [m[1], m[2]] : [k, ""]
|
|
180
|
+
child = node.children.find { |c| c.key_name == name && c.eval_rule == rule }
|
|
181
|
+
if child.nil?
|
|
182
|
+
wc = node.children.find { |c| c.key_name == "<char>" }
|
|
183
|
+
if wc && name.size == 1
|
|
184
|
+
return { status: :conflict, why: :wildcard, other: [path + ["<char>"], kbd_action_code(wc.action, kbd.actions)] }
|
|
185
|
+
end
|
|
186
|
+
return { status: :missing }
|
|
187
|
+
end
|
|
188
|
+
path << k
|
|
189
|
+
last = i == keys.size - 1
|
|
190
|
+
if !last && !child.action.nil? && child.children.empty?
|
|
191
|
+
return { status: :conflict, why: :shorter, other: [path, kbd_action_code(child.action, kbd.actions)] }
|
|
192
|
+
end
|
|
193
|
+
node = child
|
|
194
|
+
}
|
|
195
|
+
if node.children.any?
|
|
196
|
+
n = 0
|
|
197
|
+
stack = [node]
|
|
198
|
+
while (s = stack.pop)
|
|
199
|
+
s.children.each { |c| n += 1 if !c.action.nil?; stack << c }
|
|
200
|
+
end
|
|
201
|
+
return { status: :conflict, why: :prefix, other: [keys, "#{n} longer binding#{n == 1 ? "" : "s"}"] }
|
|
202
|
+
end
|
|
203
|
+
oc = kbd_action_code(node.action, kbd.actions)
|
|
204
|
+
return { status: :shared } if oc == kbd_action_code(action, vim_acts)
|
|
205
|
+
{ status: :conflict, why: :same_keys, other: [keys, oc] }
|
|
206
|
+
end
|
|
207
|
+
|
|
208
|
+
VIM_CONFLICT_WHY = {
|
|
209
|
+
same_keys: "same keys, other action",
|
|
210
|
+
shorter: "a shorter vimlike binding runs first",
|
|
211
|
+
prefix: "vimlike uses these keys as a prefix",
|
|
212
|
+
wildcard: "a vimlike <char> binding takes the key",
|
|
213
|
+
}
|
|
214
|
+
|
|
215
|
+
# Markdown report of vim_binding_conflicts, written to
|
|
216
|
+
# doc/vimlike_vim_conflicts.md (tests/test_vim_conflicts.rb keeps it current).
|
|
217
|
+
def vim_binding_conflicts_report(rows = vim_binding_conflicts)
|
|
218
|
+
code = ->(s) {
|
|
219
|
+
s = s.to_s
|
|
220
|
+
s = s[0, 57] + "..." if s.size > 60
|
|
221
|
+
s = s.gsub("&", "&").gsub("<", "<").gsub(">", ">").gsub("|", "|")
|
|
222
|
+
"<code>#{s}</code>"
|
|
223
|
+
}
|
|
224
|
+
act = code
|
|
225
|
+
by = rows.group_by { |r| r[:status] }
|
|
226
|
+
out = +"# Vim keymap vs vimlike keymap\n\n"
|
|
227
|
+
out << "Generated by `vim_binding_conflicts_report` (lib/vimamsa/key_bindings_report.rb)\n"
|
|
228
|
+
out << "from `key_bindings_vim.rb` and `key_bindings_vimlike.rb`. Don't edit by hand:\n"
|
|
229
|
+
out << "run `VMA_UPDATE_DOC=1 ruby exe/run_tests.rb --headless vim_conflicts`.\n\n"
|
|
230
|
+
out << "Bindings that modules and `custom.rb` add at startup are not included.\n\n"
|
|
231
|
+
out << "| | Count |\n|---|---|\n"
|
|
232
|
+
out << "| Conflicts (the vim binding can't be used in vimlike) | #{by.fetch(:conflict, []).size} |\n"
|
|
233
|
+
out << "| Missing from vimlike (no conflict, could be added) | #{by.fetch(:missing, []).size} |\n"
|
|
234
|
+
out << "| Shared (same keys, same action) | #{by.fetch(:shared, []).size} |\n\n"
|
|
235
|
+
|
|
236
|
+
out << "## Conflicts\n\n| Mode | Vim keys | Vim action | vimlike | Reason |\n|---|---|---|---|---|\n"
|
|
237
|
+
by.fetch(:conflict, []).each { |r|
|
|
238
|
+
ok, oa = r[:other]
|
|
239
|
+
vl = ok == r[:keys] ? act.(oa) : "#{code.(ok.join(" "))} #{act.(oa)}"
|
|
240
|
+
vl = code.(oa) if r[:why] == :prefix
|
|
241
|
+
out << "| #{r[:mode]} | #{code.(r[:keys].join(" "))} | #{act.(r[:action])} | #{vl} | #{VIM_CONFLICT_WHY[r[:why]]} |\n"
|
|
242
|
+
}
|
|
243
|
+
out << "\n## Missing from vimlike\n\n| Mode | Vim keys | Vim action |\n|---|---|---|\n"
|
|
244
|
+
by.fetch(:missing, []).each { |r|
|
|
245
|
+
out << "| #{r[:mode]} | #{code.(r[:keys].join(" "))} | #{act.(r[:action])} |\n"
|
|
246
|
+
}
|
|
247
|
+
out << "\n## Shared\n\n| Mode | Keys | Action |\n|---|---|---|\n"
|
|
248
|
+
by.fetch(:shared, []).each { |r|
|
|
249
|
+
out << "| #{r[:mode]} | #{code.(r[:keys].join(" "))} | #{act.(r[:action])} |\n"
|
|
250
|
+
}
|
|
251
|
+
out
|
|
252
|
+
end
|
|
253
|
+
|
|
254
|
+
# Show the report for the running editor: compared with the live key
|
|
255
|
+
# bindings when the vimlike keymap is in use, so custom.rb is included.
|
|
256
|
+
def show_vim_binding_conflicts
|
|
257
|
+
live = (cnf.keybindings.scheme! || "vimlike") == "vimlike"
|
|
258
|
+
b = create_new_buffer(vim_binding_conflicts_report(vim_binding_conflicts(live ? vma.kbd : nil)), "vim-binding-conflicts")
|
|
259
|
+
gui_set_file_lang(b.id, "markdown")
|
|
260
|
+
end
|
|
261
|
+
end # module Vimamsa
|
|
@@ -0,0 +1,354 @@
|
|
|
1
|
+
# Vim keybinding scheme: standard vim behavior, as close as the current
|
|
2
|
+
# action inventory allows. Standalone scheme file (does not load vimlike);
|
|
3
|
+
# selected via cnf.keybindings.scheme = "vim" (applied on restart).
|
|
4
|
+
#
|
|
5
|
+
# Not implemented (no core primitives) — intentionally left unbound:
|
|
6
|
+
# generic {op}{motion} operator-pending, t/T, %, ?, #, W/B/E/ge,
|
|
7
|
+
# V (linewise) / ctrl-v (blockwise) visual, : ex commands, >>/<<,
|
|
8
|
+
# named registers, faithful change-only "." repeat, backward ranges
|
|
9
|
+
# (db, cb, insert-mode ctrl-w).
|
|
10
|
+
# Known deviations kept on purpose:
|
|
11
|
+
# "$" parks the cursor on the newline (one past vim's last char);
|
|
12
|
+
# C tab = switch to last buffer; C enter = line action;
|
|
13
|
+
# ctrl-d/ctrl-u scroll a full page, not half; ctrl-o approximates the
|
|
14
|
+
# jumplist with jump_to_last_edit; "." repeats only the last f/F find.
|
|
15
|
+
|
|
16
|
+
module Vimamsa
|
|
17
|
+
vma.kbd.add_mode("C", :command)
|
|
18
|
+
vma.kbd.add_mode("I", :insert, :insert)
|
|
19
|
+
vma.kbd.add_mode("V", :visual, :visual)
|
|
20
|
+
vma.kbd.add_mode("M", :minibuffer)
|
|
21
|
+
vma.kbd.add_mode("R", :readchar)
|
|
22
|
+
vma.kbd.add_minor_mode("audio", :audio, :command)
|
|
23
|
+
vma.kbd.add_minor_mode("macro", :macro, :command)
|
|
24
|
+
vma.kbd.add_mode("B", :browse, :browse, scope: :editor)
|
|
25
|
+
vma.kbd.add_mode("X", :replace, :replace, name: "Replace")
|
|
26
|
+
vma.kbd.set_default_mode(:command)
|
|
27
|
+
vma.kbd.__set_mode(:command)
|
|
28
|
+
|
|
29
|
+
cnf.mode.command.cursor.background = "#05c5a0"
|
|
30
|
+
cnf.mode.default.cursor.background = "#03fcca"
|
|
31
|
+
cnf.mode.visual.cursor.background = "#bc6040"
|
|
32
|
+
cnf.mode.replace.cursor.background = "#fc0331"
|
|
33
|
+
cnf.mode.browse.cursor.background = "#f803fc"
|
|
34
|
+
cnf.mode.insert.cursor.background = "#ffffff"
|
|
35
|
+
cnf.mode.inactive.cursor.background = "#777777"
|
|
36
|
+
|
|
37
|
+
def _insert_move(op)
|
|
38
|
+
if op == :pagedown
|
|
39
|
+
vma.gui.page_down
|
|
40
|
+
elsif op == :pageup
|
|
41
|
+
vma.gui.page_up
|
|
42
|
+
else
|
|
43
|
+
buf.move(op)
|
|
44
|
+
end
|
|
45
|
+
end
|
|
46
|
+
|
|
47
|
+
def insert_select_move(op)
|
|
48
|
+
buf.continue_selection
|
|
49
|
+
_insert_move(op)
|
|
50
|
+
end
|
|
51
|
+
|
|
52
|
+
def insert_move(op)
|
|
53
|
+
buf.end_selection
|
|
54
|
+
_insert_move(op)
|
|
55
|
+
end
|
|
56
|
+
|
|
57
|
+
# ── composite actions for vim commands not covered by a single action ────────
|
|
58
|
+
|
|
59
|
+
# get_range(:to_line_end) inverts on an empty line / cursor-on-newline and
|
|
60
|
+
# would delete the previous newline (buffer.rb get_range) => guard.
|
|
61
|
+
reg_act(:vim_delete_to_eol, proc {
|
|
62
|
+
b = buf
|
|
63
|
+
b.delete2(:to_line_end) if b.pos < b.line_ends[b.lpos]
|
|
64
|
+
}, "Delete to end of line (vim D)")
|
|
65
|
+
|
|
66
|
+
reg_act(:vim_change_to_eol, proc {
|
|
67
|
+
b = buf
|
|
68
|
+
b.delete2(:to_line_end) if b.pos < b.line_ends[b.lpos]
|
|
69
|
+
vma.kbd.set_mode(:insert)
|
|
70
|
+
}, "Change to end of line (vim C / c$)")
|
|
71
|
+
|
|
72
|
+
reg_act(:vim_change_line, proc {
|
|
73
|
+
b = buf
|
|
74
|
+
b.jump(BEGINNING_OF_LINE)
|
|
75
|
+
b.delete2(:to_line_end) if b.pos < b.line_ends[b.lpos]
|
|
76
|
+
vma.kbd.set_mode(:insert)
|
|
77
|
+
}, "Change whole line, keep newline (vim cc/S)")
|
|
78
|
+
|
|
79
|
+
reg_act(:vim_change_word, proc {
|
|
80
|
+
buf.delete2(:to_word_end) # vim cw ~= ce semantics; close enough
|
|
81
|
+
vma.kbd.set_mode(:insert)
|
|
82
|
+
}, "Change word (vim cw/ce)")
|
|
83
|
+
|
|
84
|
+
reg_act(:vim_substitute_char, proc {
|
|
85
|
+
buf.delete(CURRENT_CHAR_FORWARD) if buf.current_char != "\n"
|
|
86
|
+
vma.kbd.set_mode(:insert)
|
|
87
|
+
}, "Substitute char (vim s)")
|
|
88
|
+
|
|
89
|
+
reg_act(:vim_delete_char, proc {
|
|
90
|
+
buf.delete(CURRENT_CHAR_FORWARD) if buf.current_char != "\n"
|
|
91
|
+
}, "Delete char under cursor; no-op on empty line (vim x)")
|
|
92
|
+
|
|
93
|
+
reg_act(:vim_delete_char_backward, proc {
|
|
94
|
+
buf.delete(BACKWARD_CHAR) if buf.cpos > 0
|
|
95
|
+
}, "Delete char before cursor; no-op at col 0 (vim X)")
|
|
96
|
+
|
|
97
|
+
reg_act(:vim_open_line_above, proc {
|
|
98
|
+
b = buf
|
|
99
|
+
b.jump(BEGINNING_OF_LINE)
|
|
100
|
+
# insert_txt_at neither auto-indents nor moves the cursor: @pos ends up on
|
|
101
|
+
# the inserted "\n" = the new empty line, matching vim O.
|
|
102
|
+
b.insert_txt_at("\n", b.pos)
|
|
103
|
+
b.set_pos(b.pos) # refresh view + lpos/cpos
|
|
104
|
+
vma.kbd.set_mode(:insert)
|
|
105
|
+
}, "Open line above (vim O)")
|
|
106
|
+
|
|
107
|
+
reg_act(:vim_change_selection, proc {
|
|
108
|
+
buf.delete(SELECTION) # ends visual mode itself
|
|
109
|
+
vma.kbd.set_mode(:insert)
|
|
110
|
+
}, "Delete selection and enter insert mode (vim visual c/s)")
|
|
111
|
+
|
|
112
|
+
# APPROXIMATION: set_last_command is currently only fed by f/F finds, so this
|
|
113
|
+
# repeats the last find, not the last change like vim's ".".
|
|
114
|
+
reg_act(:vim_repeat_last_action, proc { repeat_last_action() },
|
|
115
|
+
"Repeat last recorded command (approximation of vim .)")
|
|
116
|
+
|
|
117
|
+
# ── motions ──────────────────────────────────────────────────────────────────
|
|
118
|
+
|
|
119
|
+
add_keys "vim motion", {
|
|
120
|
+
"VCX up" => "buf.move(BACKWARD_LINE)",
|
|
121
|
+
"VCX down" => "buf.move(FORWARD_LINE)",
|
|
122
|
+
"VCX right" => "buf.move(FORWARD_CHAR)",
|
|
123
|
+
"VCX left" => "buf.move(BACKWARD_CHAR)",
|
|
124
|
+
"VC h" => :e_move_backward_char,
|
|
125
|
+
"VC l" => :e_move_forward_char,
|
|
126
|
+
"VC j" => :forward_line,
|
|
127
|
+
"VC k" => :backward_line,
|
|
128
|
+
"C space" => "buf.move(FORWARD_CHAR)",
|
|
129
|
+
"C backspace" => "buf.move(BACKWARD_CHAR)",
|
|
130
|
+
|
|
131
|
+
"VC e" => :jump_next_word_end,
|
|
132
|
+
"VC b" => :jump_prev_word_start,
|
|
133
|
+
"VC w" => :jump_next_word_start,
|
|
134
|
+
|
|
135
|
+
# NOTE: "G(condition)" must be defined before "G"
|
|
136
|
+
"VC G(vma.kbd.next_command_count!=nil)" => "buf.jump_to_line()",
|
|
137
|
+
"VC G" => :jump_end_of_buffer,
|
|
138
|
+
"VC g g" => :jump_start_of_buffer,
|
|
139
|
+
"VC g ;" => :jump_last_edit,
|
|
140
|
+
|
|
141
|
+
# Counts; "0" is BOL only when no count is pending
|
|
142
|
+
"VC /[1-9]/" => "vma.kbd.set_next_command_count(<char>)",
|
|
143
|
+
"VC 0(vma.kbd.next_command_count!=nil)" => "vma.kbd.set_next_command_count(<char>)",
|
|
144
|
+
"VC 0(vma.kbd.next_command_count==nil)" => "buf.jump(BEGINNING_OF_LINE)",
|
|
145
|
+
"VC ^" => "buf.jump(FIRST_NON_WHITESPACE)",
|
|
146
|
+
"VC $" => "buf.jump(END_OF_LINE)",
|
|
147
|
+
|
|
148
|
+
"VC f <char>" => "buf.jump_to_next_instance_of_char(<char>)",
|
|
149
|
+
"VC F <char>" => "buf.jump_to_next_instance_of_char(<char>,BACKWARD)",
|
|
150
|
+
"VC f space" => "buf.jump_to_next_instance_of_char(' ')",
|
|
151
|
+
"VC F space" => "buf.jump_to_next_instance_of_char(' ',BACKWARD)",
|
|
152
|
+
"VC ;" => "repeat_last_find",
|
|
153
|
+
|
|
154
|
+
"VC *" => "buf.jump_to_next_instance_of_word",
|
|
155
|
+
"VC /" => :find_in_buffer,
|
|
156
|
+
"C :" => :start_cmd_line,
|
|
157
|
+
"C n" => :find_next,
|
|
158
|
+
"C N" => "$search.jump_to_previous()",
|
|
159
|
+
|
|
160
|
+
"VCI pagedown" => :page_down,
|
|
161
|
+
"VCI pageup" => :page_up,
|
|
162
|
+
"C ctrl-f" => :page_down,
|
|
163
|
+
"C ctrl-b" => :page_up,
|
|
164
|
+
"C ctrl-d" => "buf.move(:forward_page)", # approx: full page, vim: half
|
|
165
|
+
"C ctrl-u" => "buf.move(:backward_page)", # approx: full page, vim: half
|
|
166
|
+
"C ctrl-o" => :jump_to_last_edit, # approx of vim jumplist back
|
|
167
|
+
"C z z" => :center_on_current_line,
|
|
168
|
+
|
|
169
|
+
# Marks
|
|
170
|
+
"CV m <char>" => "buf.mark_current_position(<char>)",
|
|
171
|
+
'CV \' <char>' => "buf.jump_to_mark(<char>)",
|
|
172
|
+
"C ` <char>" => "buf.jump_to_mark(<char>)",
|
|
173
|
+
}
|
|
174
|
+
|
|
175
|
+
# ── editing ──────────────────────────────────────────────────────────────────
|
|
176
|
+
|
|
177
|
+
add_keys "vim edit", {
|
|
178
|
+
# Enter insert mode
|
|
179
|
+
"C i" => :insert_mode,
|
|
180
|
+
"C a" => "buf.move(FORWARD_CHAR);vma.kbd.set_mode(:insert)",
|
|
181
|
+
"C A" => "buf.jump(END_OF_LINE);vma.kbd.set_mode(:insert)",
|
|
182
|
+
"C I" => "buf.jump(FIRST_NON_WHITESPACE);vma.kbd.set_mode(:insert)",
|
|
183
|
+
"C o" => 'buf.jump(END_OF_LINE);buf.insert_txt("\n");vma.kbd.set_mode(:insert)',
|
|
184
|
+
"C O" => :vim_open_line_above,
|
|
185
|
+
|
|
186
|
+
# Delete
|
|
187
|
+
"C x" => :vim_delete_char,
|
|
188
|
+
"C X" => :vim_delete_char_backward,
|
|
189
|
+
"C d d" => [:delete_line, proc { buf.delete_line }, "Delete current line"],
|
|
190
|
+
"C d e" => "buf.delete2(:to_word_end)",
|
|
191
|
+
"C d w" => :delete_to_next_word_start,
|
|
192
|
+
"C d $" => :vim_delete_to_eol,
|
|
193
|
+
"C d 0" => :delete_to_line_start,
|
|
194
|
+
"C d ' <char>" => "buf.delete2(:to_mark,<char>)",
|
|
195
|
+
"C d f <char>" => "buf.delete2(:to_char,<char>)",
|
|
196
|
+
"C d F <char>" => "buf.delete2(:to_char_backward,<char>)",
|
|
197
|
+
"C d f space" => "buf.delete2(:to_char,' ')",
|
|
198
|
+
"C d F space" => "buf.delete2(:to_char_backward,' ')",
|
|
199
|
+
"C D" => :vim_delete_to_eol,
|
|
200
|
+
|
|
201
|
+
# Change / substitute
|
|
202
|
+
"C c c" => :vim_change_line,
|
|
203
|
+
"C c w" => :vim_change_word,
|
|
204
|
+
"C c e" => :vim_change_word,
|
|
205
|
+
"C c $" => :vim_change_to_eol,
|
|
206
|
+
"C C" => :vim_change_to_eol,
|
|
207
|
+
"C S" => :vim_change_line,
|
|
208
|
+
"C s" => :vim_substitute_char,
|
|
209
|
+
|
|
210
|
+
# Yank / paste
|
|
211
|
+
"C y y" => :copy_cur_line,
|
|
212
|
+
"C Y" => :copy_cur_line,
|
|
213
|
+
"C y w" => "buf.copy(:to_next_word)",
|
|
214
|
+
"C y e" => "buf.copy(:to_word_end)",
|
|
215
|
+
"C y $" => "buf.copy(:to_line_end)",
|
|
216
|
+
"C y 0" => "buf.copy(:to_line_start)",
|
|
217
|
+
"C y ' <char>" => "buf.copy(:to_mark,<char>)",
|
|
218
|
+
"C p" => :paste_after_cursor,
|
|
219
|
+
"C P" => :paste_before_cursor,
|
|
220
|
+
|
|
221
|
+
# Misc edits
|
|
222
|
+
"C r <char>" => "buf.replace_with_char(<char>)",
|
|
223
|
+
"C r space" => "buf.replace_with_char(' ')",
|
|
224
|
+
"C J" => "buf.join_lines()",
|
|
225
|
+
"C ~" => :vim_toggle_case,
|
|
226
|
+
"C g U w" => :word_upcase,
|
|
227
|
+
"C g u w" => :word_downcase,
|
|
228
|
+
"C g ~ w" => :word_swapcase,
|
|
229
|
+
"C g U U" => :line_upcase,
|
|
230
|
+
"C g u u" => :line_downcase,
|
|
231
|
+
"C g ~ ~" => :line_swapcase,
|
|
232
|
+
"C ctrl-a" => "buf.increment_current_word", # vim ctrl-a: increment number
|
|
233
|
+
"C ." => :vim_repeat_last_action,
|
|
234
|
+
|
|
235
|
+
# Undo / redo
|
|
236
|
+
"C u" => :undo,
|
|
237
|
+
"C ctrl-r" => :redo,
|
|
238
|
+
}
|
|
239
|
+
|
|
240
|
+
# ── visual mode ──────────────────────────────────────────────────────────────
|
|
241
|
+
|
|
242
|
+
add_keys "vim visual", {
|
|
243
|
+
"C v" => :start_visual_mode,
|
|
244
|
+
"V esc" => "buf.end_visual_mode",
|
|
245
|
+
"V ctrl-c" => "buf.end_visual_mode",
|
|
246
|
+
"V y" => "buf.copy_active_selection()",
|
|
247
|
+
"V d" => [:delete_selection, proc { buf.delete(SELECTION) }, ""],
|
|
248
|
+
"V x" => "buf.delete(SELECTION)",
|
|
249
|
+
"V s" => :vim_change_selection,
|
|
250
|
+
"V c" => :vim_change_selection,
|
|
251
|
+
"V J" => :V_join_lines,
|
|
252
|
+
"V u" => "buf.transform_selection(:downcase)",
|
|
253
|
+
"V U" => "buf.transform_selection(:upcase)",
|
|
254
|
+
"V ~" => "buf.transform_selection(:swapcase)",
|
|
255
|
+
"V g U" => :selection_upcase,
|
|
256
|
+
"V g u" => :selection_downcase,
|
|
257
|
+
"V >" => "buf.indent_selection",
|
|
258
|
+
"V <" => "buf.unindent_selection",
|
|
259
|
+
}
|
|
260
|
+
|
|
261
|
+
# ── insert mode ──────────────────────────────────────────────────────────────
|
|
262
|
+
|
|
263
|
+
add_keys "vim insert", {
|
|
264
|
+
"I esc" => :prev_mode,
|
|
265
|
+
"I ctrl-c" => :prev_mode, # vim: ctrl-c leaves insert mode
|
|
266
|
+
"I <char>" => "buf.insert_txt(<char>)",
|
|
267
|
+
"I space" => 'buf.insert_txt(" ")',
|
|
268
|
+
"I enter" => :insert_new_line,
|
|
269
|
+
"I backspace" => :insert_backspace,
|
|
270
|
+
"I ctrl-h" => :insert_backspace, # vim i_ctrl-h = backspace
|
|
271
|
+
"I ctrl-j" => "buf.insert_new_line()", # vim i_ctrl-j = new line
|
|
272
|
+
|
|
273
|
+
# Completion (vim i_ctrl-n / i_ctrl-p; popup guards first)
|
|
274
|
+
"I tab(vma.buf.view.autocp_active)" => "vma.buf.view.autocp_select_next",
|
|
275
|
+
"I shift-tab(vma.buf.view.autocp_active)" => "vma.buf.view.autocp_select_previous",
|
|
276
|
+
"I shift!(vma.buf.view.autocp_active)" => "vma.buf.view.autocp_select",
|
|
277
|
+
"I ctrl-n" => :autocp_manual_trigger,
|
|
278
|
+
"I ctrl-p" => :autocp_manual_trigger,
|
|
279
|
+
"I ctrl-space" => :autocp_manual_trigger,
|
|
280
|
+
|
|
281
|
+
"I tab" => "buf.insert_tab",
|
|
282
|
+
"I shift-tab" => "buf.unindent",
|
|
283
|
+
|
|
284
|
+
"I shift-up" => :insert_select_up,
|
|
285
|
+
"I shift-down" => "insert_select_move(FORWARD_LINE)",
|
|
286
|
+
"I shift-left" => "insert_select_move(BACKWARD_CHAR)",
|
|
287
|
+
"I shift-right" => "insert_select_move(FORWARD_CHAR)",
|
|
288
|
+
"I shift-pagedown" => "insert_select_move(:pagedown)",
|
|
289
|
+
"I shift-pageup" => "insert_select_move(:pageup)",
|
|
290
|
+
|
|
291
|
+
"I left" => "insert_move(BACKWARD_CHAR)",
|
|
292
|
+
"I right" => "insert_move(FORWARD_CHAR)",
|
|
293
|
+
"I down" => "insert_move(FORWARD_LINE)",
|
|
294
|
+
"I up" => "insert_move(BACKWARD_LINE)",
|
|
295
|
+
"I pagedown" => "insert_move(:pagedown)",
|
|
296
|
+
"I pageup" => "insert_move(:pageup)",
|
|
297
|
+
}
|
|
298
|
+
|
|
299
|
+
# ── replace mode (vim R) ─────────────────────────────────────────────────────
|
|
300
|
+
|
|
301
|
+
add_keys "vim replace", {
|
|
302
|
+
"C R" => "vma.kbd.set_mode(:replace)",
|
|
303
|
+
"X esc" => "vma.kbd.to_previous_mode",
|
|
304
|
+
"X <char>" => "buf.replace_with_char(<char>);buf.move(FORWARD_CHAR)",
|
|
305
|
+
}
|
|
306
|
+
|
|
307
|
+
# ── macros / infrastructure ──────────────────────────────────────────────────
|
|
308
|
+
|
|
309
|
+
add_keys "vim misc", {
|
|
310
|
+
# Macros: q<char> records, q stops, @<char> runs, @@ repeats
|
|
311
|
+
"VC q <char>" => "vma.kbd.set_mode(:macro);vma.macro.start_recording(<char>)",
|
|
312
|
+
"macro q" => "vma.kbd.to_previous_mode; vma.macro.end_recording",
|
|
313
|
+
"C @ @" => :run_last_macro,
|
|
314
|
+
"C @ <char>" => "vma.macro.run_macro(<char>)",
|
|
315
|
+
|
|
316
|
+
# READCHAR mode (argument input for f/F, r, m, ', q, @)
|
|
317
|
+
"R <char>" => "readchar_new_char(<char>)",
|
|
318
|
+
|
|
319
|
+
# Kept deviations (documented in the header)
|
|
320
|
+
"C tab" => "bufs.switch_to_last_buf",
|
|
321
|
+
# prev/next file in file panel order (no-op while the panel is hidden)
|
|
322
|
+
"C alt-h" => :file_panel_prev_file,
|
|
323
|
+
"C alt-l" => :file_panel_next_file,
|
|
324
|
+
"C enter || C return" => [:line_action, proc { buf.handle_line_action() }, "Line action"],
|
|
325
|
+
|
|
326
|
+
# Browse mode keys (mode reachable only via the :start_browse_mode action)
|
|
327
|
+
"B h" => :history_switch_backwards,
|
|
328
|
+
"B l" => :history_switch_forwards,
|
|
329
|
+
"B p" => :file_panel_prev_file,
|
|
330
|
+
"B n" => :file_panel_next_file,
|
|
331
|
+
"B z" => "center_on_current_line();call_action(:exit_browse_mode)",
|
|
332
|
+
"B enter || B return || B esc || B j || B ctrl!" => :exit_browse_mode,
|
|
333
|
+
"B s" => :page_up,
|
|
334
|
+
"B d" => :page_down,
|
|
335
|
+
"B r" => proc { vma.gui.page_down(multip: 0.25) },
|
|
336
|
+
"B e" => proc { vma.gui.page_up(multip: 0.25) },
|
|
337
|
+
"B i" => :jump_to_start_of_buffer,
|
|
338
|
+
"B o" => :jump_to_end_of_buffer,
|
|
339
|
+
"B c" => :close_current_buffer,
|
|
340
|
+
"B ;" => :jump_last_edit,
|
|
341
|
+
"B q" => :jump_to_last_edit,
|
|
342
|
+
"B w" => :jump_to_next_edit,
|
|
343
|
+
"B m" => :run_last_macro,
|
|
344
|
+
}
|
|
345
|
+
|
|
346
|
+
# Audio minor mode (used by the audio module; unreachable without it)
|
|
347
|
+
bindkey "audio f || audio right", [:audio_forward, proc { Audio.seek_forward }, "Seek forward in audio stream"]
|
|
348
|
+
bindkey "audio left", [:audio_backward, proc { Audio.seek_forward(-5.0) }, "Seek backward in audio stream"]
|
|
349
|
+
bindkey "audio space", :audio_stop
|
|
350
|
+
bindkey "audio q || audio esc", "vma.kbd.to_previous_mode"
|
|
351
|
+
|
|
352
|
+
# Text objects (diw, ci", ya(, vip, ...), see text_objects.rb
|
|
353
|
+
bind_vim_text_objects
|
|
354
|
+
end # module Vimamsa
|