Homepage of Michael Goerz - vim

Integrating VIM with IPython II

2009-04-15T00:00:00+02:00

After some suggestions by Peter Battaglia, I rewrote the send.vim script to work better for its original purpose: sending text from vim to ipython. See the original post for the idea.

The send.vim script is now in the vim script repository:

http://www.vim.org/scripts/script.php?script_id=2608

The problem was that it’s not enough to send the text as-is. The ipython shell needs additional newlines to tell it when a code block ends at indentation level zero. Another problem are blank lines: a blank line in your source code might unintentionally end a code block when you send it to ipython. Hence, it’s best not to send empty lines at all.

The special behavior required for ipython meant that I had to extend the functionality of the script somewhat. I still want the plugin to be of general purpose, with all the ipython-specific behavior being optional. So, in addition to setting the g:sendToProgramName variable, you also have to set the g:sendToProgramMode to ‘ipython’ now in order to enable it.

It seems very feasible to add modes like this for other situations in the future.

In the reimplementation of the plugin, I also made it more robust to work per-buffer. In addition to the global settings (g:sendToProgramName etc.), you can also give settings local to the buffer by setting (for example) the b:sendToProgramName variable. Local settings, if present, override global settings. The plugin also keeps its internal state per buffer.

Vim Plugin for Completion of Fortran Structures

2008-12-18T00:00:00+01:00

I wrote a little plugin for vim that allows you to complete Fortran 90 structures by pressing F7.

http://www.vim.org/scripts/script.php?script_id=2487

The plugin in written in python, so you need to have your vim compiled with python support in order to use it.

The intention is to complete “program”, “type”, “interface”, “module”, “subroutine”, “function”, “do”, and “select” constructs. You write the first line of such a construct (e.g. “subroutine foo(a, b)”, then press F7, and the script will add the closing line “end subroutine foo” and put the cursor between the two lines, indented by one level.

Vim Reference Card

2008-09-29T00:00:00+02:00

This is my reference card for the vim editor:

Vim Reference Card

Integrating VIM with IPython

2008-09-20T00:00:00+02:00

When writing python scripts, I often want to run some code snippets in ipython for testing/debugging purposes. Until now, the only way to do this was to copy and paste the code snippets from vim to ipython. I wanted to have a way to send lines of text from vim to ipython directly.

More generally, I wanted to send text from vim to any (text-based) application at all. Instead of ipython, this might be a gnuplot session, or a Mathematica kernel.

To do this sort of thing, I used a feature of screen. If you have a program running inside a screen session, you can send arbitrary commands to it by executing something like screen -S sessionname -p 0 -X stuff 'command to execute^M' So, all I had to do was to generate a call like that from vim.

I split the job in two parts. First, there is a script that reads from stdin and sends every line it receives to a screen session. The script takes the -S and -p parameters with the same meaning as screen itself.

I’m calling it send2screen.py. (Update: April 15, 2009)

Second, there is the vim plugin, which just takes a range and sends all the lines in the range to the stdin of an arbitrary program (for our purpose, that arbitrary program will be send2screen.py, of course)

http://www.vim.org/scripts/script.php?script_id=2608

The plugin goes into ~/.vim/plugins/send.vim (Update: April 15, 2009 )

To use it, I set the sendToProgramName variable in vim to point to send2screen.py appropriately (update: you also need to set the sendToProgramMode to ‘ipython’), select some text in visual mode, and do: : ’<,’> python send() Or, to send the current line: : . python send() Of course, you could also map shortcuts to execute these commands.

ifort compiler definition for vim

2008-07-14T00:00:00+02:00

I put together a very quick compiler script for using ifort in vim, from an error format pattern I found here: http://vim.wikia.com/wiki/Errorformat_for_Intel_ifort

This is the script: ifort.vim

Put it in ~/.vim/compiler and add the line autocmd FileType fortran compiler ifort to your .vimrc.

The effect of this is that when you type :make in vim, it will parse any error messages that ‘make’ throws up and allow you to navigate between error lines (use :copen).

This isn’t tested very thoroughly, but it seems to work.

Vim Color Profile

2008-05-25T00:00:00+02:00

Since I didn’t like any of the existing color profiles for vim (what’d you expect), I wrote my own:

goerz.vim

It’s intended to be used mainly in a 256 color terminal (xterm with 256color support, which is my preferred way to run vim). It also works with gvim, and under 88 color terminals (not as perfect). You can see how it looks on this screenshot, which is vim running inside yakuake (which supports 256 colors):

xml_taginsert Vim Plugin

2008-05-23T00:00:00+02:00

I’ve written a vim plugin that allows to easier editing of html/xml files. If you load the plugin, you can use F7 to insert tags.

http://www.vim.org/scripts/script.php?script_id=2248

Vim LatexSuite Refcard

2008-05-11T00:00:00+02:00

This is my (unfinished) quick reference card for the LatexSuite plugin package for vim.

Vim LatexSuite Refcard

VIM Syntax File for TeX

2008-03-30T00:00:00+01:00

I wasn’t quite happy with how the TeX syntax file looks that comes with VIM, so I modified it. I wanted section (subsection, etc.) titles to be emphasized so that I can see them easily while scrolling through the file.

I also wanted spell check to be switched off for comments. Comments in TeX are usually disabled parts of text, with latex commands which will show up as spelling mistakes.

tex.vim