This chapter will cover working with a Python code base. You can get the code we’ll be editing in this chapter from GitHub at https://github.com/PacktPublishing/Mastering-Vim-Second-Edition/tree/main/Chapter02.

This chapter will start by introducing Vim plugins. Plugin management is a rather broad subject (and it’s covered in Chapter 3, Follow the Leader – Plugin Management, as well), but we’re starting out with just a few plugins, so we won’t have to worry ourselves with that topic yet.

First, let’s go through the one-time setup:

1. You’ll need to create a directory to store plugins. Execute the following on the command line:

   $ mkdir -p ~/.vim/pack/plugins/start

For Windows users

If you’re using GVim under Windows, you’ll have to create the vimfiles directory under your user folder (usually C:\Users\<username>), and then create pack\plugins\start folders inside of it.

2. You’ll want to tell Vim to load documentation for each plugin, as it doesn’t do so automatically. For that, add the following line to your ~/.vimrc file:

       silent! helptags ALL  ...

So far, we’ve only worked with a single file in Vim. When working with code, you usually have to work with multiple files at once, switching back and forth, making edits across multiple files, and looking up certain bits somewhere else. Luckily, Vim provides an extensive way to deal with many files:

• Buffers are the way Vim internally represents files; they allow you to switch between multiple files quickly
• Windows organize the workspace by displaying multiple files next to each other
• Tabs are a collection of windows
• Folds allow you to hide and expand certain portions of files, making large files easier to navigate

Here’s a screenshot illustrating the preceding points:

Figure 2.1 – Buffers, windows, tabs, and folds conveniently illustrated in one place.

Let’s understand the content in the screenshot:

• Multiple files (labeled kitchen/egg.py, kitchen/ingredient.py, and...

Since software projects contain a lot of files and directories, finding a way to traverse and display these using Vim comes in handy. This section will cover five different ways that you can navigate your files: using the built-in Netrw file manager or using the :e command with the wildmenu option enabled, as well as using the NERDTree, Vinegar, and CtrlP plugins. All of these provide different ways to interact with files and can be mixed and matched.

Netrw

Netrw is a built-in file manager in Vim (if we want to get technical, it’s a plugin that ships with Vim). It allows you to browse directories and functions, similar to any other file manager you’ve worked with in your favorite OS.

Use :Ex (the full command is :Explore) to open the file navigation window:

Figure 2.17 – Netrw file manager window, with a handy help screen above the directory tree.

Netrw is native to Vim

Netrw is fully integrated with...

We’ve covered some basic movements (by characters, words, and paragraphs), but Vim supports a lot more options for navigation.

Check the following if you want some movement within the current line:

• As you already know, h and l move the cursor left and right, respectively
• t (until) followed by a character allows you to search the line for that character and place the cursor before the character, while T allows you to search backward
• f (find) followed by a character allows you to search the current line for that character and move the cursor to the character, while F allows you to search backward
• _ takes you to the first non-blank character of the line, ^ takes you the beginning of the line, and $ takes you to the end of the line

Text objects

A word consists of numbers, letters, and underscores. A WORD consists of any characters except for whitespace (like spaces, tabs, or newlines). This distinction helps with more precise navigation...

You can copy text by using the y (yank) command, followed by a movement or a text object. You can also hit y from a visual mode when you have selected some text.

Tip

In addition to all of the standard movement, you can use yy to yank the contents of the current line.

Let’s yank the following piece of code by typing ye (yank until the end of the word):

Figure 2.35 – ye will yank (copy) has_spam into the default register.

This will copy has_spam into our default register. Now, place the cursor where you want the text to appear (the text is inserted after the cursor):

Figure 2.36 – Place cursor before the position where you want to insert the text.

To paste the code, hit p:

Figure 2.37 – p will insert the default register contents after the cursor.

The delete and change operators also yank content so that you can paste it later...

You now know how to navigate core concepts Vim operates by using buffers to represent files, utilizing split windows, and using tabs to organize multiple windows. You’ve also learned how to use folds to make navigating large files more manageable.

You now should be more confident getting through a large code base by navigating files with plugins such as Netrw, NERDTree, Vinegar, and CtrlP. Oh, and this chapter taught you a quick (even though it’s a slightly manual) way to install said plugins.

This chapter covered new movement operations, text objects, ways to quickly dart into insert mode, and how to make even fancier jumps throughout the file using the EasyMotion plugin. We’ve also dipped into search functionality, searching both within a single file and across the whole code base. You get a bonus point for trying out the ack plugin.

Finally, this chapter covered the concept of registers, and how you can use them to supercharge copying and pasting...