Where is the "default" .ideavimrc configuration file?

[fabriciorby]

Hello,

I'd like to know where I can find the default key mapping when the plugin is installed. I tried to find it in the docs and also in other forums on Google, but I couldn't find it.

Does anybody know?

Thanks

[sharpchen]

It's a vim motion emulation, so basically every default is included in vim documentation.

[fabriciorby]

Hello @sharpchen,

Of course, but the reason I am looking for this file is not to learn the commands, but check some default IDE bindings; like happens when you press gd.

I know it's possible to check one by one by toggling the track action option, but it would be nice to have the reference file or a list instead.

[citizenmatt]

These aren't IDE bindings. The actions listed in this file are custom implementations of built in Vim commands. So they're not mappings (and so it's not a vimrc format file) and they're not IDE actions either. IdeaVim hooks into the editor and dispatches keystrokes appropriately - handling mappings and then invoking a custom implementation for the Vim command. This usually uses the editor APIs to modify text and move the cursor. There are only a handful of commands that use IDE actions, things like commenting, and adding new lines (to get correct indenting).

[fabriciorby]

Hey @citizenmatt, thanks for your response.

I see, this explains a lot.

But I think I got a misconception about what the IDE actions really are, I thought gd, for example, would trigger an IDE action, that also happens to be the Vim implementation for the Vim command, isn't this statement correct?

[citizenmatt]

Broadly speaking, no, it's not correct. IdeaVim isn't just a set of mappings between shortcuts and existing IDE actions. IntelliJ's keymaps are really good, but not advanced enough to handle Vim's grammar for commands (e.g. "a3d2w being a d operator and a w motion, repeated 6 times and saving the deleted text to the a register). And the IDE doesn't provide enough editor actions to handle this grammar either. There's no IDE action to represent the "a3d2w command. And there's also no way to have different IDE key mappings for different Vim modes.

So IdeaVim essentially hooks into the typing process and handles key presses, transforming keys via user maps and building multi-key actions until it can create an IdeaVim command that executes a built-in Vim command (or enter text in the editor).

For example, G will (internally) map to IdeaVim's MotionGotoLineLastAction which will move the caret to the bottom of the file and make sure the window is properly scrolled. It can also handle a count, such as 10G to jump to a specific line. While it's called an "action", it's not an IDE action. It's not implementing any IDE interfaces, or registered with the IDE. It's completely custom code, extending a common base class created by IdeaVim. It's also a built-in Vim command, so there are no maps like in vimrc. Just like Vim, it's hardcoded that G in Normal mode means go to last/count line (if you want to change the shortcut, you just create a Vim map with a target of G). But to make life easier for us (there are a LOT of Vim commands), we register it with IdeaVim in a JSON file.

If we look at something like dw, then this actually maps to two commands. The d operator (internally) maps to DeleteMotionAction and when executed, receives an argument of MotionWordRightAction for the w motion. The delete action gets a range from the motion action and then deletes the text, using the IDE's editor APIs to modify the file.

So for the most part, IdeaVim is completely custom, mapping commands, operators and motions to custom classes that use the IDE's editor APIs to do the work. This is because Vim is mostly about text manipulation.

However, there are some things that aren't just text manipulation, such as gd. This is another built-in Vim command that would normally look at tags files and things, which we don't have. But as an IDE, we can go to definition, with Ctrl+Click or a keyboard shortcut that's mapped to an IDE action. And in this case, yes, we just invoke the IDE action. But since this is part of the Vim key processing pipeline, it's implemented as an IdeaVim action (GotoDeclarationAction) that then invokes the GotoDeclaration IDE action. It also does a bit of Vim stuff, like saving the current jump location, something else we couldn't do if we just mapped gd to the IDE action.

There are a few other Vim commands that we delegate to the IDE, commenting being the obvious one, but also K to show the quick doc popup instead of invoking man or J for IDE smart join lines. For implementation reasons, we also use IDE actions for up/down, tab, enter and escape, to make sure we integrate well with existing IDE features for those keys, such as auto-indent.

And of course, it's possible to create a map to an IDE action, such as nmap ]e <Action>(GotoNextError) that will invoke the IDE's GotoNextError action when I type ]e.

Phew. Shorter answer is - "it's complicated" 😁 But this complexity is why IdeaVim is such a good Vim implementation, IMHO.

[fabriciorby]

Amazing, I understand now.

Thanks for taking your time for such a detailed answer. :)

[OptimusCrime]

I think that you're looking for this file: https://github.com/JetBrains/ideavim/blob/master/vim-engine/src/main/resources/ksp-generated/engine_commands.json

For example gd executes com.maddyhome.idea.vim.action.motion.search.GotoDeclarationAction as defined here: https://github.com/JetBrains/ideavim/blob/master/vim-engine/src/main/resources/ksp-generated/engine_commands.json#L1607-L1611

[fabriciorby]

Hey @OptimusCrime,

For some reason, I thought it would be in some .ideavimrc format, but this is precisely what I was looking for.

Thanks!