vim

Fork of vim, an acceptable text editor
git clone git://git.laack.co/vim.git
Log | Files | Refs | README | LICENSE

cucumber.vim (5309B)


      1 " Vim filetype plugin
      2 " Language:	Cucumber
      3 " Maintainer:	Tim Pope <vimNOSPAM@tpope.org>
      4 " Last Change:	2016 Aug 29
      5 " 2026 May 26 by Vim Project: prevent Code Injection
      6 " https://github.com/vim/vim/security/advisories/GHSA-4473-94jm-w5x9
      7 
      8 " Only do this when not done yet for this buffer
      9 if (exists("b:did_ftplugin"))
     10   finish
     11 endif
     12 let b:did_ftplugin = 1
     13 
     14 let s:keepcpo= &cpo
     15 set cpo&vim
     16 
     17 setlocal formatoptions-=t formatoptions+=croql
     18 setlocal comments=:# commentstring=#\ %s
     19 setlocal omnifunc=CucumberComplete
     20 
     21 let b:undo_ftplugin = "setl fo< com< cms< ofu<"
     22 
     23 let b:cucumber_root = expand('%:p:h:s?.*[\/]\%(features\|stories\)\zs[\/].*??')
     24 if !exists("b:cucumber_steps_glob")
     25   let b:cucumber_steps_glob = b:cucumber_root.'/**/*.rb'
     26 endif
     27 
     28 if !exists("g:no_plugin_maps") && !exists("g:no_cucumber_maps")
     29   cnoremap <SID>foldopen <Bar>if &foldopen =~# 'tag'<Bar>exe 'norm! zv'<Bar>endif
     30   nnoremap <silent> <script> <buffer> [<C-D>      :<C-U>exe <SID>jump('edit',v:count)<SID>foldopen<CR>
     31   nnoremap <silent> <script> <buffer> ]<C-D>      :<C-U>exe <SID>jump('edit',v:count)<SID>foldopen<CR>
     32   nnoremap <silent> <script> <buffer> <C-W>d      :<C-U>exe <SID>jump('split',v:count)<SID>foldopen<CR>
     33   nnoremap <silent> <script> <buffer> <C-W><C-D>  :<C-U>exe <SID>jump('split',v:count)<SID>foldopen<CR>
     34   nnoremap <silent> <script> <buffer> [d          :<C-U>exe <SID>jump('pedit',v:count)<CR>
     35   nnoremap <silent> <script> <buffer> ]d          :<C-U>exe <SID>jump('pedit',v:count)<CR>
     36   let b:undo_ftplugin .=
     37         \ "|sil! nunmap <buffer> [<C-D>" .
     38         \ "|sil! nunmap <buffer> ]<C-D>" .
     39         \ "|sil! nunmap <buffer> <C-W>d" .
     40         \ "|sil! nunmap <buffer> <C-W><C-D>" .
     41         \ "|sil! nunmap <buffer> [d" .
     42         \ "|sil! nunmap <buffer> ]d"
     43 endif
     44 
     45 function! s:jump(command,count)
     46   let steps = s:steps('.')
     47   if len(steps) == 0 || len(steps) < a:count
     48     return 'echoerr "No matching step found"'
     49   elseif len(steps) > 1 && !a:count
     50     return 'echoerr "Multiple matching steps found"'
     51   else
     52     let c = a:count ? a:count-1 : 0
     53     return a:command.' +'.steps[c][1].' '.escape(steps[c][0],' %#')
     54   endif
     55 endfunction
     56 
     57 function! s:allsteps()
     58   let step_pattern = '\C^\s*\K\k*\>\s*(\=\s*\zs\S.\{-\}\ze\s*)\=\s*\%(do\|{\)\s*\%(|[^|]*|\s*\)\=\%($\|#\)'
     59   let steps = []
     60   for file in split(glob(b:cucumber_steps_glob),"\n")
     61     let lines = readfile(file)
     62     let num = 0
     63     for line in lines
     64       let num += 1
     65       if line =~ step_pattern
     66         let type = matchstr(line,'\w\+')
     67         let steps += [[file,num,type,matchstr(line,step_pattern)]]
     68       endif
     69     endfor
     70   endfor
     71   return steps
     72 endfunction
     73 
     74 function! s:steps(lnum)
     75   let c = match(getline(a:lnum), '\S') + 1
     76   while synIDattr(synID(a:lnum,c,1),'name') !~# '^$\|Region$'
     77     let c = c + 1
     78   endwhile
     79   let step = matchstr(getline(a:lnum)[c-1 : -1],'^\s*\zs.\{-\}\ze\s*$')
     80   return filter(s:allsteps(),'s:stepmatch(v:val[3],step)')
     81 endfunction
     82 
     83 function! s:stepmatch(receiver,target)
     84   if a:receiver =~ '^[''"].*[''"]$'
     85     let pattern = '^'.escape(substitute(a:receiver[1:-2],'$\w\+','(.*)','g'),'/').'$'
     86   elseif a:receiver =~ '^/.*/$'
     87     let pattern = a:receiver[1:-2]
     88   elseif a:receiver =~ '^%r..*.$'
     89     let pattern = escape(a:receiver[3:-2],'/')
     90   else
     91     return 0
     92   endif
     93   try
     94     let vimpattern = substitute(substitute(pattern,'\\\@<!(?:','%(','g'),'\\\@<!\*?','{-}','g')
     95     if a:target =~# '\v'.vimpattern
     96       return 1
     97     endif
     98   catch
     99   endtry
    100   if has("ruby") && pattern !~ '\\\@<!#{'
    101     " Use Regexp.new, so the pattern stays untrusted data and cannot inject Ruby
    102     ruby VIM.command("return #{if (begin; Regexp.new(VIM.evaluate('pattern')); rescue RegexpError; end) === VIM.evaluate('a:target') then 1 else 0 end}")
    103   else
    104     return 0
    105   endif
    106 endfunction
    107 
    108 function! s:bsub(target,pattern,replacement)
    109   return  substitute(a:target,'\C\\\@<!'.a:pattern,a:replacement,'g')
    110 endfunction
    111 
    112 function! CucumberComplete(findstart,base) abort
    113   let indent = indent('.')
    114   let group = synIDattr(synID(line('.'),indent+1,1),'name')
    115   let type = matchstr(group,'\Ccucumber\zs\%(Given\|When\|Then\)')
    116   let e = matchend(getline('.'),'^\s*\S\+\s')
    117   if type == '' || col('.') < col('$') || e < 0
    118     return -1
    119   endif
    120   if a:findstart
    121     return e
    122   endif
    123   let steps = []
    124   for step in s:allsteps()
    125     if step[2] ==# type
    126       if step[3] =~ '^[''"]'
    127         let steps += [step[3][1:-2]]
    128       elseif step[3] =~ '^/\^.*\$/$'
    129         let pattern = step[3][2:-3]
    130         let pattern = substitute(pattern,'\C^(?:|I )','I ','')
    131         let pattern = s:bsub(pattern,'\\[Sw]','w')
    132         let pattern = s:bsub(pattern,'\\d','1')
    133         let pattern = s:bsub(pattern,'\\[sWD]',' ')
    134         let pattern = s:bsub(pattern,'\[\^\\\="\]','_')
    135         let pattern = s:bsub(pattern,'[[:alnum:]. _-][?*]?\=','')
    136         let pattern = s:bsub(pattern,'\[\([^^]\).\{-\}\]','\1')
    137         let pattern = s:bsub(pattern,'+?\=','')
    138         let pattern = s:bsub(pattern,'(\([[:alnum:]. -]\{-\}\))','\1')
    139         let pattern = s:bsub(pattern,'\\\([[:punct:]]\)','\1')
    140         if pattern !~ '[\\()*?]'
    141           let steps += [pattern]
    142         endif
    143       endif
    144     endif
    145   endfor
    146   call filter(steps,'strpart(v:val,0,strlen(a:base)) ==# a:base')
    147   return sort(steps)
    148 endfunction
    149 
    150 let &cpo = s:keepcpo
    151 unlet s:keepcpo
    152 
    153 " vim:set sts=2 sw=2: