1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
Vimple
------

__Pacifying Vimmers__

++Version 0.9 -- Lil' Vimmer++

http://of-vim-and-vigor.blogspot.com/2012/03/pacifying-vimmers.html[Ad]

Perhaps most usefully, Vimple provides a few maps and commands to make
the casual vimmer's life a little easier, such as:

=== `:View ex-command`

Opens a split with the output of `ex-command`.

=== `z=`

Shows spelling suggestions in an overlay window. Pressing `<enter>`
will replace the word under the cursor in the original window with the
current word under the cursor in the overlay.

Use `<plug>vimple_spell_suggest` if you want to map this behaviour
to a differnt key.

=== `[I`

Shows identifier search results in an overlay window. Pressing `<enter>`
will jump to the associated line of the identifier under the cursor.

Use `<plug>vimple_ident_search` if you want to map this behaviour
to a differnt key.

=== `g]`

Shows tag search results in an overlay window. Pressing `<enter>`
will jump to the associated line of the tag under the cursor.

Use `<plug>vimple_tag_search` if you want to map this behaviour
to a differnt key.

=== `SCall( script , function , arg )`

A function which calls script-local `function` in `script`
with arguments `arg`. This lets you call `<SNR>` / `s:`
functions by script name rather than SNR (script-number).

=== `:Silently ex-command`

Performs the series of bar-separated ex-commands silently.

=== `:QFdo ex-command`

Performs the series of bar-separated ex-commands over the buffers in the QuickFix list.

NOTE: The location-list analogue is `:LLdo`

=== `:BufTypeDo type ex-commands`

Performs the series of bar-separated ex-commands over the buffers of the given +type+.

=== `:BufMatchDo pattern ex-commands`

Performs the series of bar-separated ex-commands over the buffers with names matching +pattern+.

=== `:Collect register-or-variable ex-command`

Saves the output of `ex-command` into the specified register
or variable.

=== `Collect('register-or-variable ex-command')`

Saves the output of `ex-command` into the specified register
or variable and returns the output for further use in
expressions.

=== `GCollect( pattern )`

Uses `pattern` in a `:global /pattern/` command and returns
the results as a list of lines.

    :echo GCollect('^\s*===\s*')

=== `GCCollect( pattern )`

Uses `pattern` in a `:global /pattern/` command and returns
the results as a list of lines with the `pattern` stripped.

    :echo GCCollect('^\s*===\s*')

=== `:MyMaps`

Shows your currently active |:map|s and |:imap|s in a new buffer.  :MyMaps
attempts to group related maps to more easily allow you to create a custom map
layout for your various |'filetype'|s.

=== `Scope()`

The Scope() function attempts to show the current function or
class/method scope. Some people like to display this information in
their `statusline`, like:

  set statusline=%f%m%r%h%w\ [%n:%{&ff}/%Y]\%{Scope()}%=[0x\%04.4B][%03v][%p%%\ line\ %l\ of\ %L]

Currently only Vim & Python (and Python only for testing purposes, created by a NON Pythonista -- patches welcome) have been implemented, but it is very easy for you to write scope functions for your own filetypes. Take Ruby for example: Create `~/.vim/ftplugin/ruby_scope.vim` like this:

----
function! Scope_ruby()
  let class_scope  = scope#inspect('^\s*class\s\+\([a-zA-Z0-9_.]\+\)', '^\s*end')
  let method_scope = scope#inspect('^\s*def\s\+\([a-zA-Z0-9_.]\+\)', '^\s*end')
  return ' ' . join(map(class_scope.stack, 'v:val.head_line_number . "," . v:val.tail_line_number . " " . v:val.head_string'), ' :: ')
        \. ' >> ' . join(map(method_scope.stack, 'v:val.head_line_number . "," . v:val.tail_line_number . " " . v:val.head_string'), ' > ')
endfunction
----

NOTE: The above example for Ruby is woefully inadequate. A better effect
might be achievable with more context in the regex patterns. The
patterns in `syntax/ruby.vim` might be useful. Parsing with regex is futile.

=== Composable Completions

By default, `jj` in insert mode activates a user-extendible
meta-completion list. The default list includes abbreviations (if you
have https://github.com/dahu/Aboriginal), some date-time patterns and
the built-in dictionary completion (`<c-x><c-k>`).

The default `jj` can be overridden like this:

  imap <c-x><c-c> <plug>vimple_completers_trigger

Vimple also provides VimLOO (Object Oriented VimL) objects
for these read-only ++:ex++ commands:

* ++:ls++          -- vimple#bl
* ++:scriptnames++ -- vimple#sn
* ++:highlight++   -- vimple#hl
* ++:version++     -- vimple#vn
* ++:marks++       -- vimple#ma
* ++:undolist++    -- vimple#ul
* ++:maps++        -- vimple#mp

NOTE: The awesome plugin
https://github.com/Raimondi/vim-buffalo[buffalo] uses the
`vimple#bl` object.

In addition to these existing ++:ex++ wrappers, Vimple allows
developers to craft their own objects too. See autoload/vimple/*.vim
for examples.