coverage: improvements and integration into vim-go

Author: fatih

README.md

@@ -57,8 +57,6 @@ People have asked for this for a long time, now you can be a fully supporter by
 
 [https://www.patreon.com/fatih](https://www.patreon.com/fatih)
 
-![ss-vim-go-coverlay](https://cloud.githubusercontent.com/assets/3804806/5319001/81a3b89a-7ce8-11e4-9fbd-2f0fd00ce1c7.gif)
-
 ## Install
 
 Vim-go follows the standard runtime path structure, so I highly recommend to
@@ -219,15 +217,8 @@ By default when `:GoInstallBinaries` is called, the binaries are installed to
 `$GOBIN` or `$GOPATH/bin`. To change it:
 
 ```vim
-<<<<<<< HEAD
 let g:go_bin_path = expand("~/.gotools")
 let g:go_bin_path = "/home/fatih/.mypath"      "or give absolute path
-=======
-au FileType go nmap <leader>c <Plug>(go-coverlay) "test coverage then overlay covered lines
-au FileType go nmap <leader>C <Plug>(go-clearlay) "clear overlay
-
-au BufWritePost *.go call go#coverlay#Coverlay() "run test and cover on file save
->>>>>>> 70c8cf8... code cleanup
 ```
 
 ### Using with Neovim (beta)

autoload/go/coverlay.vim

@@ -1,18 +1,8 @@
-if !exists("g:go_gopath")
-    let g:go_gopath = $GOPATH
-endif
-
-augroup plugin-go-coverlay
-    autocmd!
-    autocmd BufEnter,BufWinEnter,BufFilePost * call go#coverlay#draw()
-    autocmd BufWinLeave * call go#coverlay#clear()
-augroup END
-
 function! go#coverlay#draw()
     call go#coverlay#hook()
     call go#coverlay#clear()
     for m in b:go_coverlay_matches
-        let id = matchadd(m.group, m.pattern, m.priority)
+        let id = matchaddpos(m.group, m.pos)
         call add(b:go_coverlay_match_ids, id)
     endfor
 endfunction
@@ -22,19 +12,20 @@ function! go#coverlay#hook()
     if !exists("b:go_coverlay_matches")
         let b:go_coverlay_matches = []
     endif
+
     if !exists("b:go_coverlay_match_ids")
         let b:go_coverlay_match_ids = []
     endif
 endfunction
 
-"findbufnr look for the number of buffer that opens `file`,
+" findbufnr look for the number of buffer that opens `file`,
 " as it is displayed by the ":ls" command.
-"If the buffer doesn't exist, -1 is returned.
+" If the buffer doesn't exist, -1 is returned.
 function! go#coverlay#findbufnr(file)
     if a:file[0] == "_"
         return bufnr(a:file[1:])
     endif
-    for path in split(g:go_gopath, ':')
+    for path in split(go#path#Default(), ':')
         let nr = bufnr(path . '/src/' . a:file)
         if nr != -1
             return nr
@@ -61,37 +52,51 @@ endfunction
 function! go#coverlay#parsegocoverline(line)
     " file:startline.col,endline.col numstmt count
     let mx = '\([^:]\+\):\(\d\+\)\.\(\d\+\),\(\d\+\)\.\(\d\+\)\s\(\d\+\)\s\(\d\+\)'
-    let l = matchstr(a:line, mx)
+    let tokens = matchlist(a:line, mx)
     let ret = {}
-    let ret.file = substitute(l, mx, '\1', '')
-    let ret.startline  = substitute(l, mx, '\2', '')
-    let ret.startcol = substitute(l, mx, '\3', '')
-    let ret.endline = substitute(l, mx, '\4', '')
-    let ret.endcol = substitute(l, mx, '\5', '')
-    let ret.numstmt = substitute(l, mx, '\6', '')
-    let ret.cnt = substitute(l, mx, '\7', '')
+    let ret.file = tokens[1]
+    let ret.startline  = str2nr(tokens[2])
+    let ret.startcol = str2nr(tokens[3])
+    let ret.endline = str2nr(tokens[4])
+    let ret.endcol = str2nr(tokens[5])
+    let ret.numstmt = tokens[6]
+    let ret.cnt = tokens[7]
     return ret
 endfunction
 
 function! go#coverlay#genmatch(cov)
-    let pat1 = '\%>' . a:cov.startline . 'l'
-    let pat2 = '\%<' . a:cov.endline . 'l'
-    let pat3 = '\|\%' . a:cov.startline . 'l\_^\s\+\|\%' . a:cov.endline . 'l\_^\s\+\(\}$\)\@!'
     let color = 'covered'
-    let prio = 6
     if a:cov.cnt == 0
         let color = 'uncover'
-        let prio = 5
     endif
-    return {'group': color, 'pattern': pat1 . '\_^\s\+' . pat2 . pat3, 'priority': prio}
+
+    let matches = []
+
+    " if start and end are the same, also specify the byte length
+    " example: foo.go:92.2,92.65 1 0
+    if a:cov.startline == a:cov.endline
+        call add(matches, {'group': color, 'pos': [[a:cov.startline, a:cov.startcol, a:cov.endcol - a:cov.startcol]] })
+        return matches
+    endif
+
+    " add start and end columns
+    call add(matches, {'group': color, 'pos': [[a:cov.startline, a:cov.startcol]] })
+
+    " and then the remaining lines
+    let start_line = a:cov.startline
+    while start_line < a:cov.endline
+        let start_line += 1
+        call add(matches, {'group': color, 'pos': [[start_line]] })
+    endwhile
+
+    call add(matches, {'group': color, 'pos': [[a:cov.endline, a:cov.endcol-1]] })
+
+    return matches
 endfunction
 
 function! go#coverlay#overlay(file)
     call go#coverlay#hook()
 
-    highlight covered term=bold ctermbg=green guibg=green
-    highlight uncover term=bold ctermbg=red guibg=red
-
     if !filereadable(a:file)
         return
     endif
@@ -105,11 +110,16 @@ function! go#coverlay#overlay(file)
             " even if it is not opened currently?
             continue
         endif
-        let m = go#coverlay#genmatch(c)
+        let gen_matches = go#coverlay#genmatch(c)
         let matches = get(getbufvar(nr, ""), "go_coverlay_matches", [])
-        call add(matches, m)
+        call extend(matches, gen_matches)
         call setbufvar(nr, "go_coverlay_matches", matches)
     endfor
+
+    syntax clear
+    highlight covered term=bold ctermfg=118 guifg=#A6E22E
+    highlight uncover term=bold ctermfg=197 guifg=#F92672
+    
     "TODO: can we draw other window for split windows mode?
     call go#coverlay#draw()
 endfunction
@@ -154,6 +164,8 @@ function! go#coverlay#Coverlay(bang, ...)
 endfunction
 
 function! go#coverlay#Clearlay()
+    syntax reset
+    syntax on
     call go#coverlay#hook()
     call go#coverlay#clear()
     let b:go_coverlay_matches = []

doc/vim-go.txt

@@ -323,13 +323,27 @@ COMMANDS                                                          *go-commands*
 
     If [!] is not given the first error is jumped to.
 
-    If using neovim `:GoTestCompile` will run in a new terminal or run asynchronously
-    in the background according to |g:go_term_enabled|. You can set the mode of
-    the new terminal with |g:go_term_mode|.
+    If using neovim `:GoTestCompile` will run in a new terminal or run
+    asynchronously in the background according to |g:go_term_enabled|. You can
+    set the mode of the new terminal with |g:go_term_mode|.
 
                                                                 *:GoCoverage*
 :GoCoverage[!] [options]
 
+    Create a coverage profile and annotates the current file's source code.
+    To clear the annotation use |:GoCoverageClear|.
+
+    If [!] is not given the first error is jumped to.
+
+                                                          *:GoCoverageClear*
+:GoCoverageClear[!] [options]
+
+    Clears the go cover annotation of the current file.
+
+
+                                                          *:GoCoverageBrowser*
+:GoCoverageBrowser[!] [options]
+
     Create a coverage profile and open a browser to display the annotated
     source code of the current package.
 

ftplugin/go/commands.vim

@@ -26,7 +26,11 @@ command! -nargs=* -bang GoInstall call go#cmd#Install(<bang>0, <f-args>)
 command! -nargs=* -bang GoTest call go#cmd#Test(<bang>0, 0, <f-args>)
 command! -nargs=* -bang GoTestFunc call go#cmd#TestFunc(<bang>0, <f-args>)
 command! -nargs=* -bang GoTestCompile call go#cmd#Test(<bang>0, 1, <f-args>)
-command! -nargs=* -bang GoCoverage call go#cmd#Coverage(<bang>0, <f-args>)
+
+" -- cover
+command! -nargs=* -bang GoCoverage call go#coverlay#Coverlay(<bang>0, <f-args>)
+command! -nargs=* GoCoverageClear call go#coverlay#Clearlay(<f-args>)
+command! -nargs=* -bang GoCoverageBrowser call go#cmd#Coverage(<bang>0, <f-args>)
 
 " -- play
 command! -nargs=0 -range=% GoPlay call go#play#Share(<count>, <line1>, <line2>)

ftplugin/go/coverlay.vim

@@ -23,7 +23,10 @@ nnoremap <silent> <Plug>(go-install) :<C-u>call go#cmd#Install(!g:go_jump_to_err
 nnoremap <silent> <Plug>(go-test) :<C-u>call go#cmd#Test(!g:go_jump_to_error, 0)<CR>
 nnoremap <silent> <Plug>(go-test-func) :<C-u>call go#cmd#TestFunc(!g:go_jump_to_error)<CR>
 nnoremap <silent> <Plug>(go-test-compile) :<C-u>call go#cmd#Test(!g:go_jump_to_error, 1)<CR>
-nnoremap <silent> <Plug>(go-coverage) :<C-u>call go#cmd#Coverage(!g:go_jump_to_error)<CR>
+
+nnoremap <silent> <Plug>(go-coverage) :<C-u>call go#coverlay#Coverlay(!g:go_jump_to_error)<CR>
+nnoremap <silent> <Plug>(go-coverage-clear) :<C-u>call go#coverlay#Clearlay()<CR>
+nnoremap <silent> <Plug>(go-coverage-browser) :<C-u>call go#cmd#Coverage(!g:go_jump_to_error)<CR>
 
 nnoremap <silent> <Plug>(go-files) :<C-u>call go#tool#Files()<CR>
 nnoremap <silent> <Plug>(go-deps) :<C-u>call go#tool#Deps()<CR>

ftplugin/go/mappings.vim

@@ -167,6 +167,12 @@ augroup vim-go
     if get(g:, "go_metalinter_autosave", 0)
         autocmd BufWritePost *.go call go#lint#Gometa(1)
     endif
+
+    " redraw coverage for all window, experimental
+    if get(g:, "go_coverage_draw", 0)
+        autocmd BufEnter,BufWinEnter,BufFilePost * call go#coverlay#draw()
+        autocmd BufWinLeave * call go#coverlay#clear()
+    endif
 augroup END