vim/vim-signify
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
d9918a69bc
vim-signify/autoload/sy/sign.vim

267 lines
7.7 KiB
VimL
Raw Normal View History

Move modelines to the top
2013-09-30 04:19:31 -04:00
" vim: et sw=2 sts=2
Set encoding for plugin files Closes #54.
2013-08-19 11:36:16 -04:00
scriptencoding utf-8
Use two digit numbers for SignifyDelete signs Defining the SignifyDelete set of signs on the fly provides the ability to specify the exact line deletion count for up to 99 lines, rather than the current limit of 9 lines. This also has the benefit of reducing the number of signs defined when there aren't many hunks of deleted lines. On the flip side, if there are other sign-placing plugins in use, then it also increases the chance of nearing the ~120 sign definition limit if there are many hunks of varying line deletions.
2013-12-05 19:51:33 -05:00
" Init: values {{{1
New option: g:signify_sign_show_text This makes all Signify signs use a non-breaking space as text. This is convenient if only the background colors of the signs are important. References #188.
2016-09-28 11:05:40 -04:00
if get(g:, 'signify_sign_show_text', 1)
let s:sign_delete = get(g:, 'signify_sign_delete', '_')
let s:sign_show_count = get(g:, 'signify_sign_show_count', 1)
else
let s:sign_delete = ' '
let s:sign_show_count = 0
endif
Introduce g:signify_sign_show_count This option replaces g:signify_sign_delete_use_count and works for both, delete and change/delete. Referenes #125.
2014-10-07 06:49:41 -04:00
let s:delete_highlight = ['', 'SignifyLineDelete']
Use two digit numbers for SignifyDelete signs Defining the SignifyDelete set of signs on the fly provides the ability to specify the exact line deletion count for up to 99 lines, rather than the current limit of 9 lines. This also has the benefit of reducing the number of signs defined when there aren't many hunks of deleted lines. On the flip side, if there are other sign-placing plugins in use, then it also increases the chance of nearing the ~120 sign definition limit if there are many hunks of varying line deletions.
2013-12-05 19:51:33 -05:00
Simplify sign ID handling
2017-01-18 10:28:35 -05:00
" Function: #id_next {{{1
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
function! sy#sign#id_next(sy) abort
let id = a:sy.signid
let a:sy.signid += 1
Simplify sign ID handling
2017-01-18 10:28:35 -05:00
return id
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
endfunction
" Function: #get_current_signs {{{1
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
function! sy#sign#get_current_signs(sy) abort
let a:sy.internal = {}
let a:sy.external = {}
Relocate emptying of other signs dict References #64.
2013-09-06 10:22:09 -04:00
Populate autoload/
2013-07-17 06:30:58 -04:00
redir => signlist
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
silent! execute 'sign place buffer='. a:sy.buffer
Populate autoload/
2013-07-17 06:30:58 -04:00
redir END
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
for signline in split(signlist, '\n')[2:]
Don't rely on :language Fixes #187.
2016-12-15 08:13:53 -05:00
let tokens = matchlist(signline, '\v^\s+\S+\=(\d+)\s+\S+\=(\d+)\s+\S+\=(.*)$')
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
let line = str2nr(tokens[1])
let id = str2nr(tokens[2])
let type = tokens[3]
if type =~# '^Signify'
" Handle ambiguous signs. Assume you have signs on line 3 and 4.
" Removing line 3 would lead to the second sign to be shifted up
" to line 3. Now there are still 2 signs, both one line 3.
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
if has_key(a:sy.internal, line)
execute 'sign unplace' a:sy.internal[line].id 'buffer='.a:sy.buffer
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
endif
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
let a:sy.internal[line] = { 'type': type, 'id': id }
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
else
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
let a:sy.external[line] = id
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
endif
endfor
endfunction
Don't remember the dummy sign References #102.
2013-12-06 16:43:51 -05:00
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
" Function: #process_diff {{{1
Allow multiple active VCS When you have nested repos of different VCS and you edit a file from the inner repo, more than one VCS can return a valid diff. Only one VCS should return a non-empty diff, though. Once a non-empty diff is found, all other VCS get disabled to reduce overhead. References #235.
2017-04-18 10:59:48 -04:00
function! sy#sign#process_diff(sy, vcs, diff) abort
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
let a:sy.signtable = {}
let a:sy.hunks = []
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
let [added, modified, deleted] = [0, 0, 0]
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
call sy#sign#get_current_signs(a:sy)
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
" Determine where we have to put our signs.
Make Vim and job_start() work
2017-01-17 17:12:00 -05:00
for line in filter(a:diff, 'v:val =~ "^@@ "')
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
let a:sy.lines = []
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
let ids = []
let tokens = matchlist(line, '^@@ -\v(\d+),?(\d*) \+(\d+),?(\d*)')
let old_line = str2nr(tokens[1])
let new_line = str2nr(tokens[3])
let old_count = empty(tokens[2]) ? 1 : str2nr(tokens[2])
let new_count = empty(tokens[4]) ? 1 : str2nr(tokens[4])
" 2 lines added:
" @@ -5,0 +6,2 @@ this is line 5
" +this is line 5
" +this is line 5
if (old_count == 0) && (new_count >= 1)
let added += new_count
let offset = 0
while offset < new_count
let line = new_line + offset
let offset += 1
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
if s:external_sign_present(a:sy, line) | continue | endif
call add(ids, s:add_sign(a:sy, line, 'SignifyAdd'))
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
endwhile
" 2 lines removed:
" @@ -6,2 +5,0 @@ this is line 5
" -this is line 6
" -this is line 7
elseif (old_count >= 1) && (new_count == 0)
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
if s:external_sign_present(a:sy, new_line) | continue | endif
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
let deleted += old_count
if new_line == 0
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
call add(ids, s:add_sign(a:sy, 1, 'SignifyRemoveFirstLine'))
Introduce g:signify_sign_show_count This option replaces g:signify_sign_delete_use_count and works for both, delete and change/delete. Referenes #125.
2014-10-07 06:49:41 -04:00
elseif s:sign_show_count
Add finer grained control over signs and highlights I wanted to be able to customize signify in a way that wasn't possible with the current set of options. This commit adds 2 new options and 2 new highlight groups. Specifically, we can now 1. differentiate between changes, deletes AND signs that have both with the `signify_sign_changedelete` option. 2. disable showing the number of deleted lines in the sign column with the `signify_sign_delete_use_count` option. 3. highlight lines with changes and deletes specifically with the `SignifySignChangeDelete` highlight group. 4. highlight the first line differently with the `SignifySignDeleteFirstLine` highlight group. All of these default to existing settings/highlight groups, so everything should continue working the way it does now. -------------------------------------------------------------------------------- For those that are curious, I wanted to configure signify to show no symbols in the sign column, and to just use the highlight groups to give me all the information I needed. I am able to achieve that now with the following settings and the Solarized colorscheme: let g:signify_sign_add = "\<Char-0xa0>\<Char-0xa0>" let g:signify_sign_change = "\<Char-0xa0>\<Char-0xa0>" let g:signify_sign_changedelete = "__" let g:signify_sign_delete = "__" let g:signify_sign_delete_first_line = "‾‾" let g:signify_sign_delete_use_count = 0 hi SignifySignDelete term=bold,underline cterm=bold,underline ctermfg=1 ctermbg=12 hi SignifySignDeleteFirstLine ctermfg=1 ctermbg=12 hi SignifySignChangeDelete term=bold,underline cterm=bold,underline ctermfg=1 ctermbg=3 You can see it in action here: https://twitter.com/_bentomas/status/486266117204090880
2014-10-04 13:35:51 -04:00
if old_count <= 99
let text = substitute(s:sign_delete . old_count, '.*\ze..$', '', '')
else
let text = s:sign_delete .'>'
endif
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
call add(ids, s:add_sign(a:sy, new_line, 'SignifyDelete'. old_count, text))
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
else
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
call add(ids, s:add_sign(a:sy, new_line, 'SignifyDeleteMore', s:sign_delete))
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
endif
" 2 lines changed:
" @@ -5,2 +5,2 @@ this is line 4
" -this is line 5
" -this is line 6
" +this os line 5
" +this os line 6
elseif old_count == new_count
let modified += old_count
let offset = 0
while offset < new_count
let line = new_line + offset
let offset += 1
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
if s:external_sign_present(a:sy, line) | continue | endif
call add(ids, s:add_sign(a:sy, line, 'SignifyChange'))
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
endwhile
else
" 2 lines changed; 2 lines removed:
" @@ -5,4 +5,2 @@ this is line 4
" -this is line 5
" -this is line 6
" -this is line 7
" -this is line 8
" +this os line 5
" +this os line 6
if old_count > new_count
let modified += new_count
let removed = old_count - new_count
let deleted += removed
let offset = 0
while offset < new_count - 1
let line = new_line + offset
let offset += 1
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
if s:external_sign_present(a:sy, line) | continue | endif
call add(ids, s:add_sign(a:sy, line, 'SignifyChange'))
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
endwhile
let line = new_line + offset
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
if s:external_sign_present(a:sy, line) | continue | endif
call add(ids, s:add_sign(a:sy, line, (removed > 9)
\ ? 'SignifyChangeDeleteMore'
\ : 'SignifyChangeDelete'. removed))
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
" lines changed and added:
" @@ -5 +5,3 @@ this is line 4
" -this is line 5
" +this os line 5
" +this is line 42
" +this is line 666
else
let modified += old_count
let offset = 0
while offset < old_count
let line = new_line + offset
let offset += 1
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
if s:external_sign_present(a:sy, line) | continue | endif
call add(ids, s:add_sign(a:sy, line, 'SignifyChange'))
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
let added += 1
endwhile
while offset < new_count
let line = new_line + offset
let offset += 1
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
if s:external_sign_present(a:sy, line) | continue | endif
call add(ids, s:add_sign(a:sy, line, 'SignifyAdd'))
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
endwhile
endif
endif
if !empty(ids)
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
call add(a:sy.hunks, {
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
\ 'ids' : ids,
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
\ 'start': a:sy.lines[0],
\ 'end' : a:sy.lines[-1] })
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
endif
Populate autoload/
2013-07-17 06:30:58 -04:00
endfor
Fix sign_overwrite for non-EN locales
2013-11-18 17:02:21 -05:00
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
" Remove obsoleted signs.
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
for line in filter(keys(a:sy.internal), '!has_key(a:sy.signtable, v:val)')
execute 'sign unplace' a:sy.internal[line].id 'buffer='.a:sy.buffer
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
endfor
Populate autoload/
2013-07-17 06:30:58 -04:00
MacVim: don't use ^L in insert mode References #234.
2017-04-12 05:18:38 -04:00
if has('gui_macvim') && has('gui_running') && mode() == 'n'
Remove now useless workarounds
2017-02-24 11:41:32 -05:00
" MacVim needs an extra kick in the butt, when setting signs from the
" exit handler. :redraw would trigger a "hanging cursor" issue.
call feedkeys("\<c-l>")
GUIs: redraw screen after sign update Some GUIs (MacVim, gVim) wouldn't show placed signs after updating. Force a redraw. References #228.
2017-02-19 19:15:50 -05:00
endif
Improve debug output
2017-04-18 11:18:19 -04:00
call sy#verbose('Signs updated.', a:vcs)
Always set sy.updated_by References #235.
2017-04-21 07:34:00 -04:00
let a:sy.updated_by = a:vcs
Improve debug output
2017-04-18 11:18:19 -04:00
if len(a:sy.vcs) > 1
call sy#verbose('Disable all other VCS.', a:vcs)
let a:sy.vcs = [a:vcs]
endif
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
let a:sy.stats = [added, modified, deleted]
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
endfunction
Fix sign overwrite issue References #64.
2013-09-06 09:34:13 -04:00
Add finer grained control over signs and highlights I wanted to be able to customize signify in a way that wasn't possible with the current set of options. This commit adds 2 new options and 2 new highlight groups. Specifically, we can now 1. differentiate between changes, deletes AND signs that have both with the `signify_sign_changedelete` option. 2. disable showing the number of deleted lines in the sign column with the `signify_sign_delete_use_count` option. 3. highlight lines with changes and deletes specifically with the `SignifySignChangeDelete` highlight group. 4. highlight the first line differently with the `SignifySignDeleteFirstLine` highlight group. All of these default to existing settings/highlight groups, so everything should continue working the way it does now. -------------------------------------------------------------------------------- For those that are curious, I wanted to configure signify to show no symbols in the sign column, and to just use the highlight groups to give me all the information I needed. I am able to achieve that now with the following settings and the Solarized colorscheme: let g:signify_sign_add = "\<Char-0xa0>\<Char-0xa0>" let g:signify_sign_change = "\<Char-0xa0>\<Char-0xa0>" let g:signify_sign_changedelete = "__" let g:signify_sign_delete = "__" let g:signify_sign_delete_first_line = "‾‾" let g:signify_sign_delete_use_count = 0 hi SignifySignDelete term=bold,underline cterm=bold,underline ctermfg=1 ctermbg=12 hi SignifySignDeleteFirstLine ctermfg=1 ctermbg=12 hi SignifySignChangeDelete term=bold,underline cterm=bold,underline ctermfg=1 ctermbg=3 You can see it in action here: https://twitter.com/_bentomas/status/486266117204090880
2014-10-04 13:35:51 -04:00
" Function: #remove_all_signs {{{1
Add the buffer number as an argument to sy#stop() sy#stop() is called by the BufDelete autocmd so b: variables may not correspond to the buffer actually being deleted. Instead, we must use <abuf> to determine which buffer is being deleted and pass that into sy#stop(). There are some ripple effects, causing sy#sign#remove_all_signs to also gain a buffer number argument. Signed-off-by: James McCoy <vega.james@gmail.com>
2014-11-25 11:25:40 -05:00
function! sy#sign#remove_all_signs(bufnr) abort
let sy = getbufvar(a:bufnr, 'sy')
for hunk in sy.hunks
Add finer grained control over signs and highlights I wanted to be able to customize signify in a way that wasn't possible with the current set of options. This commit adds 2 new options and 2 new highlight groups. Specifically, we can now 1. differentiate between changes, deletes AND signs that have both with the `signify_sign_changedelete` option. 2. disable showing the number of deleted lines in the sign column with the `signify_sign_delete_use_count` option. 3. highlight lines with changes and deletes specifically with the `SignifySignChangeDelete` highlight group. 4. highlight the first line differently with the `SignifySignDeleteFirstLine` highlight group. All of these default to existing settings/highlight groups, so everything should continue working the way it does now. -------------------------------------------------------------------------------- For those that are curious, I wanted to configure signify to show no symbols in the sign column, and to just use the highlight groups to give me all the information I needed. I am able to achieve that now with the following settings and the Solarized colorscheme: let g:signify_sign_add = "\<Char-0xa0>\<Char-0xa0>" let g:signify_sign_change = "\<Char-0xa0>\<Char-0xa0>" let g:signify_sign_changedelete = "__" let g:signify_sign_delete = "__" let g:signify_sign_delete_first_line = "‾‾" let g:signify_sign_delete_use_count = 0 hi SignifySignDelete term=bold,underline cterm=bold,underline ctermfg=1 ctermbg=12 hi SignifySignDeleteFirstLine ctermfg=1 ctermbg=12 hi SignifySignChangeDelete term=bold,underline cterm=bold,underline ctermfg=1 ctermbg=3 You can see it in action here: https://twitter.com/_bentomas/status/486266117204090880
2014-10-04 13:35:51 -04:00
for id in hunk.ids
Simplify sign ID handling
2017-01-18 10:28:35 -05:00
execute 'sign unplace' id 'buffer='.a:bufnr
Add finer grained control over signs and highlights I wanted to be able to customize signify in a way that wasn't possible with the current set of options. This commit adds 2 new options and 2 new highlight groups. Specifically, we can now 1. differentiate between changes, deletes AND signs that have both with the `signify_sign_changedelete` option. 2. disable showing the number of deleted lines in the sign column with the `signify_sign_delete_use_count` option. 3. highlight lines with changes and deletes specifically with the `SignifySignChangeDelete` highlight group. 4. highlight the first line differently with the `SignifySignDeleteFirstLine` highlight group. All of these default to existing settings/highlight groups, so everything should continue working the way it does now. -------------------------------------------------------------------------------- For those that are curious, I wanted to configure signify to show no symbols in the sign column, and to just use the highlight groups to give me all the information I needed. I am able to achieve that now with the following settings and the Solarized colorscheme: let g:signify_sign_add = "\<Char-0xa0>\<Char-0xa0>" let g:signify_sign_change = "\<Char-0xa0>\<Char-0xa0>" let g:signify_sign_changedelete = "__" let g:signify_sign_delete = "__" let g:signify_sign_delete_first_line = "‾‾" let g:signify_sign_delete_use_count = 0 hi SignifySignDelete term=bold,underline cterm=bold,underline ctermfg=1 ctermbg=12 hi SignifySignDeleteFirstLine ctermfg=1 ctermbg=12 hi SignifySignChangeDelete term=bold,underline cterm=bold,underline ctermfg=1 ctermbg=3 You can see it in action here: https://twitter.com/_bentomas/status/486266117204090880
2014-10-04 13:35:51 -04:00
endfor
endfor
Add the buffer number as an argument to sy#stop() sy#stop() is called by the BufDelete autocmd so b: variables may not correspond to the buffer actually being deleted. Instead, we must use <abuf> to determine which buffer is being deleted and pass that into sy#stop(). There are some ripple effects, causing sy#sign#remove_all_signs to also gain a buffer number argument. Signed-off-by: James McCoy <vega.james@gmail.com>
2014-11-25 11:25:40 -05:00
let sy.hunks = []
Add finer grained control over signs and highlights I wanted to be able to customize signify in a way that wasn't possible with the current set of options. This commit adds 2 new options and 2 new highlight groups. Specifically, we can now 1. differentiate between changes, deletes AND signs that have both with the `signify_sign_changedelete` option. 2. disable showing the number of deleted lines in the sign column with the `signify_sign_delete_use_count` option. 3. highlight lines with changes and deletes specifically with the `SignifySignChangeDelete` highlight group. 4. highlight the first line differently with the `SignifySignDeleteFirstLine` highlight group. All of these default to existing settings/highlight groups, so everything should continue working the way it does now. -------------------------------------------------------------------------------- For those that are curious, I wanted to configure signify to show no symbols in the sign column, and to just use the highlight groups to give me all the information I needed. I am able to achieve that now with the following settings and the Solarized colorscheme: let g:signify_sign_add = "\<Char-0xa0>\<Char-0xa0>" let g:signify_sign_change = "\<Char-0xa0>\<Char-0xa0>" let g:signify_sign_changedelete = "__" let g:signify_sign_delete = "__" let g:signify_sign_delete_first_line = "‾‾" let g:signify_sign_delete_use_count = 0 hi SignifySignDelete term=bold,underline cterm=bold,underline ctermfg=1 ctermbg=12 hi SignifySignDeleteFirstLine ctermfg=1 ctermbg=12 hi SignifySignChangeDelete term=bold,underline cterm=bold,underline ctermfg=1 ctermbg=3 You can see it in action here: https://twitter.com/_bentomas/status/486266117204090880
2014-10-04 13:35:51 -04:00
endfunction
" Function: s:add_sign {{{1
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
function! s:add_sign(sy, line, type, ...) abort
call add(a:sy.lines, a:line)
let a:sy.signtable[a:line] = 1
Populate autoload/
2013-07-17 06:30:58 -04:00
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
if has_key(a:sy.internal, a:line)
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
" There is a sign on this line already.
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
if a:type == a:sy.internal[a:line].type
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
" Keep current sign since the new one is of the same type.
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
return a:sy.internal[a:line].id
Use two digit numbers for SignifyDelete signs Defining the SignifyDelete set of signs on the fly provides the ability to specify the exact line deletion count for up to 99 lines, rather than the current limit of 9 lines. This also has the benefit of reducing the number of signs defined when there aren't many hunks of deleted lines. On the flip side, if there are other sign-placing plugins in use, then it also increases the chance of nearing the ~120 sign definition limit if there are many hunks of varying line deletions.
2013-12-05 19:51:33 -05:00
else
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
" Update sign by overwriting the ID of the current sign.
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
let id = a:sy.internal[a:line].id
Use two digit numbers for SignifyDelete signs Defining the SignifyDelete set of signs on the fly provides the ability to specify the exact line deletion count for up to 99 lines, rather than the current limit of 9 lines. This also has the benefit of reducing the number of signs defined when there aren't many hunks of deleted lines. On the flip side, if there are other sign-placing plugins in use, then it also increases the chance of nearing the ~120 sign definition limit if there are many hunks of varying line deletions.
2013-12-05 19:51:33 -05:00
endif
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
endif
Populate autoload/
2013-07-17 06:30:58 -04:00
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
if !exists('id')
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
let id = sy#sign#id_next(a:sy)
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
endif
Fix sign overwrite issue References #64.
2013-09-06 09:34:13 -04:00
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
if a:type =~# 'SignifyDelete'
execute printf('sign define %s text=%s texthl=SignifySignDelete linehl=%s',
\ a:type,
\ a:1,
\ s:delete_highlight[g:signify_line_highlight])
endif
execute printf('sign place %d line=%d name=%s buffer=%s',
\ id,
\ a:line,
\ a:type,
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
\ a:sy.buffer)
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
return id
Populate autoload/
2013-07-17 06:30:58 -04:00
endfunction
Add finer grained control over signs and highlights I wanted to be able to customize signify in a way that wasn't possible with the current set of options. This commit adds 2 new options and 2 new highlight groups. Specifically, we can now 1. differentiate between changes, deletes AND signs that have both with the `signify_sign_changedelete` option. 2. disable showing the number of deleted lines in the sign column with the `signify_sign_delete_use_count` option. 3. highlight lines with changes and deletes specifically with the `SignifySignChangeDelete` highlight group. 4. highlight the first line differently with the `SignifySignDeleteFirstLine` highlight group. All of these default to existing settings/highlight groups, so everything should continue working the way it does now. -------------------------------------------------------------------------------- For those that are curious, I wanted to configure signify to show no symbols in the sign column, and to just use the highlight groups to give me all the information I needed. I am able to achieve that now with the following settings and the Solarized colorscheme: let g:signify_sign_add = "\<Char-0xa0>\<Char-0xa0>" let g:signify_sign_change = "\<Char-0xa0>\<Char-0xa0>" let g:signify_sign_changedelete = "__" let g:signify_sign_delete = "__" let g:signify_sign_delete_first_line = "‾‾" let g:signify_sign_delete_use_count = 0 hi SignifySignDelete term=bold,underline cterm=bold,underline ctermfg=1 ctermbg=12 hi SignifySignDeleteFirstLine ctermfg=1 ctermbg=12 hi SignifySignChangeDelete term=bold,underline cterm=bold,underline ctermfg=1 ctermbg=3 You can see it in action here: https://twitter.com/_bentomas/status/486266117204090880
2014-10-04 13:35:51 -04:00
" Function: s:external_sign_present {{{1
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
function! s:external_sign_present(sy, line) abort
if has_key(a:sy.external, a:line)
if has_key(a:sy.internal, a:line)
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
" Remove Sy signs from lines with other signs.
Don't switch window in exit handler Since we don't switch the window anymore, we can't simply refer to b:sy as we used to do while Sy worked only synchronously. Now we provide the buffer number to each job and the exit handler gets a pointer to the b:sy of that buffer and passes it to all the subsequent functions. References #209, #210.
2017-01-30 08:50:32 -05:00
execute 'sign unplace' a:sy.internal[a:line].id 'buffer='.a:sy.buffer
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
endif
return 1
Fix sign overwrite issue References #64.
2013-09-06 09:34:13 -04:00
endif
Introduce smarter sign management
2014-10-04 09:55:49 -04:00
endfunction
Reference in New Issue Copy Permalink