From: Gregory Brown <gregory.t.brown@...>
Date: 2006-02-18T10:31:17+09:00
Subject: Re: Rubuntu LiveCD I need vim/emacs configs!

On 2/16/06, Ezra Zygmuntowicz <ezmobius@gmail.com> wrote:

>         What I really need some help with is killer ruby configs for vim,
> emacs and jedit. And anything else you would like to see included,
> please drop me a note and any pointers you have for configuration
> that would be best suited for this.

I am happy with my config:
--------------------------------------------------------------------

set nobackup
set nocompatible
set backspace=indent,eol,start

set history=50          " keep 50 lines of command line history
set ruler               " show the cursor position all the time
set showcmd             " display incomplete commands
set incsearch           " do incremental searching

map Q gq

set autoindent          " always set autoindenting on
set shiftwidth=2
set tabstop=2
set expandtab
set tw=80
set nohlsearch
map <silent> <C-N> :se invhlsearch<CR>

filetype on
filetype indent on
filetype plugin on
syntax on
if !exists( "*EndToken" )
 function EndToken()
   let current_line = getline( '.' )
   let braces_at_end = '{\s*\(|\(,\|\s\|\w\)*|\s*\)\?$'
   if match( current_line, braces_at_end ) >= 0
     return '}'
   else
     return 'end'
   endif
 endfunction
endif

noremap <F5> :set invpaste paste?<Enter>
imap <F5> <C-O><F5>
set pastetoggle=<F5>

map <C-R> :!ruby %<CR>
map <C-A> :!rake<CR>
map <C-I> :!ri <cword><CR>

imap <C-L> <ESC>:execute 'normal o' . EndToken()<CR>O
imap <C-B> def test_<C-L><BS><BS><BS><BS><BS><BS>
"{{{ Ruby block delimiter conversion: do end <=> { }
"Copyright (c) 2005 Mauricio Fernandez
"Subject to same licensing terms as Ruby.
" requires matchit and friends
" since it uses the % and = bindings
function! s:String_Strip(str)
   let s = substitute(a:str, '\v^\s*', '', '')
   return substitute(s, '\v\s*$', '', '')
endfunction
function! s:RubyBlockBraceToDoEnd(lineno)
   " { } => do end
   let oldz = getreg("z")
   call setreg("z", "")
   execute 'normal ^f{%l"zd$'
   let suffix = s:String_Strip(getreg("z"))
   call setreg("z", oldz)
   let orig = getline(".")
   let repl = substitute(orig, '\v\s*\{\s*(\|[^|]*\|)?.*', ' do \1', '')
   call setline(".", repl)
   let nextline = substitute(orig, '\v[^{]*\v\s*\{\s*(\|[^|]*\|)?', '', '')
   let nextline = substitute(nextline, '\}[^}]*$', '', '')
   let numlines = 0


   " uncomment one of the following:

   " (1) just insert the body without splitting the lines on ;
   "call append(a:lineno, nextline)
   "call append(a:lineno+1, 'end' . suffix)
   "

   " (2) try to split on ; ...
   call append(a:lineno, 'end' . suffix)
   " this is what we would want to do:
   "let nextline = substitute(nextline, ';', "\n", 'g')

   while stridx(nextline, ";") != -1
       let eom = stridx(nextline, ";")
       let line = s:String_Strip(strpart(nextline, 0, eom))
       call append(a:lineno + numlines, line)
       let numlines = numlines + 1
       let nextline = strpart(nextline, eom+1, strlen(nextline) - eom - 1)
   endwhile
   let nextline = s:String_Strip(nextline)
   if strlen(nextline) > 0
       call append(a:lineno + numlines, nextline)
       let numlines = numlines + 1
   endif

   " this is what it all began with...
   "execute 'normal :s/\v\s*\{\s*(\|.*\|)?/ do \1\r/
'
   "execute 'normal g_cw
en
rmal V' . (1 + numlines) . 'j='
   "echo "{ } => do end"
endfunction

function! s:RubyBlockDoEndToBrace(_firstline, _lastline)
   " do end => { }
   let linenum = a:_firstline + 1
   let orig = getline(".")
   while linenum < a:_lastline - 1
       let addline = getline(linenum)
       if '\v^\s*$' !~ addline
           let addline = substitute(addline, '\v^\s*', '', '')
           let addline = substitute(addline, '\s*$', '; ', '')
           let orig = orig . addline
       endif
       let linenum = linenum + 1
   endwhile
   let l = substitute(getline(a:_lastline-1), '\v^\s*', '', '')
   let l = substitute(l, '\s*$', '', '')
   let orig = orig . l
   let l = substitute(getline(a:_lastline), '\v^\s*end(\.|\s|$)@=', ' }', '')
   let l = substitute(l, '\s*$', '', '')
   let orig = orig . l

   "echo orig
   "input(orig)
   let repl = substitute(orig, '\v\s*do\s*(\|[^|]*\|)?', '{\1 ', '')
   "execute 'normal d' . (a:_lastline - a:_firstline) . 'j'
   execute ':' . a:_firstline . ',' . a:_lastline . 'd'
   call append(a:_firstline - 1, repl)
   execute ':' . a:_firstline
   "echo "do end => { }"
endfunction

map <SID>xx <SID>xx
let s:sid = maparg("<SID>xx")
unmap <SID>xx
let s:sid = substitute(s:sid, 'xx', '', '')

function! <SID>RubyBlockSwitchDelimiters() range
   set nofoldenable
   if a:firstline == a:lastline
       let braceidx = match(getline("."), '{')
       let doidx = match(getline("."), '\<do\>')
       if braceidx != -1 && (doidx == -1 || braceidx < doidx)
           call s:RubyBlockBraceToDoEnd(a:firstline)
       elseif doidx != -1
           execute 'normal /\<do\>' . "\n" . 'V%:call ' .
                       \ s:sid . 'RubyBlockSwitchDelimiters()' . "\n"
       else
           echo "No block found"
       end
   else
       call s:RubyBlockDoEndToBrace(a:firstline, a:lastline)
   endif
   "execute 'normal V2k='
   "execute 'normal v5j'
endfunction

command! -range B <line1>,<line2>call <SID>RubyBlockSwitchDelimiters()
vmap <Leader>B :call <SID>RubyBlockSwitchDelimiters()<cr>