Vim.txt

**************************************************
                Window Splitting
**************************************************
:vsp    Vertical split
:sp     Horizontal split
:vsp <file>     Opens <file> in new window
:10sp   Specify split height

:set splitright
    Opens window in right [for vertical splits] and becomes active

:set splitbelow
    Same as above, but for horizontal window

CTRL+w is same as :wincmd
    * Wherever we use CTRL+w, we can do :wincmd

CTRL+w <number> <
    reduce width of window by <number>

CTRL+w <number> >
    increase width of window by <number>

<number> CTRL+w +
    increase length of window by <number>

<number> CTRL+w -
    decrease length of window by <number>

CTRL+w |
    max out window width

CTRL+w _
    max out window height

CTRL+w =
    normalize all window sizes (equal sizes)

CTRL+w R
    swap both windows [including buffers]

<number> CTRL+w w
    switch to window <number>

CTRL+w T
    make current split window in to a tab (capital T)





**************************************************
                Tab Views
**************************************************
:tabnew <file>
    opens <file> in a new tab
:tabp
    previous tab
:tabn
    next tab

In Normal mode
    gt // go to next tab
    gT // go to previous tab
    ngt // got to tab no. n

vim -p file1 file 2 // open multiple files in tab mode





**************************************************
                Regular Expressions
**************************************************
. (dot) Any single character except newline
*       zero or more occurances of any character
[...]   Any single character specified in the set
[^...]  Any single character not specified in the set
^       Anchor - beginning of the line
$       Anchor - end of line
\<      Anchor - begining of word
\>      Anchor - end of word
\(...\) Grouping - usually used to group conditions
\n      Contents of nth grouping

[...] - Set Examples
--------------------
[A-Z]   The SET from Capital A to Capital Z
[a-z]   The SET from lowercase a to lowercase z
[0-9]   The SET from 0 to 9 (All numerals)
[./=+]  The SET containing . (dot), / (slash), =, and +
[-A-F]  The SET from Capital A to Capital F and the dash (dashes must be specified first)
[0-9 A-Z]       The SET containing all capital letters and digits and a space
[A-Z][a-zA-Z]   In the first position, the SET from Capital A to Capital Z
In the second character position, the SET containing all letters

Regular Expression Examples
---------------------------
/Hello/         Matches if the line contains the value Hello
/^TEST$/        Matches if the line contains TEST by itself
/^[a-zA-Z]/     Matches if the line starts with any letter
/^[a-z].*/      Matches if the first character of the line is a-z and there is at least one more of any character following it
/2134$/ Matches if line ends with 2134
/\(21|35\)/     Matches if the line contains 21 or 35
Note the use of ( ) with the pipe symbol to specify the 'or' condition
/[0-9]*/        Matches if there are zero or more numbers in the line
/^[^#]/         Matches if the first character is not a # in the line


- Regular expressions are case sensitive
- Regular expressions are to be used where pattern is specified


Reference for Regex:
    - http://vimregex.com/




**************************************************
                Code Folding
**************************************************
Reference - :help folding
            :help za
            :help zo
            :help zc

Synopsis - Using commands here, code in a file can be temporarily folded
[hidden]. Folding helps in navigating a file quickly as parts of the file
is hidden.

zc - close a fold
zo - open a fold
za - toggle a fold [open if its closed and vice versa]

zC, zO, zA are similar but inner folding levels are also affected by them,
not just the level at which cursor is present.




**************************************************
                Motion
**************************************************
CTRL+d  Scroll half page down
CTRL+u  Scroll half a page up

CTRL+f  Scroll full page down
CTRL+b  Scroll full page up

L   last line of current screen
M   middle line of current screen
^e  move the screen by one line down, with cursor staying in its place
^y  move the screen up by one line

0   beginning of the line
$   end of the line
^   first non-blank character of the line
g_  last non-blank character of the line

n%  takes you to nth percent position of the file

*   search for occurance of word under cursor
#   same as *, but move in opposite direction

Q: What is a word in Vim?
- Hyphen, Exclamation, Period delianated ... stuff?

Word wise navigation:
w   small word
W   big word
e vs E
b vs B


Scrolling
---
^E or ^e      Scroll window down
^Y or ^y      Scroll window up
^F      Scroll down one page
^B      Scroll up one page
H       Move cursor to top of window
M       Move cursor to middle of window
L       Move cursor to bottom of window



zt puts current line to top of screen
z. or zz puts current line to center of screen
zb puts current line to bottom of screen

Ref: http://unix.stackexchange.com/a/110252/45157



**************************************************
                Key Mappings
**************************************************
{cmd} {attr} {lhs} {rhs}

where
{cmd}  is one of ':map', ':map!', ':nmap', ':vmap', ':imap',
       <buffer>, <silent>, <expr> <script>, <unique> and
       <special>. More than one attribute can be specified to a map.
{lhs}  left hand side, is a sequence of one or more keys that are being
       mapped.
{rhs}  right hand side, is the sequence of keys that the {lhs} keys are

Ex: Map Ctrl+Tab to next tab and Ctrl+Shift+Tab to prev tab
nnoremap <C-Tab> <ESC>:tabnext<CR>
nnoremap <C-S-Tab> <ESC>:tabprevious<CR>

# Unmap arrow keys
no <up> <Nop>
no <down> <Nop>
no <left> <Nop>
no <right> <Nop>




**************************************************
                Miscellaneous
**************************************************

gf          ("goto file") Open file under cursor in current window
CTRL+w f    Open file under cursor in (horizontal) split window
CTRL+w gf   Open file under cursor in new tab

More details here: https://vim.fandom.com/wiki/Open_file_under_cursor


vim -O file1 file2 // open two files side by side




Substituting Tips
-----------------
Save typing by using \zs and \ze to set the start and end of a pattern.
For example, instead of:

:s/Copyright 2007 All Rights Reserved/Copyright 2008 All Rights Reserved/

Use:

:s/Copyright \zs2007\ze All Rights Reserved/2008/


Diff
----
vimdiff file1 file2 // diff two files side by side



Reformatting
------------
In the .vimrc file, `set textwidth=80` (or whatever column width).
gg  - go to top of file
gqG - globally set the entire file to 80 width column. It joins lines. If you
        dont want lines to be joined, have a blank one in between.
gq} - change only current paragraph
G   - go to beginning of last line
ga  - Gives ASCII value of character under cursor


Power of global(g) command
------------------
:[range]g/pattern/command
- Above command acts on [range] (default - whole file), by executing 'cmd'
  command, for each line matching 'pattern'.

Examples:
:g/pattern/d
- Delete all lines matching 'pattern'

:g/pattern/z#.5
- Display context (5 lines) for all occurrences of a pattern.

:g/pattern/z#.5 | echo "==========="
- Same as above but with some beautification.

:g!/pattern/d
:v/pattern/d
- Do NOT delete lines matching 'pattern'

:g/^\s*$/d
- Delete all blank lines. '^' start of line, '\s*' is zero or more white
  spaces, '$' end of line.



http://vim.wikia.com/wiki/Power_of_g

Wikia Tips
----------
1. Insert line numbers in file (not just display) or a portion of file?

    http://vim.wikia.com/wiki/Insert_line_numbers

    :%s/^/\=printf("%d", line("."))   // prints current line number. Read
                                      // above link for more granularity.

Code Indentation
----------------
1. Shift+V and then up/down
2. hit =


Vim Tips from Youtube talks
---------------------------
1) Highlight 80th column

" Make the 81st column stand out with magenta color
highlight ColorColumn ctermbg=magenta
" Call ColorColumn on 81st column virtually.
call matchadd('ColorColumn', '\81xv', 100)

Completion tips (tags, file name etc):
-------
2)
CTRL+r --> insert text from a register
CTRL+a --> insert last inserted text (access . register)

CTRL+p --> Keyword completion. 'p' means, look back in the document
CTRL+n --> Keyword completion. 'n' mean next

CTRL+x --> puts you in a special X mode (submode of insert mode). This allows
           you to autocomplete tags using tags file.
CTRL+x CTRL+] --> completes a class name (and such tags) when pressed after
                   letter

3) Vim keeps track of Jump List: files that Vim jumped to.
CTRL+i, CTRL+o --> you can go in and out of that list

4) Filename completion:
CTRL+x, CTRL+f --> vim completes file names from current directory

5) Context aware completion
CTRL+x, CTRL+p or CTRL+n
CTRL+x, CTRL+l --> context aware line completion

6) Context aware Omni completion
CTRL+x, CTRL+o

7) Auto completion settings
:set complete
    complete=.,w,b,u,t,i
    . = look in current buffer
    w = look in split window buffer (adjacent window)
    b = Other buffers, this or other Vim tab
    u = look in unloaded buffer, not active in any window
    t = look in tags file
    i = look in inserted file


[1] https://www.youtube.com/watch?v=aHm36-na4-4
[2] https://www.youtube.com/watch?v=3TX3kV3TICU

Vim Marks
---------
- Marks are points in file(s) that you can jump between.
- Three types of marks:
    * Lowercase marks - for points within a buffer/file.
    * Uppercase marks - for points across buffers/files.
    * Numbered marks - unmodifiable marks stored in viminfo file

- Mark can be set only in Normal mode as: m<alphabet>
    * <alphabet> can be uppper or lower case.
    * If reused, latest mark overrides previous mark.

- Jumping to a mark:
    `<alphabet>  takes you to position where mark is set
    '<alphabet>  takes you to beginning of line where mark is set

- Full power of mark is in combining them with other composable commands.


Vim Scripting Language
-------
Syntax of the Language: Verb + Noun
---
d   for delete
w   for word
combine to be "delete word"

- Commands are repeatable and undoable

Verbs in Vim
---
d   Delete
c   Change (delete and enter insert mode)
>   Indent
<   Outdent
v   Visually select
y   Yank (copy)

Nouns in Vim -- Motions
---
w   word (forward by a "word")
b   back (back by a "word")
2j  down 2 lines


Nouns in Vim -- Text Objects
---
iw      "inner word" (works from anywhere in a word)
it      "inner tag" (the contents of an HTML tag)
i"      "inner quotes"
ip      "inner paragraph"
as      "a sentence"


Nouns in Vim -- Parameterized Text Objects
---
f, F    "find" the next character
t, T    "find" the next character
/,?     Search up to next match


Tips for Mastering Vim Language
-----
- The 'dot' command should be guiding rule
- Visual mode means something is wrong


File Navigation
---
set path+=**    " recursive search all files in subdirectories
                " accepts wild chars. Works like fuzzy file search
                " Use with wildmenu

:b *file        " searches for files in buffer


Tag Jumping
----
command! MakeTags !ctags -R .

- Use ^] to jump to tag under cursor
- Use g^] for ambiguous tags
- Use ^t to jump back the tag stack

Autocomplete
----
^x^n    for just this file
^x^f    for file names
^x^]    tags only
^x^d    definition (in Vim's dictionary)
^x^i    Keywords in included files
^x^l    Lines (useful while writing Markdown)
^x^t    Thesaurus (Needs an input file)
^x^k    Dictionary
^x^s    Spelling
^x^v    Vim commands
^n      for anything specified by complete option

^n and ^p   go back and forth in suggestion list

Read docs at |ins-completion|


Intermediate Vim [5]
===
- Most commands are composed of an action and a motion
    * Actions do something
    * Motions move the cursor

- Uncommon Motions
    * Text objects: w, s, p, b, B, etc
        * Pneumonic?
            + "a word" -> aw
            + "inner block" -> ib
    * Last position in change list: g; (g, is go back)

Copy & Paste
---
- Forget Copy/Paste and think Registers
- You now have 35 copy buffers/registers
"+ is X server (i.e system) copy/paste register, copy to here to copy out of Vim
:reg    view content of registers
<C-r> in insert mode puts the register


Common Registers
---
"[1-9] history registers (or delete registers. It acts like a Queue)
"0 the yank register
"[a-z] are named registers
"[A-Z] samd as "[a-z] but append


Important Registers
---
"/  current search pattern
"-  small delete
"=  expression register
"_  the black hole register


Read-Only Registers
---
":  last :command
".  last inserted text
"%  filename of current buffer
"#  filename of alternate file (last file you edited)
:h registers

Undo and Redo Trees
---


Macros
---
- Recording a Macros starts by hitting q and then a letter, then sequence of
actions are recorded in that register.
- Hit q again to stop recording
- @<register-alphabet> will replay the macros actions


Windows
---
:h windows
- Lots of commands/help


Digraphs & Special Characters
---
- Digraphs: insert weird chars like: é,ä,etc
- In insert mode, ^k followed by one or two chars
:h digraphs


Templates
---
0r ~/path/to/template   << this puts entire template in to this file


Snippets
---
:ab list of abbreviations
- Ultisnips and Snipmate: provide better snippets support and advance features


Notes from [6, 7]
---
Vim Concepts
---
- Modal Editing: Normal, Insert, Visual, Ex (or Command) modes


text-objects
---
w       word
s       sentence
p       paragraph
t       tags as in XML/HTML files


Motions: Getting from a to b
---
word = Any set of alphanumeric chars. Does not include commas, period etc
WORD - Chars separated by whitespace (or the like)

Basics: wWbBeE
w       Forward to beginning of next word
W       Forward to beginning of next WORD
b       Backwards to beginning of next word
B       Backwards to beginning of next WORD
e       Forward to next end of word
E       Forward to next end of WORD
0       Zeroth char of the line
^       First non-blank char of line
$       Last char of line


Slightly less basic: fFtT
All follow: [number]<verb><noun> syntax
[n]f<o>     Forward until (nth) (o) Inclusive
[n]F<o>     Backward until (nth) (o) Inclusive
[n]t<o>     Forward until (nth) (o) Exclusive
[n]T<o>     Backward until (nth) (o) Exclusive


Searching
/   Forward
?   Backward
*   Word under cursor - Forward search (bounded)
g*  Word under cursor - Forward search (unbounded)
#   Word under cursor - Backward search (bounded)
g#  Word under cursor - Backward search (unbounded)

Motions
---
a       all
i       in
t       until
f       find
F       Find backwards

Commands
---
d       delete
c       change (delete + insert mode)
y       yank (copy)
v       visually select

[number]{command}{text object | motion}

// TODO: Below commands are 'repeatable', meaning you can use DOT command to
// repeat what they do

diw
daw
ca[     change everything including []
ci]     change everything inside []
ca      << there's space after 'a'
va"     visually select everything including "


Basic Insert Mode Operations
---
i   Enter insert mode at cursor
I   Enter insert mode at first non-blank char
s   Delete char under cursor and enter insert mode
S   Delete line and insert mode at beginning of same line
a   Enter insert mode _after_ cursor
A   Enter insert mode at end of line
o   Enter insert mode on next line
O   Enter insert mode above line
C   Delete from cursor to end of line and enter insert mode


==========   Ten Things You Don't Know About Vim [8]    ====================
In .vimrc, do following
set nocompatible    " not compatible with vi
filetype off

1) Help System. Very extensive
:help i_CTRL-V      " tells what CTRL-V does in insert mode
:help :help         " help about help
:help text-objects  " help about concepts 'text-objects'
:help gU            " help about key strokes
:help 'compatible'  " options
:help submatch()    " Vimscript functions
:help surround      " help about plugins after installing

- Vim is Upside-Down vs GUI editor. In Vim, action comes first and object next
    * [number]<verb><object> or [number]<verb><adverb><object>
    * Ex: diw, yw, c$

- Visual Mode is somewhat similar to GUI
    * Select object first and perform operation.

- Example. verb -> gU (change to Uppercase)
           object -> char, word or line

2) Visual Block Mode
- CTRL-V puts vim into Visual Block mode


3) Text-Object
- aw or iw: around word, inner word
- All text-objects start with a (around) or i (inner)
- Around includes whitespace or things like that with object of your interest
- Inner is just the object
- word, sentence (ending with .), paragraph

4) Registers
- Put something in a register
    "<alphabet><operation>
- Play something from a register
    @<register>

5) Macros
- Record operations in to a register and repeatedly apply them
q       start recording
a       record in to register a
<do your operations>
q       end recording

- But typing entire operation on a line and saving them into a register is more
  convenient.

- Suppose, at 36.48 in [1], user has list of names. He want's to number them and
  add ; at the end. They can type this on a line

A; I =b:i
)  l~j:let b:i+=1

6) Shell output in to Vim directly
:4,8!<shell cmd>
- Result of shell command is pasted in lines 4,8

7) Advanced search & replace
set hlsearch    " highlight search
set incsearch   " find as you type

- Search history by q/


8) Regular Exp in search
- Vim's regex is very bad
- Instead use "magic v"

/\v<regex>
- Now regex behaves like Perl regex

9) Browse vimrc session from within vim and live update settings and save it
using :mksession <session-name>.vim

- Later on, load that session using :source <session-name>.vim

10) Open an HTTPS file using :edit https://github.com/umbs/dotfiles/blob/master/vimrc

11) You can edit a tar.gz file "live" from within Vim

=======================

Vim important links

[1] https://raw.github.com/shawncplus/vim-classes/master/expert-1.md
[2] https://raw.github.com/shawncplus/vim-classes/master/expert-2.md


.vim/
  - after/
  - autoload/
  - bundle/ <<< when using Pathogen/Vundle etc
  - colors/
  - plugins/
  - syntax/

=============     Standard   Plugins  ==========
- AKA Global Plugins
- :help usr_05.txt (or :help standard-plugin)
- :help standar-plugin-list will list all of them



=============     Autocommands     =============
- Run commands automatically, as trigger to certain events such as file
  save/write etc.
- :help usr_40.txt
- :help autocmd.txt
- Syntax
    autocmd [group] {events} {file_pattern} [nested] {command}

- :help autocmd-events

// This is very extensive documentation. Read up for more info.


[1] https://www.youtube.com/watch?v=aHm36-na4-4
[2] https://www.youtube.com/watch?v=Qem8cpbJeYc
[3] https://www.youtube.com/watch?v=wlR5gYd6um0
[4] https://www.youtube.com/watch?v=XA2WjJbmmoM
[5] https://www.youtube.com/watch?v=v0W7JkzQAzA
[6] https://www.youtube.com/watch?v=5r6yzFEXajQ
[7] https://www.youtube.com/watch?v=Nim4_f5QUxA << basic Vim stuff
[8] Ten Things You Don't Know About Vim
https://www.youtube.com/watch?v=ZtfSm8nK1ag
[9]

================   Autocompletion in Vim    ==============
by Stephen Belcher

- Works in 'Insert' mode
- Ctrl-X puts you in special mode and then a command
    * Line completion (Ctrl-l)
    * File keywords (Ctrl-n/Ctrl-p)
    * Keywords in included files (Ctrl-i)
    * Dictionary Words (Ctrl-k)
    * Thesaurus Words (Ctrl-t)
    * Filenames (Ctrl-f)
    * Definitions/Macros (Ctrl-d)   // C and C++ languages
    * Vim command-line (Ctrl-v)
    * User-defined functions (Ctrl-u). These functions are custom
      auto-completion
    * Omni Completion (Ctrl-o)

- Use :pclose after Omni Completion suggestions

- :help ins-complete

[1] https://www.youtube.com/watch?v=VMPtoBe8Yi0

================   Registers in Vim    ==============
by Stephen Belcher

- Like clipboard, but there are many of them
- Persists between sessions
    * Saved in .viminfo
    * Read .viminfo, there'll be lot of useful info from previous Vim sessions

- Registers are (almost) always prefixed with "
    * Only scripts or macros prefix them with @

- To write in to register 'r', do the following
    "rdd    // dd is for write to

- To read from register 'e', do the following
    "ep     // p is for paste

- Vim doc breaks registers in to 10 groups

""  This is unnamed register. Any delete/change/x/s operation will put that text
in to "" register and then to named register if provided.

"0  Default destination for yanked text unless another register is provided like
this "ay. Now, text is copied to "a register and unnamed register :)

If you yank to unnamed register (""y) then a copy is made in "0 register. Vim
probably wants to maintain two copies

"1 thru "9 default destination for any multi-line deleted text

"1 is written on every delete, unless another register is specified ("bd4j)

Before delete in to "1, current contents of "1 are moved to "2, "2 to "3 and so
on. Contents of "9 fall off.

"-  deletions that are small (less than one line x, dw etc)

"a to "z. Only written to/read from when specifically asked.

"A thru "Z behave differently to "a thru "z
    * "add overwrites the "a register
    * "Add appends to "a register
    * Useful when u want to append non-contiguous lines

:help registers

:let @x = "value"   This will manually set contents of x register


[1] https://www.youtube.com/watch?v=sf1prtd_2E8

================   Macros in Vim    ==============
by Stephen Belcher

Definition: Recorded series of commands that can easily be replayed again and
again

Recursive Macros: A macro which calls itself, so that the macro automatically
repeats until it's finished

Recording Macros:
    * In NORMAL mode, press q and then any letter (example: qe). This is the
      register where macro is recorded
    * Follow with sequence of commands
    * Return to NORMAL mode and press q to stop recording

Playing Macros:
    * In NORMAL mode, press @, then the letter of register (example: @e)
    * This replays macros stored in register "e
    * Macro replay will stop when finished or hit an error

Viewing Macros:
    * In NORMAL mode, just do "<register-alphabet> where macro is registered
    * :registers
    * :registers "e

Editing Macros:
- You can copy contents of a Macro to file like this: "ep
- Edit the contents
- Copy them back to the register as: "edaW

    "e  -> In to register e
    d   -> delete
    a   ->
    W   -> Big word

More Macro Concepts:
- Macros are transactional
    * Entire actions of macros can be undone using 'u'
    * What happens if macro opens new file. Can you undo it?

- Macros can be repeated by pressing @@ in NORMAL mode
    * Think like @@ is special macro-specific register containing last executed
      macro

- Like any regular macro, they have command to execute themselves
    * Example: cw<REDACTED>^[n@e
    * The last @e makes it recursive macro

- Recursive Macros continue until they hit error condition


Creating Recursive Macros

Option 1:
    * Empty a macro register (qeq)
    * Record macro, including execution of current macro (@e) at the end

Option 2:
    * Record macro as usual (Example: qe ... q)
    * Append a macro execution via special upper-case register. So, have @e in
      your file, have cursor on @ and do this "E2x
    * Since upper-case registers are append only, they'll append @e to the "E
      register

Option 3:
    * Record macro as usual (Example: qe ... q)
    * In command-line mode, run following Vimscript command
        :let @e = @e . '@e'


[1] https://www.youtube.com/watch?v=ejOF_N8Hd04

====================== Vim   Help   System     ========================
:help
    CTRL-]          Jump to tag
    CTRL-T, CTRL-O  Jump back
    CTRL-I          Jump forward

    :help jumps     These are called jumplist


:helpgrep
    - This does text search in entire help manual.
    - Results are in quickfix window.
    - Do :copen and open results in quickfix.
    - :copen, cclose

:set wildmenu
    - Now :help pyth<tab>   will show various options statusline like bar.

$ vim -c "help help"    " Launch Vim. Enters :help help
$ vim -c "help help | only | syntax enable"


Bash function
$ function vimhelp() { vim -u NONE -c "help help | only | syntax enable"; }
$ vimhelp python    " this will open vim help for python


[1] https://www.youtube.com/watch?v=ghKR9rclP_8

====================== Vimscript (Talk by Prabir Shresta)  ========================
:help variables
    string          Job
    number          Channel
    float           Blob
    null
    dictionary
    list
    funcref

let string = "help"
let number = 1
let float = 1.0
let list = [1, 2, "hello", "world"]
let dictionary = {"message": "hello world"}


- Multiline statement
    let list = [
        \ 1, 2,
        \ "hello",
        \ "world" ]

- Some quirks. Comments cannot be inline in a multiline code. Example of multi
  line code

- Special Variables
    let t = v:true
    let f = v:false
    let n = v:null
    " All variables starting with v:<something> are read only.

- Variable Scoping

        let g:global_var = "global variable accessible across all script"
        let s:script_var = "script level variable accessible across the entire script/file"
    let l:local_var = "local variable accessible only in the scope"
    let b:buffer_var = "buffer scope"
    let w:window_var = "window scope"
    let t:tab_var = "tab scope"


Functions
---
- :help function

:help list
:help dict
        APIs to interact with list and dict
        add, remove, has_key, copy, keys, items()

:h write-plugin

[1]
https://www.youtube.com/watch?v=7fcJWwl1-SU&list=PLcTu2VkAIIWzD2kicFNHN2c35XQCeZdsv&index=18

====================== Vimscript (Steve Losh)  ========================
- On Linux and Mac OSX, ~/.vimrc and Windows ~/_vimrc
- :echo $MYVIMRC, tells where this file is on any OS

Persistent Echoing
---
  :echo "Hello World"
  :echom "Hello World, Again"   <<< persistent and shown in :messages
  :messages

Options
===

Boolean Options
---
  :set <option>     " :set number
  :set <nooption>   " :set nonumber
  :set <option>!    " :set number!  Toggles the option
  :set <option>?    " :set number?  Find settings


Option with Value
---
  :set <option>=<value>     " :set numberwidth=4
  :set <option>?            " :set numberwidth?


  :setlocal <option>=<value>    " set only for local buffer
  " Not all options can be used with 'setlocal'. Read it's :help for details.

Basic Mappings
---
    :map <lhs> <rhs>

<lhs>   This could be basic chars or special chars like <space> or <c-d>
<rhs>   Group of commands that'll be run

- Modal Mapping: nmap, vmap, imap
- Each of *map has a *noremap counterpart
    map, noremap
    nmap, nnoremap
    vmap, vnoremap
    imap, inoremap


Leader Key: Vim let's you set any key as leader as follows:
---
    :let mapleader = "-"    " - is leader key

<leader> means, whatever I have my leader key set to.

- Why do you need <leader> key at all?
    * Easy to change <leader> mapping.
    * Other's can understand what <leader> means and can copy your .vimrc file.
    * Many plugins use <leader> key in their mappings. Easy for you to use them.

:nnoremap          <leader>d dd     " mapping applies to all buffers
:nnoremap <buffer> <leader>x dd     " mapping applies to current buffer.

- Instead of <buffer> in mappings, <localleader> is recommended.

Local Leader Key: Used for mappings on specific file types (Python, HTML etc)
---
    :let maplocalleader = "\\"      " \ is escape char in Vimscript. Must use \\



Abbreviations
---
- Very similar to mappings, but done in insert, replace and command modes.
- Usually done for spelling corrections. For insert mode,
    :iabbrev adn and
    :iabbrev waht what
    :iabbrev tehn then

- Vim substitutes an abbreviation when you type "non-keyword character" after an
  abbreviation.

- What is "non-keyword character"?
    * :set iskeyword?
    * It's complicated. Read here :help isfname (too complicated)
    * https://learnvimscriptthehardway.stevelosh.com/chapters/08.html
    * Assume that abbrev expands when you type anything other than letter,
      underscore or number

- Difference between Mappings and Abbreviations
    * Mappings don't take in to account chars before and after the map.
    * Abbreviations. Vim pays more attention to chars before and after.


- Read up
    :help local-options
    :help setlocal
    :help map-local


Shadowing
---
https://learnvimscriptthehardway.stevelosh.com/chapters/11.html


Autocommands: a way to tell Vim to run certain commands whenever certain events
happen.
---
- Syntax
    autocmd [group] {events} {file_pattern} [nested] {command}

- Ex:

:autocmd BufNewFile * :write
         ^          ^ ^
         |          | |
         |          | The command to run.
         |          |
         |          A "pattern" to filter the event.
         |
         The "event" to watch for.


- :help autocmd-events

- Autocommands offer many events to watch.


Examples:
" Save (Write to disk) a buffer whenever it is new and opened
:autocmd BufNewFile * :write

" Same as above, but only to files with .txt extension
:autocmd BufNewFile *.txt :write


" Just before saving html file, reindent
:autocmd BufWritePre *.html :normal gg=G


" Multiple events. Same as above, but while reading too.
:autocmd BufWritePre,BufRead *.html :normal gg=G

" When you read or open a new html file, don't wrap lines.
:autocmd BufNewFile,BufRead *.html setlocal nowrap



FileType Events
---
" Comment out an entire line in Javascript file when you do <localleader>c
:autocmd FileType javascript nnoremap <buffer> <localleader>c I//<esc>

" Comment out an entire line in Python file when you do <localleader>c
:autocmd FileType python     nnoremap <buffer> <localleader>c I#<esc>


Autocommands and Abbreviations
---
- Pair up Autocommands and buffer-local abbreviations to form our own snippet
  system.

    :autocmd FileType python    :iabbrev <buffer> iff if:<left>


Autocommand Groups: Read LVSHW for details.
    :help autocmd-groups

- When you create same autocmd multiple times, Vim does not override
  earlier one.
- Problem compounds if you have autocmd in your .vimrc and each time you source
  it, duplicate autocmds get created.

- The extra space is not required. Done only for readability.

:augroup testgroup
:    autocmd BufWrite * :echom "Foo"
:    autocmd BufWrite * :echom "Bar"
:augroup END

- When you use augroup multiple times, Vim "combines" them. Does union of
  autocmds.
- If you don't want union and want to clear a group, use 'autocmd!' at the
  start.

:augroup testgroup
:    autocmd!
:    autocmd BufWrite * :echom "Cats"
:augroup END



15. Operator-Pending Mappings
---

16. More Operator-Pending Mappings
---

17. Status Lines
---



Unclear
----
- In chapter 'Operator-Pending Mapping', unclear on \r translating to <cr>
  inside the script

Reading:
----
:help normal
:help execute
:help expr-quote
:help pattern-overview
:help statusline


[1] https://learnvimscriptthehardway.stevelosh.com/

----------------------------
Navigating Neovim Terminals

- See `:help terminal-emulator` for more info
- Ways to spawn a terminal
    :terminal
    :term://bash    spawns bash terminal
    :term://zsh     spawns zsh terminal
    :term://htop    runs htop in new term
    :vsplit term://zsh
    :split term://bash


- Ctrl+\ Ctrl+n puts you in 'normal' mode. After that, it is like navigating
  another window in Vim.

- Navigating between windows is only possible in Normal Mode.


[1] https://vid.bina.me/tools/nvim/terminal-in-nvim/

----------------------------
Up and Running with Neovim + LSP
- There is native support for LSP in Neovim. But nvim-lspconfig makes it *easy*
  to setup the LSP config
- Understood plugin files are laid out, especially making use of Lau support in
  Neovim.

- Installation of LSP plugin
    Plug 'neovim/nvim-lspconfig'
- Note that `nvim-lspconfig` is NOT a client. With plugin, it is easy to
  configure LSP client to talk to LSP server, manage it etc.

- You can setup the config in `init.vim` like this
    lua << EOF
    require'lspconfig'.pyright.setup{}
    EOF

    OR, just this in `lua` folder inside .config/nvim/lua/
    require'lspconfig'.pyright.setup{}

- Lots of info about `lua` directory and namespace directory inside that
  directory. This is best practice [3]
- For every plugin, create a .lua file in this namespace folder
- Read up [2] for more details

- Discussions on root_dir for LSP to know where to start. Each server has their
  way. Read up on pyright's configurations [4]

- on_attach function during setup of LSP server. Watch at this timestamp [5] and
  look for configuration at [6]


References:
[1] https://youtu.be/36o52-2_83M
[2] https://www.jakewiesler.com/blog/getting-started-with-vim
[3] https://github.com/nanotee/nvim-lua-guide#tips
[4] https://github.com/microsoft/pyright/blob/main/docs/configuration.md
[5] https://youtu.be/36o52-2_83M?t=1557
[6] https://github.com/neovim/nvim-lspconfig#suggested-configuration


----------------------------
nvim-lsp-installer
    github.com/williamboman/nvim-lsp-installer

References:
[1] Neovim - LSP setup tutorial (Built in LSP 100% Lua)

----------------------------
Vim - Tutorial on Customizations and Configuration
- Leeren Chen(?)

1. Initialization


----------------------------
Vim Spellchecking

:set spell spelllang=en_us
:set nospell

# Only on local buffer
:setlocal spell spelllang=en_us
:setlocal nospell

]s  Jump to next mispelled word
[s  Jump to previous mispelled word

z=  Provide suggestions for word under the cursor.
zg  Word is correct. Add to dictionary.
zw  Mark word as incorrect.


----------------------------
Vim Insert Current Date and Time
- Vim's internal strftime() function (:help strftime()) returns a date/time             :help strftime()
  string formatted in a way you specify with a format string. Most systems
  support strftime(), but some don't.

    :put =strftime(\"%c\")
    :put =strftime('%c')


- To map this to a key
    :nnoremap <F5> "=strftime("%c")<CR>P
    :inoremap <F5> <C-R>=strftime("%c")<CR>


- Read up my notes on strftime() in Python.txt for various formatting options.

        Format String              Example output
        -------------              --------------
        %c                         Thu 27 Sep 2007 07:37:42 AM EDT (depends on locale)
        %a %d %b %Y                Thu 27 Sep 2007
        %b %d, %Y                  Sep 27, 2007
        %d/%m/%y %H:%M:%S          27/09/07 07:36:32
        %H:%M:%S                   07:36:44
        %T                         07:38:09
        %m/%d/%y                   09/27/07
        %y%m%d                     070927
        %x %X (%Z)                 09/27/2007 08:00:59 AM (EDT)
        %Y-%m-%d                   2016-11-23
        %F                         2016-11-23 (works on some systems)

        RFC822 format:
        %a, %d %b %Y %H:%M:%S %z   Wed, 29 Aug 2007 02:37:15 -0400

        ISO8601/W3C format (http://www.w3.org/TR/NOTE-datetime):
        %FT%T%z                    2007-08-29T02:37:13-0400

[1] https://vim.fandom.com/wiki/Insert_current_date_or_time

==========================     Netrw Commands      =============================

" Verify these. Its generated by ChatGPT and I'm not sure they are 100% correct

:Explore or :E  Open Netrw in the current window.
<Enter> Open file/directory under the cursor.
o   Open file/directory in a new horizontal split.
v   Open file/directory in a new vertical split.
t   Open file/directory in a new tab.
<C-t>   Open file/directory in a new tab silently (without switching to it).
R   Rename a file/directory.
D   Delete a file/directory.
%   Create a new file/directory.
-   Jump to the parent directory.
~   Jump to the user's home directory.
q   Close the Netrw window.
gx  Open the file under the cursor using the system default program.


Navigation:
h   Move left.
j   Move down.
k   Move up.
l   Move right.


Modes:
i   Toggle between thin and wide listing.
I   Toggle hidden files.


File Operations:
mf  Mark a file.
mt  Mark a directory.
mD  Unmark all files/directories.
mc  Copy marked files/directories.
mx  Cut marked files/directories.
md  Create a directory.
mR  Move marked files/directories.
mD  Delete marked files/directories.
:NetrwMark  List marked files/directories.


Miscellaneous:
!   Invoke shell commands on the file/directory under the cursor.
C   Change the current directory.


================== A Little :help - Dan Phillips (VimConf 2021 Talk) ================
:TOhtml
    - Converts current buffer into an HTML page

- Two types of help manual: User and Reference
- motions.txt, index.txt: They are Reference Manual. But read them.
- quotes.txt is fun

- https://vim.help is a better formatted webpage of Vim manuals.
- g + CTRL-g will give word count, total words, line, column, byte count.
- K for Unix man page.


================== Vim as an IDE (VimConf 2020 Talk) ================
Leeren Chan

        7 Steps for Setting up Vim as Lightweight IDE

- Open a file as follows:
	vi -Nu NORC <filename>
	-Nu: Open in "No Compatible Mode". Meaning, open using Vim
	NORC: Even if there is no .vimrc file, Vim uses a default vimrc file
	      somewhere in the system. By providing NORC flag, we tell Vim, not
              to use that default vimrc.

- Ex command
    :set filetype?	# filetype is not turned on

    :filetype plugin indent on

    This turns on following:
        - detection of filetypes
        - any plugins related to that filetype (not fully sure)
        - turn on indentations


- `syntax on`
    - Turns syntax highlighting

- set backspace=start,eol,indent
    - This allows backspace to work even before where you started typing.



1. MAKE A MINIMAL VIMRC
  - Whichever of the following is found first will be used:
        $VIMINIT        (environment variable)
        $HOME/.vimrc
        $HOME/.vim/vimrc    <<<< suggested by Leeren
        $EXINIT         (environment variable)
        $HOME/.exrc
        $VIMRUNTIME/defaults.vim


- On some machines you can set minimum Vim settings as environment variable
  $VIMINIT and that's enough for Vim. You do not need a .vimrc file.

2. FIX FORMATTING
- Choose standards of your language
- Python (PEP8)
    - 4 spaces per indentation level.
    - Limit lines to 79 chars.

- `set list` shows all the special chars used in that file.
- set shiftwidth=4 tabstop=4 softtabstop=4 expandtab autoindent smartindent

- runtimepath
    - A list of directories will be searched for runtime files, in following order

    runtimepath Search Order
    ------------
    1. User Home .vim folder
    2. Sysadmin folder
    3. $VIMRUNTIME
    4. Sysadmin "after" folder
    5. User Home "after" folder in .vim

    What does runtimepath search? It searches for folder structure as follows

    compiler/
    ftdetect/
    filetype.vim
    scripts.vim
    autoload/
    ftplugin/
    plugin/
    pack/
    colors/
    doc/
    import/
    keymap/
    lang/
    menu.vim
    print/
    ...


    If you want *something* specific to, say, python, put it in here:
        .vim/after/ftplugin/python.vim
    Example, put following in python.vim in above:
        set shiftwidth=4 tabstop=4 softtabstop=4 expandtab autoindent smartindent


3. FIX YOUR PATH
- Strongly recommend setting current directory (`:pwd`) to to root of the
  project.

- After that, figure out parts of the project that are frequently explored. Add
  those to your `:path`
    - set path?

- For browsing outside your main project context, make use of `:lcd` and
  `:setlocal path`


4. SETUP INCLUDE-SEARCH
- `include-search` is very powerful. It defines commands and patternst that
  allow for instantly locating symbol definitions (like functions, variables,
  and macros)

  - `include`
    - Used to define which files should be traversed for searching of relevant symbols

  - `define`
    - Finds macro definitions (works in tandem with `include`)

- It's quite crazy/complex. But speaker says its very powerful.


5. SETUP TAGS
- When `include-search` fails, tags are the best fallback option to use. All it
  requires is creating a tags file for your project and keeping in sync after
  making changes.
- For prog languages like Go, it's difficult to use `include-search`. Instead use ctags

    ~/.ctags file has this
    ----------------------
    --langdef=Go
    --langmap=Go:.go
    --regex-Go=/func() ... watch the video around 52 min mark.


6. COMPILER SUPPORT
- Integrate a compiler with vim's `makeprg` and `errorformat` for seamless
  compile-and-edit workflows

    compiler/   <<<< put here
    ftdetect/
    filetype.vim
    scripts.vim
    autoload/
    ftplugin/
    plugin/
    pack/
    colors/
    doc/
    import/
    keymap/
    lang/
    menu.vim
    print/
    ...

- In ~/.vim/compiler/go.vim file add this

    let current_compiler = 'go'
    CompilerSet makeprg=go\ build

    # Typically this is how Go errors look
    CompilerSet errorformat=%E%f:%l:%c:%m
        E = Error
        f = file
        l = line number
        c = column number
        m = error message



7. MAKE CONFIG PORTABLE
- Use GNU stow
- Have a common folder, called `configs` (can be any name). Have various
  configs in them, say for `vim` as follows.
    $ mkdir -p ~/configs/vim
    $ cd config
    $ cp -R ~/.vim vim
    $ rm -fr ~/.vim
    $ tree -a
        vim
        └── .vim
            ├── after
            │   └── ftplugin
            │       └── python.vim
            └── vimrc

        4 directories, 3 files

    $ stow vim
    $ ll ~/.vim
    lrwxr-xr-x  1 bupadhyayula    16B Dec 19 10:22 /Users/bupadhyayula/.vim -> configs/vim/.vim

    $ git init  # start using version control and all that