Executing VIM commands in a shell script

Question

I am writing a bash script that runs a command line program (Gromacs), saves the results, modifies the input files, and then loops through the process again. I am trying to use VIM to modify the input text files, but I have not been able to find a way to execute internal VIM commands like :1234, w, x, dd, ect. from the .sh file after opening my input files in VIM ("vim conf.gro").

Is there any practical way to execute VIM commands from the shell script?

Answer 1

You can script Vim via the -c flag.

vim  -c "set ff=dos" -c wq mine.mak

However that only gets you so far.

• From the commands you gave it looks like you are trying to run some normal commands. You will need to use :normal. e.g. :norm dd
• Writing all this in the command line is asking for trouble. I suggest you make a vim file (e.g. commands.vim) and then :source via -S.
• You probably want to get good and conformable vim's ex commands. Take a look at :h ex-cmd-index

So you will end up with something like this. With all your vim commands inside of commands.vim.

vim -S commands.vim mine.mak

You may also want to look into using sed and/or awk for text processing.

Answer 2

Alternatives

Unless you really need special Vim capabilities, you're probably better off using non-interactive tools like sed, awk, or Perl / Python / Ruby / your favorite scripting language here.

That said, you can use Vim non-interactively:

Silent Batch Mode

For very simple text processing (i.e. using Vim like an enhanced 'sed' or 'awk', maybe just benefitting from the enhanced regular expressions in a :substitute command), use Ex-mode.

REM Windows
call vim -N -u NONE -n -es -S "commands.ex" "filespec"

Note: silent batch mode (:help -s-ex) messes up the Windows console, so you may have to do a cls to clean up after the Vim run.

# Unix
vim -T dumb --noplugin -n -es -S "commands.ex" "filespec"

Attention: Vim will hang waiting for input if the "commands.ex" file doesn't exist; better check beforehand for its existence! Alternatively, Vim can read the commands from stdin. You can also fill a new buffer with text read from stdin, and read commands from stderr if you use the - argument.

Full Automation

For more advanced processing involving multiple windows, and real automation of Vim (where you might interact with the user or leave Vim running to let the user take over), use:

vim -N -u NONE -n -c "set nomore" -S "commands.vim" "filespec"

Here's a summary of the used arguments:

-T dumb           Avoids errors in case the terminal detection goes wrong.
-N -u NONE        Do not load vimrc and plugins, alternatively:
--noplugin        Do not load plugins.
-n                No swapfile.
-es               Ex mode + silent batch mode -s-ex
                Attention: Must be given in that order!
-S ...            Source script.
-c 'set nomore'   Suppress the more-prompt when the screen is filled
                with messages or output to avoid blocking.

Answer 3

I think vim -w/W and vim -s is what you are looking for.

The "vim operations/key sequence" you could record with vim -w test.keys input.file also, you could write the test.keys too. e.g. save this in the file:

ggwxjddZZ

this will do:

move to 1st line, 
move to next word,
delete one char,
move to next line, 
del the line. 
save and quit.

with this test.keys file, you could do:

vim -s test.keys myInput.file

your "myInput.file" would be processed by the above operations, and saved. you could have that line in your shell script.

vimgolf is using the same way to save users solution.