Using vimscript to run test scripts by utilizing normal vim commands

Question

I started using VIM as my editor around six months back and I enjoy it very much. However, there are a few work related scripts that I'd like to implement to make my life easier. If there is anyone who can help me I would be grateful.

This is my question. I have some tests written in python and I wrote a key mapping to run those tests using vim terminal. It works perfectly. However, now I want to use VimScript and some vim functions to make it look better. I'm a beginner in VimScript and therefore, I'm not sure whether this is doable.

My folder structure looks like,

.
├── my_test.py
└── test
    └── testRunner.py

1 directory, 2 files

My test code looks something like,

my_test.py:

#!/bin/python

class MyTest1:

    def Run():
        # Test body

class MyTest2:

    def Run():
        # Test body

test/testRunner.py:

#!/bin/python

print "Running the test"

My current key-mapping in .vimrc looks like:

nnoremap t mZ/classNwyiw:noh:terminalcd testpython testRunner.py "0'Z

What this does is,

Find the test name (the test that I'm currently editing)
Copy the name and run that test name in a vim-terminal

What I want it to be something which looks like:

nnoremap t :call RunThisTest()

function! RunThisTest()
    RememberEditContext()
    FindAndCopyTestName()
    RunTestInTestDirectory()
    ReturnToEditContext()
endfunction

Can someone help me in developing these functions?

Thank you in advance!

filbranden · Accepted Answer

One option is to use the :normal! command directly, which allows you to run a sequence of keystrokes directly as you'd have used them in a mapping.

But it turns out we can do better, much better, so let's get to it!

Searching and Matching

You can use the search() function to look for the class you're in. You can pass it flags, such as bcnW, to have it search backwards, possibly match at the cursor position, do not move the cursor and do not wrap around the file. Putting it all together:

let line = search('^class \w', 'bcnW')

This will return a line number if there was a positive match, or 0 if there wasn't one. If there was a match, we can use getline() to get its contents and then matchlist() to capture the name of the class.

let [_, classname; _] = matchlist(getline(line), '^class $\w\+$')

As you can see, using Vimscript we were able to get the classname without moving the cursor and without touching the search register. So we didn't need to set any marks and we won't need to worry about recovering the current position and view!

Running a command

Now it's time to run a command on the terminal. We can simplify the process by passing it a command directly. (Note that there's a difference here, in that the terminal will run just that command, it won't leave the shell around after finished. Depending on your use case, you might prefer to do something more akin to what you're doing now.)

We can run the command in a terminal with:

:terminal ++shell cd test && python testRunner.py MyTest1

But, of course, we need to actually pass it the class name we got, not a fixed value here. We can use the :execute command for this purpose. It takes a string and runs it as a Vimscript command. We can use this to assemble the string dynamically.

execute "terminal ++shell cd test && python testRunner.py ".shellescape(classname)

Finally, to go back to the original window, we can use the :wincmd command, more specifically wincmd p.

Putting it together

The resulting function is:

function! RunThisTest() abort
    let line = search('^class \w', 'bcnW')
    if line == 0
        echoerr "Not inside a test class!"
        return
    endif
    let [_, classname; _] = matchlist(getline(line), '^class $\w\+$')
    execute "terminal ++shell cd test && python testRunner.py ".shellescape(classname)
    wincmd p
endfunction

nnoremap  t :call RunThisTest()

There's definitely room for improvement, but this should get you started!

Saving and restoring context

We didn't go into saving and restoring context, since this case actually didn't need any of that!

If you were to develop functions that use commands that affect global context, you can use Vimscript to save and restore it.

For example, if you're going to search, you can save the @/ register and restore it after the search:

let saved_search = @/
/class
let @/ = saved_search

If you're going to yank into a register, you can save and restore it too. For example, @" for the default register. You should also save the register type, which records whether the contents were taken in a character-wise, linewise or blockwise context.

let saved_register = getreg('"')
let saved_regtype = getregtype('"')
normal! y3W
let words = getreg('"')
call setreg('"', saved_register, saved_regtype)

You can also save the current view, which includes the position your cursor is in, but also the other parameters of the window, such as what the first displayed line and column are, such that you can fully restore that context. See the winsaveview() and winrestview() functions for details on that.

Managing Terminals

There are functions to control the terminal that go way beyond what :terminal can do.

For instance, the much richer term_start() allows running a command as a list and passing options such as 'cwd' to run the command on a different directory.

So we could simplify our test execution with:

call term_start(['python', 'testRunner.py', classname], {'cwd': 'test'})

There's also term_sendkeys() which you can use to send keystrokes to the terminal. For example, if you prefer to start a shell and call the Python script through the shell:

let termbuf = term_start(&shell, {'cwd': 'test'})
call term_sendkeys(termbuf, "python testRunner.py ".shellescape(classname)."\r")

You can also use term_getline(termbuf, '.') to get the contents of the line where the cursor currently is. For instance, you could use that to detect whether the terminal is on a shell prompt (line ending in $ and whitespace) or still on an execution of a test runner.

Finally, you can even have the command running inside the terminal call Vim commands! Through special escape sequences, it can call exported functions or ask Vim to open files for editing. See :help terminal-api for details.

Learning More

This is all very neat... But how can I learn more?

My first strong recommendation would be to read the excellent "Learn Vimscript the Hard Way", by Steve Losh. It covers the basics of the language, how to interface with the editor (mappings, auto-commands, indentation expressions, filetypes) and basics of how to put together Vim plug-ins. It also covers common pitfalls of Vimscript and best practices for writing reliable code. That's a must if you want to get serious about scripting Vim.

Second suggestion is read the excellent documentation that's available through :help! Few applications are as well documented as Vim is, so knowing your way around the help system can really help a lot.

Third is using StackExchange. In particular, the Vi & Vim SE which is dedicated to the subject. Not only you'll find great answers there and you'll be able to ask great questions, you will also have the opportunity of seeing great questions, wonder how to solve them and possibly take a stab at writing an answer. (Personally, since I started using the Vi & Vim SE, my Vim-foo has greatly improved, to the point I can consider myself almost an expert.) I strongly recommend that.

Finally, practice. It typically takes a few attempts to get something really right. But the fact that the environment is fairly dynamic and flexible allows for experimentation. You can type and experiment with the commands in the editor itself, so it's usually quick to test your code and get it right as you're writing it.