Vim Smackdown! for Den of Clojure

vim.markdown

Vim Smackdown

Intro / Ethos

• Vim vs Emacs: seems like comparing a text editor to the JVM. Apples to oranges?
• Where Emacs is about providing the user powerful tools, Vim is a powerful text editor focussed on efficiency
• Emacs has nice tooling for clj dev - can Vim match it?

Keep the mnemonics in mind...

File management

• :e <filename> - edits a file
• :w - writes a file to disk
• :qa - quits vim
• :qa! - really quits vim!

Editing

When in normal mode:

• i - switch into insert mode

When in insert mode:

• <esc> - switch into normal mode

Help

• :h - start up the help system
• :h <cmd> - get help on a command (or keystroke etc - try :h CTRL-w_q

Package Management

Noob tip: Check your .vimrc into github

Aside from the built-in method of dumping plugins into a subdirectory somewhere, there are a couple of nice plugin management tools.

• Pathogen

  • I used to use this
  • Use git submodules - slightly awkward, more typing

• Vundle - I switched to this to put this talk together

  • My .vimrc on Github:

git clone git://github.com/iantruslove/vimrc_vundle.git .git
cd .vim
git submodule update --init
ln -s .vimrc ../.vimrc

* Launch Vim, and `:BundleInstall`

.vimrc runthrough

• Declare and configure plugins
• Disable arrow keys - force learning of hjkl
• Set up some basic non-default settings
• Custom functions and behaviors

Vim Basics

Referring to the "you don't grok vi" stackoverflow answer, there's a Vim way. There is a vocabulary to learn, and the commands are largely composable.

File operations

• :e <filename> - opens the file for editing
• :w - writes changes for the current buffer to disk
• :q - closes the current window. If this is the last window, tries to quit Vim. Will warn if closing unsaved files.
• :q! - same as previous, but will disregard any unsaved changes.
• :qa - closes all windows, being mindful of unsaved changes.
• :qa - closes all windows, and screw any unsaved changes, they're gone.

Basic navigation

• h,j,k,l - move cursor left, down, up, right one character/line
• 0 - move to start of line
• $ - move to end of line
• nG - go to line n
  • gg - go to start of file
  • G - go to end of file
• b - (back) move to start of previous word
• w - move to start of next word
• e - move to end of next word

Basic operations

• u - undo last edit
• C-r - redo last undo
• . - redo the last operation
• x - remove character under cursor (c.f. delete)
• X - remove character previous to cursor (c.f. backspace)
• i - enter insert mode at the current position
• a - enter insert mode at the character after the current position
• r<c> - replace the current character with the character c
• R - enter replace (overtype) mode
• s - remove the current character and enter insert mode (substituting the current character)
• J - join this line with the next
• c<movement> - change the text
• d<movement> - delete
• dd - delete line
• y<movement> - yank (copy)
• yy - yank line
• p - put (paste) previously deleted or yanked text after cursor
• P - put previously deleted or yanked text before cursor
• v - enter visual selection mode
• V - enter visual selection mode for complete lines

A Few Movements

• w - rest of word
• b - previous part of word
• iw - inner word - the whole word the cursor is within
• aw - all of the word, including the trailing spaces
• t<char> - to next instance of
• ib - inner block - everything within a set of parens

Combined examples

• xp - transposes two characters
• 3dd - delete three lines
• 2ciw - replace the word the cursor is currently in, and the word after with whatever gets typed next
• dt) - delete up to the next ")" character in the line

Searching and Replacing

• /abc - search for "abc". Can use vim regexes
• :%s/abc/123/g - for every line in the file, replace all instances of "abc" with "123".
• :s//xyz/ - for the current line, replace the first instance of whatever was last searched for with "xyz"
• * - search for the next instance of the word under the cursor
• # - search backwards for the next instance of the word under the cursor
• n - jump to the next match for the last search
• N - jump to the previous match for the last search

Scrolling

• C-d - move half a screen downwards. Cursor is moved too.
• C-u - move half a screen upwards. Cursor is moved too.
• C-e - scroll a line downwards. Cursor is not moved if possible.
• C-y - scroll a line upwards. Cursor is not moved if possible.
• % - jump to the matching paren / brace ( / HTML element / XML element / ...)

Window Management

• C-w s - split window horizontally
• C-w v - split window vertically
• C-w C-w - move focus to the next window
• C-w j - move focus a window down (similarly for all of hjkl)
• C-w J - move current window to the bottom (all of HJKL)
• C-w + - make window 1 line taller
• C-w - - make window 1 line shorter
• C-w _ - make window full height
• C-w > - make window 1 column wider
• C-w < - make window 1 column narrower
• C-w | - make window full width
• C-w = - make all windows equally(ish) sized

Plugins

Really depends on what you have installed. Compare with Emacs major and minor modes.

Some things I use:

• Fugitive - Git plugin
  • :Gstatus - interactive git status
  • :Gdiff - diff from HEAD
• CtrlP plugin
  • C-p enters a fuzzy file search mode
• Nerd commenter
  • \cc toggles comments on the selection
• Supertab
  • tab - tries to complete the word based on all kinds of inputs. Usually very effective
• Sparkup
  • HTML Zen editing. Very cool, watch the video.
  • E.g. in insert mode, type "div.section > ul#the-list > li*3e"

Clojure Plugins

• vim-slime
  • Sending commands from vim to another tmux (or screen) window
• Fireplace
  • akin to clojure-mode
  • Decent walkthrough on clojure-doc
• vim-clojure-static
  • Code editing and syntax highlghting for clojure
• vim-classpath
  • For running clj code without a repl

Clojure Walkthrough

Just scratching at the fireplace functionality here. Check out :h fireplace.txt

• Fire up tmux
• Create a new lein project: lein new vimclj
• Start the lein repl, and open vim in a new tmux window
• Open the test file, add some new code to make it fail
  • Compile the code with cpr (actually, it does (require :reload) for the current file)
  • Verify the test fails (i.e. running Clojure code from within Vim):
    • :Eval (clojure.test/run-tests)
    • cqp to open a repl prompt, type (clojure.test/run-tests)
    • cqc to open an interactive command editor, type (clojure.test/run-tests)<enter> to run the last line of code
    • Add (comment (clojure.test/run-tests)) at the end of the file
    • cqq with the cursor within the inner s-exp takes the expression into the command window ready for editing and executing
    • Again, with cursor within the inner s-exp, cpp runs that s-exp directly
• Add some code to make the tests pass.
  • :A jumps from the test file to the implementation
  • In insert mode, <C-x> <C-o> starts up ommicomplete. <tab> runs through the choices. Editing the current selection changes the options available.
  • [d on a symbol shows the documentation for that
  • [<C-d> jumps to the definition of a symbol
  • <C-w>d jumps to the definition of a symbol in a new split
  • gf (usually opens a file) works on namespace names also
  • Use cpr to compile and load the new code, or use :Require! from the test file