# Installation

    git clone http://git.entwicklerseite.de/vim ~/.config/nvim/
    ln -s ~/.config/nvim ~/.vim

# Overview

- `init.lua` :: my every day neovim config. It sources my vimrc (see below)

- `init-mini.lua` :: if you want to start from scratch this is a good start. It
  sets up nvim with a language server to support the creation of a new config.

- `vimrc` :: commented version of a vimrc with sane defaults

- `gvimrc` :: configures the gui of gvim and sources the vimrc


```
 .
├──  after
│  ├──  ftdetect
│  │  └──  log.vim
│  ├──  ftplugin
│  │  └──  python.vim
│  ├──  indent
│  │  ├──  html5.vim
│  │  ├──  php.vim
│  │  └──  yaml.vim
│  └──  syntax
│     ├──  c.vim
│     ├──  log.vim
│     └──  markdown.vim
├──  gvimrc
├──  init-mini.lua
├──  init.lua
├──  README.md
└──  vimrc
```


# Cheat sheet
For different working scenarios.

## vim

- use `<C-d>` to expand autocompletion on the `:` command line. That works for
  example for `:setfiletype <C-d>` to show all available filetypes.

- use `gw` or `gq` in visual mode to break selected text at the current
  textwidth (configured with `set textwidth=80` for example)


        :viusage        = summary of all keyboard shortcuts
        :options        = shows currently :set options (with descriptions)
        leader key      = usually set to backslash expects a quick command

        [normal mode]
        f{char}         = move cursor to the character {char}
        gf              = open file under cursor
        <C-w>gf         = open file under cursor in a tab
        <C-w>]          = jump to the tag under the cursor in a new window
        <C-t>           = jump back from where that ^ brought you
        K               = keyword lookup for the word under the cursor (see :help kp)
        w               = next word
        e               = end of word (=inner word)

        @see: :h text-objects
        ci'             = change between single quote
        ci"             = change between double quote
        ci(             = change between brace
        cit             = change XML Tag
        ciw             = select inner word
        caw             = select 'a word'
        " where c can be replaced by v for visual mode

        :%s/foo/bar/g    = replace all foo with bar
        :g/foo/s/bar//g  = on lines with foo replace bar with nothing
        :g!/foo/s/bar//g = on lines not containing foo replace bar with nothing
        :g!/^foo/execute("normal dd") delete lines starting with foo

        flags, end: after the last /
        g               = replace globally (all occurances on the current line)
        c               = confirm each replace, also allows to switch to g (use the flag to see the help message)
        e               = places the cursor in the end of the selection

        flags, within the search string:
        \v              = use very magic search (more like perl)
        \V              = use no very magic, more like searching verbatim
        \zs .. \ze      = mark begin and end of a sub pattern (like perl lookaround assertions)

        [visual mode]   # with selected lines
        gq              = formats text so that it fits in whatever :set textwidth was set
        iB              = select block between curly braces (:help object-select)

        [commands]
        command line mode begins with : and has its own key mappings starting with c like in cnormap

        :spell [word]   = adds a word to the current dictionary (no mistake any more)
        :set list       = display non printable characters
        :retab          = replaces tabs with spaces
        :set expandtab  = in insert mode: replace tab with spaces
        :Explore        = cli version open file dialog (file explorer)
        :Lex            = use netrw as project drawer (stays open in its own window)
        :only           = 'maximize' current buffer

        <c-r><c-w>      = auto completion with the word under the cursor (interesting with incsearch)
        <c-a>           = expand pattern from command line (e.g. *.txt)

        [navigation]
        <CTRL-]>        = look up the tag under the cursor (help links as well)
        <CTRL-T>        = return back from tag under the cursor
        gd              = jump to the declaration of the variable under the cursor

        [macros]        # record and play back a series of vim commands
        qa              = start (q) macro recording in register a (can be anything)
        q               = stop macro recording
        @a              = replay macro a
        :'<,'>normal @a = apply a to every line in the current selection
        :reg            = lists all registers (including those with macros in them)

        [registers]
        notice, that registers get used for both: macro recordings and copying text

        :reg            = shows contents of all registers
        "0p             = pasts from register 0, which is the same as "", but not overwritten by dd
        "ap             = same for register a
        "0yy            = yanks to register 0 (same as y by itself)
        "ay             = yanks current selection to register a (in visual mode)

        [marker]
        ma              = set marker a-z (a in this case)
        mA              = create a session persistent file marker which can be used to reopen a file (not bound to the buffer)
        `a              = go to marker a (line & column)
        'a              = go to marker a (line, first non blank), same as `a^

        [hotkeys]
        <C-A>, <C-X>    = increment, decrement number under the cursor

        [windows]
        <C-W>v          = splits buffer vertically (screen uses |)
        <C-W>s          = splits buffer horizontally (same as screen)
        <C-W>w          = moves the cursor to the next window and back
        <C-W>[dir]      = moves the cursor in that direction (use hjkl or arrow keys)
        <C-W>[HK]       = make a vertical split horizontal and vice versa
        <C-W>o          = only: close all other windows
        <C-W>c          = close: current window in which the cursor sits

        [vimdiff]
        do              = get changes from other window into the current
        dp              = put changes from current window into the other
        ]c              = jump to the next change
        [c              = jump to the prevous change

        [folds]
        za              = toggle a fold
        zM              = close all folds
        zR              = opens all folds (unfold all)
        zE              = eliminates all folds

        [buffers]
        :bn              = buffer next
        :bp              = buffer previous
        :bd              = buffer dispatch (close)
        :b <tab>         = switch buffer by name (use <tab> and <return>)
        :set nobuflisted = hide buffer in buffer list (great for neovim's terminal)

        [args]
        :n **/*.c        = opens all files with that name or type in buffers and also fills the argument list

        [special]
        g CTRL-g        = display file properties including word and char count
        q:              = show command history and use it like a normal buffer
        z=              = show spellcheck suggestions

        [completions]
        CTRL-O          = display completions: omnicomplete (context dependant completions)

        CTRL-X CTRL-F   = display completions: file name (using vim-internals omnicomplete)
        CTRL-N CTRL-P   = display completions: file keywords
        CTRL-K          = display completions: dictionary
        CTRL-T          = display completions: thesaurus
        CTRL-I          = display completions: include files
        CTRL-]          = display completions: tags
        CTRL-D          = display completions: (marcro-) definitions
        CTRL-V          = display completions: vim command line
        CTRL-U          = display completions: user-defined

        [annoyances]
        gv               = visual mode: reselect last selection
        CTRL-o           = lets the caret jump back to the previous location
        CTRL-L           = redraws the complete screen
        CTRL-R<register> = in insert mode and command line: paste contents of <register> (e.g. : for last command, * for clipboard)
        CTRL-R           = in normal mode: redoes what has been undone with u
        "<register>p     = in normal mode: paste paste contents of <register>

        [registers]
        "/               = last search expression
        ":               = last command entered
        "=               = expression register (to do calculations or call vim functions)

        [netrw]
        :Lex            = open the netrw-view as project drawer
        gn              = makes the directory under the cursor the root directory
        a               = toggles display of hidden files

        [filetype:css]
        viB:sort       = sort inner block by name

        [vim commands]
        :for i in range(1,12) | put ='2016-'.i | endfor

        [fancy utf-8 symbols]
        ௵

        [debugging]
        :profile! start /tmp/profile.log
        :profile func *
        :profile file *
        " At this point do slow actions
        :profdel *
        :e /tmp/profile.log
        " add a break point to a vim script (like vimrc) to invoke the internal debugger
        :breakadd here

        :finish      = from within a viml-script: stop sourcing it

        [substitutions]
        delete all comments: %s/\/\*\*< [^(\*\/)]*\*\///g
        remove empty lines: global/^$/d
        remove non-empty lines: v/^$/d

        [programs]
        gpm - cut and paste helper for the linux console (to get text from CTRL-ALT-F2 to CTRL-ALT-F3)

        [vim modeline]
        filetype can have multiple values, like python.django
        The last line can be a mode line, which holds settings like tab width:



## git

    undo last commit:    git reset HEAD~
    diff two branches:   git diff branch1 branch2 path/to/file



To `~/.gitconfig` add:
    [alias]
      branchvv = for-each-ref --sort='committerdate:raw' --format='%(HEAD)%(if)%(HEAD)%(then)%(color:bold green)%(end) %(align:width=24)%(refname:short)%(end)  %(objectname:short)  %(color:bold blue)%(committerdate:iso)%(color:reset)  %(if)%(upstream)%(then)[%(color:blue)%(upstream:short)%(color:reset)] %(end)%(subject)' refs/heads 

Provides you with `git branchvv`, a command that works similar to `git branch`,
but sorts the branches by modification date and displays them.


# gnu screen

To run Vim in a gnu screen session:

    TERM=vte-256color screen vim

But if you are using another terminal there may be further options with even
more capabilities. Starting point for you search could be something like:

    find /usr/share/terminfo/ | grep screen | grep 256

# gvim

Change the default brackground of applications if you see an ugly grey border
around your beatiful theme:

```
/* to be saved as ~/.config/gtk-3.0/gtk.css
 * thanks to http://stackoverflow.com/users/6899000/proprefenetre */
@define-color YOUR_BACKGROUND_COLOR #rrggbb;

window#vim-main-window {
  background-color: @YOUR_BACKGROUND_COLOR;
}
```