rails::Notes

Anton Astashov hat kürzlich ein Plugin für vim veröffentlicht, mit dem man ruby- und Rails-Projekte aus dem Editor heraus debuggen kann. Mit

:Rdebugger

startet man den Mechanismus. Im Falle eines Railsprojektes wird dann ein Mongrel im development-Modus durch den Debugger gestartet. Auf den kann man wie üblich mit dem Webbrowser zugreifen. Hat man Breakpoints gesetzt, so hält der Prozess an der Stelle an und vim zeigt sie im Hauptfenster.

Nun kann man sich die aktiven Variablen ansehen und schrittweise durch den Quelltext gehen:

Installation

Damit die Sache funktioniert, muss der vim mit “1” antworten, wenn man ihn dies fragt:

:echo has("signs") && has("clientserver") && v:version > 700

Weder der eingebaute vim in Leopard noch der port-vim bringen im Moment eine Unterstützung für das Feature clientserver mit, aber die gvim- und MacVim-Varianten, die ich in Ubuntu und OsX ausprobiert habe, funktionierten beide klaglos.

Außerdem wird das ruby-debug-ide gem genötigt.

Zur Plugininstallation klont man das github-repo:

git clone git://github.com/astashov/vim-ruby-debugger.git

und kopiert dann einige Dateien in vims Pluginverzeichnis:

> cd ./vim-ruby-debugger
> cp -r vim/* ~/.vim/plugin/

Im Hilfetext des Plugins in vim stehen deutliche mehr Informationen, als auf der Hauptseite des github-Projekts:

:helptags ~/.vim/doc
:help ruby-debugger

Entgegen der Voreinstellung habe ich mir die Tastenkürzel auf die Alt-Taste verlegt. In der ~/.vimrc:

map <A-b>  :call g:RubyDebugger.toggle_breakpoint()<CR>
map <A-v>  :call g:RubyDebugger.open_variables()<CR>
map <A-m>  :call g:RubyDebugger.open_breakpoints()<CR>
map <A-s>  :call g:RubyDebugger.step()<CR>
map <A-n>  :call g:RubyDebugger.next()<CR>
map <A-c>  :call g:RubyDebugger.continue()<CR>
map <A-e>  :call g:RubyDebugger.exit()<CR>
map <A-d>  :call g:RubyDebugger.remove_breakpoints()<CR>

let g:ruby_debugger_fast_sender = 1

Die Letzte Zeile ist nötig, um die Benutzung eines Socket-Scripts in C zu aktivieren, dass vermutlich etwas schneller ist, als der übliche Weg (siehe Hilfetext).

Weblinks

github.com/astashov/vim-ruby-debugger

Sowohl der in Leopard eingebaute vim, als auch die Standard-Portversion bringen keinen ruby-Support mit. Das bedeutet, dass die rubybasierten Plugins nicht arbeiten. So kompiliert man ihn richtig:

port install vim +big+ruby+python+cscope

== - auto-indent current line

aw - mark a word (in visual mode)
ib - mark an inner () block (visual mode)
iB - mark an inner {} block (visual mode)

:setlocal fileformat=dos|unix
:setlocal fileencoding=utf-8

gg - Go to first line
[N]G - Go To line N. No N: last line

`. - jump to spot in last modification line
'X - jump to mark named "X" at ANY file

"+y - yank to system buffer
"+p - paste from system buffer

Auf dem Weg muss ich immer mal wieder ein paar Kürzel notieren!

screen’s Scrollback-Mode

• CTL-a ESC startet den Scrollback/Copy-Modus in screen
• q beendet den Scrollback/Copy-Modus wieder

Alternativ kann man im .screenrc Mappings auf z.B. ALT-pgup und ALT-pgdown legen:

bindkey ^[[5;3~ eval "copy" "stuff \"^u\"" 
bindkey ^[[6;3~ eval "copy" 
bindkey -m ^[[5;3~ stuff "^u" 
bindkey -m ^[[6;3~ stuff "^d"

Visual mode

• CTL-v $ jjj… A selektiert eine Reihe von Zeilen jew. bis zum Ende und hängt dann Zeichen an
• CTL-v jjj… I (groß i) selektiert eine Reihe von Zeichen und fügt dann Zeichen ein

ctags

Vorbereitung: im Rails-Root ctags -R --exclude=*.js ausführen. In .vimrc muss set tags=tags stehen (unklar), dann:

• CTL-] springt zur ersten Definitionsstelle einer Funktion unter dem Cursor
• g CTL-] springt zu einer weiteren Definitionsstelle einer Funktion unter dem Cursor
• CTL-o springt zurück zur vorherigen Stelle

Rails-Funktionen

• gf während der Cursor auf einem Modell steht: öffnet das Model-File. Dies scheint in Fällen zu klappen, wo ein Dateiname dem Wort entspricht, also z.B. auch bei Partials

Codefaltung

• zf% am Anfang eines Klammernpaares oder Blocks (begin … end, if …, ...) faltet den Block
• % springt alternierend zwischen den Klammernpartnern hin und her
• za toggelt eine Faltung
• zA toggelt rekursiv alle Faltungen
• zi Faltung grundsätzlich ein-/ausschalten
• :set foldcolumn=5 aktiviert die Faltungsanzeige auf der linken Seite
• :set foldmethod=syntax faltet aufgrund syntaktischer Eigenschaften

Buffers

• :bd schließt (löscht) den aktuellen Buffer
• :2-6bdelete schließt die Buffer 2 bis 6

Fenster

• CTL-w q schließt das aktive Fenster (wie :q)
• CTL-w n öffnet ein neues leeres Fenster horizontal

ruby-code-indentation

• \rci ruft den externen Indenter auf

entfernte Dateien editieren

klappt via scp:

vim scp://me@passenger.int.bm.net//home/me/Dokumente/my.cnf

Jumps

• z. aktuelle Zeile vertikal zentrieren
• CTL-d halben Screen herunter scrollen
• CTL-u halben Screen herauf scrollen
• H (home) zur oberen Screenzeile springen
• M (middle) zur mittleren Screenzeile springen
• L (last) zur unteren Screenzeile springen

Wortsuche

• * springt zum nächsten Vorkommen des exakten Worts unter dem Cursor
• # springt zum letzten Vorkommen des exakten Worts unter dem Cursor
• g* springt zum nächsten Vorkommen des Wortteils unter dem Cursor
• g# springt zum letzten Vorkommen des Wortteils unter dem Cursor

Sreen-Kommandos

• CTL-a a sendet ein reguläres CTL-a an die Applikation

vim und screen lassen sich gut zu einer Art IDE mit geteilten (split) screens verbrämen.

Zum Start der Oberfläche benötigt man eine Steuerdatei:

rails.screen

screen 1 ./script/server
split
focus
resize 20
screen 2 tail -F log/development.log
focus
screen 3 vim -S layout_ide.vim

Hier wird außer dem vim auch ein tail und eine Mongrel-Instanz gestartet.

Start der Umgebung

Nun startet man das Ganze mit

screen -c rails.screen

screen-Kommandos

Innerhalb der laufenden Sitzung kann man u.a. folgende Mappings benutzen:

• split screen: CTL-a S (groß s)
• kill all regions but the current: CTL-a Q (groß q)
• kill current region: CTL-a X (groß x)
• switch to next region: CTL-a TAB
• rename region: CTL-a A
• resize current region: resize 20 (in command mode)

• display windows: CTL-a CTL-w
• show window-selector: CTL-a "
• switch to window: CTL-a # (mit # = 1, 2, 3, ..)
• switch to next window: CTL-a SPC
• toggle between last two windows: CTL-a CTL-a

• create a new shell: CTL-a CTL-c
• toggle logging of current window to screenlog.#: CTL-a H
• enter command mode: CTL-a :
• lock screen: CTL-a x
• detach: CTL-a CTL-d

die layout_ide.vim-Session

kann man aus dem laufenden vim wiefolgt erzeugen:

:mksession layout_ide.vim

Probleme

Bisher ist es mir nicht gelungen, das Splitscreenlayout nach einem detach -reattach zu erhalten. Man muss also die Splits manuell neu erzeugen.

Eclipse ist auf Dauer zu träge und Textmate gibt’s nicht für Linux – also: auf zum VIM!

Diese Tipps habe ich gefunden:

Coding

• CTRL-p aktiviert die Code-Completion

Visual Mode (Markierungen)

• v Markierung starten
• SHIFT-v zeilenweise markieren
• CTRL-v “Visual Block” Modus aktivieren
• c im aktiven visual Mode: ändert die Markierung
• x im aktiven visual Mode: löscht die Markierung
• > im aktiven visual Mode: Einrückung
• < im aktiven visual Mode: “Ausrückung”
• /\%V Ersetzen auf den markierten Bereich einschränken, z.B. ersetze Y durch X: :%s/\%VY/X/g

Editing

• J hängt die nächste Zeile an die aktuelle an
• qa beginnt die Aufzeichnung eines Macros in den a-Slot, q beendet
• @a gibt ein aufgezeichnetes Macro in Slot a wieder
• CTRL-n im Insertmode ergänzt ein Wort mit den nächsten Alternativen (wie Textmate ESC)

Navigation

• fa springt zum nächsten a in der Zeile
• Fa springt zum vorherigen a in der Zeile
• ; wiederholt fa oder Fa
• ma setzt die Sprungmarke a
• ‘a springt zur Zeile der Marke a
• `a springt zur Marke a
• ’’ oder `` zyklisch zum vorherigen Ort zurückgehen

Buffers

• :ls zeigt die aktuellen Buffers an
• :b3 aktiviert Buffer #3
• CTRL-^ wechselt zyklisch zwischen den letzten beiden aktiven Buffern

Tabs

• :tabnew öffnet einen neuen Tab
• :tabnew neuen benannten Tab öffnen
• gt wechselt zum linken Tab
• gT wechselt zum rechten Tab

Split-Winows

• CTRL-w s splittet das Fenster horizontal
• CTRL-w v splittet das Fenster vertikal
• CTRL-j springt in unteres Splitfenster (eigenes Mapping)
• CTRL-k springt in unteres Splitfenster (eigenes Mapping)

FuzzyFinder

• STRG+j öffnet die aktuell selektierte Datei horizontal in einem neuen Fenster
• STRG+k öffnet die aktuell selektierte Datei vertikal in einem neuen Fenster
• STRG+] öffnet die aktuell selektierte Datei in einem neuen Tab
• :ruby finder.rescan! Filebaum neu einlesen (Mapping auf \-r)
• \-t fuzzy-Filesuche
• \-b fuzzy-Buffersuche

vimdiff

vimdiff file1 file2

• dp – Änderungen des aktuellen Buffers in die andere Datei schreiben
• do – Änderungen vom anderen Buffer in den aktuellen schreiben
• ]c – Sprung zur nächsten Differenz
• [c – Sprung zur vorherigen Differenz

Dateiübergreifende Suche

• :vimgrep /muster/ **/*.rb sucht mit internem grep in allen rb-Dateien rekursiv nach dem Muster
• :grep … setzt ein externes grep ab und liefert die Dateiliste zurück. Die erste Fundstelle wird geöffnet

Quickfix-Mode (für :grep)

• :cl listet die gefundenen grep-Dateien auf
• :cc17 öffnet die 17. Fundstelle
• :cp springt zur vorherigen Fundstelle
• :cn springt zur nächsten Fundstelle

anderer Leute .vims

Speziell für Railsprojekte:

git clone git://github.com/manalang/vim-config.git