├── .gitignore
├── .travis.yml
├── HISTORY.md
├── LICENSE.md
├── Makefile
├── README.md
├── autoload
    └── closer.vim
├── doc
    └── closer.txt
├── plugin
    └── closer.vim
└── test
    ├── closer_test.vader
    ├── endwise
        └── endwise_test.vader
    └── javascript_test.vader


/.gitignore:
--------------------------------------------------------------------------------
1 | vendor
2 | doc/tags
3 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: ruby
2 | script: make test
3 | 


--------------------------------------------------------------------------------
/HISTORY.md:
--------------------------------------------------------------------------------
 1 | ## v0.2.0
 2 | > Sep 28, 2015
 3 | 
 4 | * JavaScript: add semicolons in the file when `'use strict';` is found.
 5 | 
 6 | ## v0.1.2
 7 | > Jun 19, 2015
 8 | 
 9 | * Hotfix to actually make the last version's change work.
10 | 
11 | ## v0.1.1
12 | > Jun 19, 2015
13 | 
14 | * Prevent semicolons in if/else in JavaScript.
15 | 
16 | ## v0.1.0
17 | > Jun  3, 2015
18 | 
19 | * Initial release.
20 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 Rico Sta. Cruz
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | vim := vim
 2 | 
 3 | test: test-plain test-endwise
 4 | 
 5 | test-plain: vendor/vimrc
 6 | 	@echo env HOME="$(shell pwd)/vendor" ${vim} -Nu $< +"Vader! test/*"
 7 | 
 8 | test-endwise: vendor/vimrc
 9 | 	@env test_endwise=1 HOME="$(shell pwd)/vendor" ${vim} -Nu $< +"Vader! test/endwise/* test/*"
10 | 
11 | vim: vendor/vimrc
12 | 	@env HOME="$(shell pwd)/vendor" ${vim} -Nu $<
13 | 
14 | vendor/vimrc: vendor/vader.vim vendor/vim-endwise
15 | 	@mkdir -p ./vendor
16 | 	@echo "filetype off" > $@
17 | 	@echo "set rtp+=vendor/vader.vim" >> $@
18 | 	@echo "set rtp+=vendor/vim-endwise" >> $@
19 | 	@echo "set rtp+=." >> $@
20 | 	@echo "filetype plugin indent on" >> $@
21 | 	@echo "syntax enable" >> $@
22 | 
23 | vendor/vader.vim:
24 | 	@mkdir -p ./vendor
25 | 	@git clone https://github.com/junegunn/vader.vim.git ./vendor/vader.vim
26 | 
27 | vendor/vim-endwise:
28 | 	@mkdir -p ./vendor
29 | 	@git clone https://github.com/tpope/vim-endwise.git ./vendor/vim-endwise
30 | 
31 | .PHONY: test vendor/vimrc doc
32 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # vim-closer
 2 | 
 3 | **Closes brackets.** Perfect companion to [vim-endwise]. Basically, a more conservative version of [auto-pairs] that only works when you press Enter.
 4 | 
 5 | > NB: This plugin is known to have issues when used with COQ.nvim. See [#37](https://github.com/rstacruz/vim-closer/issues/37).
 6 | 
 7 | ----
 8 | 
 9 | ![](https://raw.githubusercontent.com/rstacruz/vim-closer/gh-pages/closer.gif)
10 | 
11 | ----
12 | 
13 | [![Status](http://img.shields.io/travis/rstacruz/vim-closer/master.svg)](https://travis-ci.org/rstacruz/vim-closer/ "See test builds")
14 | 
15 | [auto-pairs]: https://github.com/jiangmiao/auto-pairs
16 | [vim-endwise]: https://github.com/tpope/vim-endwise
17 | 
18 | <br>
19 | 
20 | ## What
21 | 
22 | Closings are automatically inserted after pressing <kbd>Enter ⏎</kbd>. It supports languages that have `(`, `[`, and `{` brackets.
23 | 
24 | ```css
25 | .section {⏎
26 | ```
27 | 
28 | ```css
29 | .section {
30 |   |
31 | }
32 | ```
33 | 
34 | It tries to automatically figure out whatever braces were opened in the line. This is useful for, say, JavaScript where `});` is commonly seen.
35 | 
36 | ```js
37 | describe('test', function () {⏎
38 | ```
39 | 
40 | ```js
41 | describe('test', function () {
42 |   |
43 | })
44 | ```
45 | 
46 | Semicolons are automatically added if it makes sense, and only if another line in the buffer ends in `;`.
47 | 
48 | ```js
49 | var x = 1;
50 | setImmediate(function () {⏎
51 | ```
52 | 
53 | ```js
54 | var x = 1;
55 | setImmediate(function () {
56 |   |
57 | });
58 | ```
59 | 
60 | <br>
61 | 
62 | ## Install
63 | 
64 | When using [vim-plug], add this to your `~/.vimrc`:
65 | 
66 | [vim-plug]: https://github.com/junegunn/vim-plug
67 | 
68 | ```vim
69 | Plug 'rstacruz/vim-closer'
70 | ```
71 | 
72 | <br>
73 | 
74 | ## By the way
75 | 
76 | Do you edit CSS often? Of course you do. Let me help you make that [a better experience.](http://ricostacruz.com/vim-hyperstyle/)
77 | 
78 | <br>
79 | 
80 | ## Thanks
81 | 
82 | **vim-closer** © 2015+, Rico Sta. Cruz. Released under the [MIT] License.<br>
83 | Authored and maintained by Rico Sta. Cruz with help from contributors ([list][contributors]).
84 | 
85 | > [ricostacruz.com](http://ricostacruz.com) &nbsp;&middot;&nbsp;
86 | > GitHub [@rstacruz](https://github.com/rstacruz) &nbsp;&middot;&nbsp;
87 | > Twitter [@rstacruz](https://twitter.com/rstacruz)
88 | 
89 | [MIT]: http://mit-license.org/
90 | [contributors]: http://github.com/rstacruz/vim-closer/contributors
91 | 


--------------------------------------------------------------------------------
/autoload/closer.vim:
--------------------------------------------------------------------------------
  1 | if exists("g:closer_autoloaded") | finish | endif
  2 | let g:closer_autoloaded=1
  3 | 
  4 | if maparg("<Plug>CloserClose") == ""
  5 |   inoremap <silent> <SID>CloserClose <C-R>=closer#close()<CR>
  6 |   imap <script> <Plug>CloserClose <SID>CloserClose
  7 | endif
  8 | 
  9 | "
 10 | " Enables closer for the current buffer.
 11 | "
 12 | 
 13 | function! closer#enable()
 14 |   " Based on tpope's vim-eunuch <CR> mapping function
 15 |   if ! exists('b:closer_flags') | return | endif
 16 |   let b:closer = 1
 17 |   let oldmap = maparg('<CR>', 'i', 0, 1)
 18 |   let rhs = substitute(get(oldmap, 'rhs', ''), '\c<sid>', '<SNR>' . get(oldmap, 'sid') . '_', 'g')
 19 | 
 20 |   if get(g:, 'closer_no_mappings') || rhs =~# '\MCloserClose\|closer#close'
 21 |     return
 22 |   endif
 23 | 
 24 |   if get(oldmap, 'expr')
 25 |     exe 'imap <script><silent><expr> <CR> closer#close(' . rhs . ')'
 26 |   elseif rhs =~? '^<cr>' && rhs !~? '<plug>'
 27 |     exe 'imap <silent><script> <CR>' rhs . '<SID>CloserClose'
 28 |   elseif rhs =~? '^cr'
 29 |     exe 'imap <silent> <CR>' rhs . '<SID>CloserClose'
 30 |   elseif empty(rhs)
 31 |     imap <script><silent><expr> <CR> closer#close("\r")
 32 |   endif
 33 | endfunction
 34 | 
 35 | "
 36 | " Adds a closing bracket if needed.
 37 | " Executed after pressing <CR>
 38 | "
 39 | 
 40 | function! closer#close(...)
 41 |   " tpope madness to play nicely with other plugins' <CR> mappings
 42 |   if a:0 && type(a:1) == type('')
 43 |     return a:1 . (a:1 =~# "\r" && empty(&buftype) ? "\<C-R>=closer#close()\r" : "")
 44 |   endif
 45 | 
 46 |   if ! get(b:, 'closer') | return '' | endif
 47 | 
 48 |   " supress if it broke off a line (pressed enter not at the end)
 49 |   if match(getline('.'), '^\s*$') == -1 | return '' | endif
 50 | 
 51 |   let ln = line('.') - 1
 52 |   let line = getline(ln)
 53 |   let indent = matchstr(line, '^\s*')
 54 | 
 55 |   let closetag = s:get_closing(line)
 56 |   if closetag == '' | return "" | endif
 57 | 
 58 |   let closetag = closetag . s:use_semicolon(ln)
 59 | 
 60 |   " <esc>a will go back to the 0.
 61 |   " I dont know why <esc>A is needed at the end, but it seems to fix
 62 |   " pressing escape after expansion.
 63 |   return "\<Esc>a" .indent . closetag . "\<C-O>O\<Esc>a" . indent . "\<Tab>\<Esc>A"
 64 | endfunction
 65 | 
 66 | "
 67 | " Returns the context of the function
 68 | " simply returns whatever's on the previous level of indentation
 69 | "
 70 | 
 71 | function! s:get_context()
 72 |   let ln = line('.') - 1
 73 |   let indent = strlen(matchstr(getline(ln), '^\s*'))
 74 |   while ln > 0
 75 |     let ln = prevnonblank(ln-1)
 76 |     let lntext = getline(ln)
 77 |     let nindent = strlen(matchstr(lntext, '^\s*'))
 78 |     if nindent < indent | return lntext | endif
 79 |   endwhile
 80 |   return 0
 81 | endfunction
 82 | 
 83 | "
 84 | " Checks if a semicolon is needed for a given line number
 85 | "
 86 | 
 87 | function! s:use_semicolon(ln)
 88 |   " Only add semicolons if the `;` flag is on.
 89 |   if ! exists('b:closer') | return '' | endif
 90 |   if match(b:closer_flags, ';') == -1 | return '' | endif
 91 | 
 92 |   " Only add semicolons if another line has a semicolon.
 93 |   let used_semi = search(';$', 'wn') > 0
 94 |   if used_semi == "0" | return '' | endif
 95 | 
 96 |   " Don't add semicolons for lines matching `no_semi`.
 97 |   " This allows `function(){ .. }` and `class X { .. }` to not get semicolons.
 98 |   let line = getline(a:ln)
 99 |   let topline = getline(a:ln - 1)
100 |   if b:closer_no_semi != '0' && match(line, b:closer_no_semi) > -1
101 |     return ''
102 |   elseif b:closer_no_semi != '0' && b:closer_semi_check_top != '0' && match(topline, b:closer_no_semi) > -1
103 |     return ''
104 |   endif
105 | 
106 |   " Don't add semicolons for context lines matching `semi_ctx`.
107 |   " This allows supressing semi's for those inside object literals
108 |   let ctx = s:get_context()
109 |   if ctx != '0'
110 |     " if context is not a js function, don't semicolonize
111 |     if b:closer_semi_ctx != '0' && match(ctx, b:closer_semi_ctx) == -1 | return '' | endif
112 |   endif
113 | 
114 |   return ';'
115 | endfunction
116 | 
117 | "
118 | " Returns the closing tag for a given line
119 | "
120 | "     get_closing('describe(function() {')
121 | "     => '});'
122 | "
123 | "     get_closing('function x() {')
124 | "     => '}'
125 | "
126 | 
127 | function! s:get_closing(line)
128 |   let i = -1
129 |   let clo = ''
130 |   while 1
131 |     let i = match(a:line, '[{}()\[\]]', i+1)
132 |     if i == -1 | break | endif
133 |     let ch = a:line[i]
134 |     if ch == '{'
135 |       let clo = '}' . clo
136 |     elseif ch == '}'
137 |       if clo[0] != '}' | return '' | endif
138 |       let clo = clo[1:]
139 |     elseif ch == '('
140 |       let clo = ')' . clo
141 |     elseif ch == ')'
142 |       if clo[0] != ')' | return '' | endif
143 |       let clo = clo[1:]
144 |     elseif ch == '['
145 |       let clo = ']' . clo
146 |     elseif ch == ']'
147 |       if clo[0] != ']' | return '' | endif
148 |       let clo = clo[1:]
149 |     endif
150 |   endwhile
151 |   return clo
152 | endfunction
153 | 


--------------------------------------------------------------------------------
/doc/closer.txt:
--------------------------------------------------------------------------------
 1 | *closer.txt*  automatically close brackets
 2 | *vim-closer*
 3 | 
 4 | ==============================================================================
 5 | INTRODUCTION                                                            *closer*
 6 | 
 7 | |closer| automatically closes brackets for you.
 8 | 
 9 | http://github.com/rstacruz/vim-closer
10 | 
11 | ==============================================================================
12 | CONFIGURATION                                             *closer-configuration*
13 | 
14 |   *g:closer_no_mappings*
15 |     Set this to `1` to suppress vim-closer's keybindings (default `null`). Use
16 |     this when using with other plugins that might also rely on binding `<CR>`.
17 | 
18 |     When set to `1`, this requires setting bindings like so:
19 | >
20 |       imap <CR> <CR><Plug>CloserClose
21 | <
22 | ==============================================================================
23 | BUFFER CONFIGURATION                               *closer-buffer-configuration*
24 | 
25 |   Using configuration:~
26 |     See the plugin/closer.vim source for information on how to set
27 |     configuration flags for filetypes.
28 |     http://github.com/rstacruz/vim-closer/blob/master/plugin/closer.vim
29 | 
30 |   *b:closer*
31 |     Enables vim-closer behavior. Set this to `0` to temprarily disable.
32 | 
33 |   *b:closer_flags*
34 |     A list of flags. Available flags:
35 | 
36 |        `([{`  close these braces
37 |        `;`    use semicolons
38 | 
39 |   *b:closer_no_semi*
40 |     When the line matches this regexp, don't add semicolons.
41 | 
42 |     In JavaScript, this allows you to not add semicolons for `function(){...}`
43 |     or `class` `X` `{...}`.
44 | 
45 |   *b:closer_semi_ctx*
46 |     Only consider semicolons when the context line matches this regexp.
47 | 
48 |     The context is the previous line that is indented higher than the current
49 |     line. In JavaScript, this allows you to only add semicolons in the
50 |     function context.
51 | 
52 | ==============================================================================
53 | vim:tw=78:ts=8:ft=help:norl:
54 | 


--------------------------------------------------------------------------------
/plugin/closer.vim:
--------------------------------------------------------------------------------
 1 | augroup closer
 2 |   au!
 3 |   autocmd FileType *
 4 |     \ let b:closer = 0 |
 5 |     \ let b:closer_no_semi = 0 |
 6 |     \ let b:closer_semi_ctx = 0 |
 7 |     \ let b:closer_semi_check_top = 0
 8 | 
 9 |   au FileType javascript,javascript.jsx,javascriptreact,vue,typescript,typescriptreact
10 |     \ let b:closer = 1 |
11 |     \ let b:closer_flags = '([{;' |
12 |     \ let b:closer_no_semi = '^\s*\(function\|class\|if\|else\)' |
13 |     \ let b:closer_semi_ctx = ')\s*{$'
14 | 
15 |   au FileType c,cpp,css,elixir,go,java,javacc,json,less,lua,objc,puppet,python,ruby,rust,scss,sh,solidity,stylus,terraform,xdefaults,zsh
16 |     \ let b:closer = 1 |
17 |     \ let b:closer_flags = '([{'
18 | 
19 |   au FileType php
20 |     \ let b:closer = 1 |
21 |     \ let b:closer_flags = '([{;' |
22 |     \ let b:closer_no_semi = '\s*\(function\s\+.\+(\|class\|if\|else\|for\|try\)' |
23 |     \ let b:closer_semi_ctx = '\s*{$' |
24 |     \ let b:closer_semi_check_top = 1
25 | 
26 |   autocmd FileType * call closer#enable()
27 | augroup END
28 | 


--------------------------------------------------------------------------------
/test/closer_test.vader:
--------------------------------------------------------------------------------
 1 | Execute (set soft tabs to 2 spaces):
 2 |   set sts=2 sw=2 ex
 3 | 
 4 | Given css (css):
 5 |   .section {
 6 | Do:
 7 |   A\<Enter>|
 8 | Expect (closes curly braces):
 9 |   .section {
10 |     |
11 |   }
12 | 
13 | Given javascript (js):
14 |   hello();
15 |   describe(function() {
16 | Do (pressing enter):
17 |   GA\<Enter>|
18 | Expect (closes multiple braces):
19 |   hello();
20 |   describe(function() {
21 |     |
22 |   });
23 | 
24 | Given css (css with balanced braces):
25 |   .section {}
26 | Do (presing enter):
27 |   A\<Enter>|
28 | Expect (leaves braces alone):
29 |   .section {}
30 |   |
31 | 
32 | Given ruby (ruby):
33 |   a = %w[
34 | Do (presing enter):
35 |   A\<Enter>|
36 | Expect (closes brackets):
37 |   a = %w[
38 |     |
39 |   ]
40 | 
41 | Given ruby (ruby):
42 |   a = %w[
43 | Do (presing enter then esc):
44 |   A\<Enter>|\<Esc>dd
45 | Expect (escape works):
46 |   a = %w[
47 |   ]
48 | 
49 | Given css:
50 |   .section {}
51 | Do (presing enter in the middle of the line):
52 |   $i\<Enter>|
53 | Expect (doesnt terminate brackets):
54 |   .section {
55 |   |}
56 | 
57 | Given css:
58 |   .x ({
59 | Do (presing enter):
60 |   A\<Enter>|
61 | Expect (figures out 2 braces in the correct order):
62 |   .x ({
63 |     |
64 |   })
65 | 
66 | Given xdefaults:
67 |   x [{(
68 | Do (pressing enter):
69 |   A\<Enter>|
70 | Expect (figures out 3 braces in the correct order):
71 |   x [{(
72 |     |
73 |   )}]
74 | 
75 | Given xdefaults:
76 |   x [(){(
77 | Do (pressing enter):
78 |   A\<Enter>|
79 | Expect (Discards superfluous braces):
80 |   x [(){(
81 |     |
82 |   )}]
83 | 


--------------------------------------------------------------------------------
/test/endwise/endwise_test.vader:
--------------------------------------------------------------------------------
 1 | Execute:
 2 |   set sts=2 sw=2 ex
 3 | Given ruby:
 4 |   class Foo
 5 | Do:
 6 |   A\<Enter>|
 7 | Expect (endwise works):
 8 |   class Foo
 9 |     |
10 |   end
11 | 
12 | Given ruby:
13 |   a = %w[
14 | Do:
15 |   A\<Enter>|
16 | Expect (expansion works):
17 |   a = %w[
18 |     |
19 |   ]
20 | 


--------------------------------------------------------------------------------
/test/javascript_test.vader:
--------------------------------------------------------------------------------
 1 | Execute:
 2 |   set sts=2 sw=2 ex
 3 | 
 4 | Given javascript (js):
 5 |   hello();
 6 |   describe(function() {
 7 | Do (pressing enter):
 8 |   GA\<Enter>|
 9 | Expect (adds semicolon to describe):
10 |   hello();
11 |   describe(function() {
12 |     |
13 |   });
14 | 
15 | Given javascript (js):
16 |   hello();
17 |   a = {
18 |     b: {
19 | Do (pressing enter):
20 |   GA\<Enter>|
21 | Expect (adds no semicolon on object literal):
22 |   hello();
23 |   a = {
24 |     b: {
25 |       |
26 |     }
27 | 
28 | Given javascript (js):
29 |   hello();
30 |   class X {
31 |     fn() {
32 | Do (pressing enter):
33 |   GA\<Enter>|
34 | Expect (adds no semicolon on class methods):
35 |   hello();
36 |   class X {
37 |     fn() {
38 |       |
39 |     }
40 | 
41 | Given javascript (js):
42 |   hello();
43 |   a = {
44 | Do (pressing enter):
45 |   GA\<Enter>|
46 | Expect (adds semicolons to object literal):
47 |   hello();
48 |   a = {
49 |     |
50 |   };
51 | 


--------------------------------------------------------------------------------