├── .gitignore
├── README.mdown
├── doc
    └── turbux.txt
└── plugin
    └── turbux.vim


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


--------------------------------------------------------------------------------
/README.mdown:
--------------------------------------------------------------------------------
 1 | Turbux is designed to speed up your TDD cycle by using a single key
 2 | mapping to run the most relevant test based on the current file in vim.
 3 | It uses tmux's scriptability to send commands to a chosen pane in your
 4 | tmux session.
 5 | 
 6 | For more information, see the documentation.
 7 | 
 8 | 
 9 | Dependencies
10 | ------------
11 | 
12 | This plugin depends on [vim-dispatch][7], [tslime.vim][1], [vim-tmux-runner][8], or [vimux][2],
13 | whichever is available, and becomes really awesome when used with
14 | [rails.vim][3]. It also makes the assumption that you're using tmux.
15 | 
16 | **Note:** Due to a bug in the original tslime.vim plugin, please use 
17 | [my fork][4].
18 | 
19 | 
20 | Installation
21 | ------------
22 | 
23 | Use [pathogen][5] or [vundle][6].
24 | 
25 | [1]: https://github.com/jgdavey/tslime.vim
26 | [2]: https://github.com/benmills/vimux
27 | [3]: https://github.com/tpope/vim-rails
28 | [4]: https://github.com/jgdavey/tslime.vim
29 | [5]: https://github.com/tpope/vim-pathogen
30 | [6]: https://github.com/gmarik/vundle
31 | [7]: https://github.com/tpope/vim-dispatch
32 | [8]: https://github.com/christoomey/vim-tmux-runner
33 | 


--------------------------------------------------------------------------------
/doc/turbux.txt:
--------------------------------------------------------------------------------
  1 | *turbux.txt*  Turbo Ruby tests with tmux
  2 | 
  3 | Author:  Joshua Davey <http://joshuadavey.com/>
  4 | License: Same terms as Vim itself (see |license|)
  5 | 
  6 | This plugin is only available if 'compatible' is not set.
  7 | 
  8 | This plugin can optionally be used with tslime.vim or vimux, whichever
  9 | is available, from within a tmux session.
 10 | 
 11 | It also depends optionally on rails.vim.
 12 | 
 13 | INTRODUCTION                                    *turbux*
 14 | 
 15 | Turbux is designed to speed up your TDD cycle by using a single key
 16 | mapping to run the most relevant test based on the current file in vim.
 17 | With either tslime or vimux, it uses tmux's scriptability to send
 18 | commands to a chosen pane in your tmux session.
 19 | 
 20 | The default mapping for invoking the plugin is <leader>t. In a spec
 21 | file, this will run "rspec <filename>". In a test-unit file, this will
 22 | run "ruby -Itest <filename>". In a cucumber feature file, this will run
 23 | "cucumber <filename>".
 24 | 
 25 | If rails.vim is present, some additional niceties are provided. When
 26 | rails.vim can find an alternate file for the current one, and that file
 27 | is a spec or test, it will run the alternate file rather than the one
 28 | you are in. For example, given the following two files:
 29 | >
 30 |         app/models/foo.rb
 31 |         spec/models/foo_bar.rb
 32 | <
 33 | When the current file and is "foo.rb" and you invoke the plugin, the
 34 | following command will be sent the configured tmux pane:
 35 | >
 36 |         rspec spec/models/foo_bar.rb
 37 | <
 38 | Note: this plugin does not work well with |autochdir|. The working
 39 | directories for the target pane and vim should match.
 40 | 
 41 | 
 42 | REPEATING                                        *turbux-repeating*
 43 | 
 44 | If you invoke the plugin (by default, with <leader>t), and neither the
 45 | current file nor the alternate is a test, spec or feature, turbux will
 46 | simply send the most recent command instead. This can be quite helpful
 47 | in situations where you are editing a related file, or in the case of
 48 | cucumber, step definitions or a view.
 49 | 
 50 | The |turbux| and |turbux-focused| invocations each store their own
 51 | command, so you can use the focused one elsewhere in a test suite while
 52 | still setting the normal one, or vice-versa.
 53 | 
 54 | 
 55 | FOCUSED                                          *turbux-focused*
 56 | 
 57 | Turbux also comes with bindings to run focused tests. This is
 58 | accomplished by appending the current line number to the test command.
 59 | In cucumber, this runs the scenario under the cursor. In rspec, this
 60 | runs only the example or group under the cursor.
 61 | 
 62 | The default mapping for focused test output is <leader>T.
 63 | 
 64 | 
 65 | CONFIGURATION                                    *turbux-config*
 66 | 
 67 | Turbux attempts to intelligently determine the most appropriate test
 68 | runner based on loaded plugins. You can manually set the test runner
 69 | with the following setting:
 70 | >
 71 |           let g:turbux_runner  = 'vim'      " default: vimux OR tslime OR vim
 72 | >
 73 | Use the following in your vimrc to set a common command prefix for prepending
 74 | all commands:
 75 | >
 76 |           let g:turbux_command_prefix = 'bundle exec' " default: (empty)
 77 | <
 78 | You can also choose your own commands for each test framework. A command use
 79 | case is to use 'spec' instead of 'rspec' for older versions of RSpec.
 80 | >
 81 |           let g:turbux_command_rspec  = 'spec'        " default: rspec
 82 |           let g:turbux_command_test_unit = 'ruby'     " default: ruby -Itest
 83 |           let g:turbux_command_cucumber = 'cucumber'  " default: cucumber -rfeatures
 84 |           let g:turbux_command_turnip = 'rspec'       " default: rspec -rturnip
 85 |           let g:turbux_command_teaspoon = 'teaspoon'  " default: teaspoon
 86 | <
 87 | You can implement a custom test runner. The following is one such example:
 88 | >
 89 |           let g:turbux_custom_runner = 'TurbuxCustomRunner' " default: (unset)
 90 |           function! TurbuxCustomRunner(command)
 91 |             call VimuxRunCommand("shrink")
 92 |             call VimuxClearRunnerHistory()
 93 |             return VimuxRunCommand(a:command)
 94 |           endfunction
 95 | <
 96 | MAPPING                                         *turbux-mappings*
 97 | 
 98 | <Plug>SendTestToTmux              Normal invocation
 99 | <Plug>SendFocusedTestToTmux       Focused test (appends line number or named
100 | test)
101 | 
102 | And the following are available unless "g:no_turbux_mappings" is set:
103 | 
104 | <leader>t                         Normal invocation
105 | <leader>T                         Focused test
106 | 
107 | To use custom mappings, you can put something like the following in your
108 | vimrc:
109 | >
110 |           let g:no_turbux_mappings = 1
111 |           map <leader>rt <Plug>SendTestToTmux
112 |           map <leader>rT <Plug>SendFocusedTestToTmux
113 | <
114 | 
115 |  vim:tw=78:et:ft=help:norl:
116 | 


--------------------------------------------------------------------------------
/plugin/turbux.vim:
--------------------------------------------------------------------------------
  1 | " turbux.vim - Turbo Ruby tests with tmux
  2 | " Author:      Joshua Davey <http://joshuadavey.com/>
  3 | " Version:     1.0
  4 | 
  5 | " Install this file to plugin/turbux.vim.
  6 | " Relies on the following plugins:
  7 | " - tslime.vim or vimux
  8 | " - rails.vim
  9 | 
 10 | if exists('g:loaded_turbux') || &cp || v:version < 700
 11 |   finish
 12 | endif
 13 | let g:loaded_turbux = 1
 14 | 
 15 | " Default Settings {{{1
 16 | function! s:turbux_command_setting(name, default_value)
 17 |   let name = 'g:turbux_command_'.a:name
 18 |   if !exists(name)
 19 |     exec ':let '.name.'= "'.a:default_value.'"'
 20 |   endif
 21 | endfunction
 22 | 
 23 | call s:turbux_command_setting("teaspoon", "teaspoon")
 24 | call s:turbux_command_setting("rspec", "rspec")
 25 | call s:turbux_command_setting("test_unit", "ruby -Itest")
 26 | call s:turbux_command_setting("turnip", "rspec -rturnip")
 27 | call s:turbux_command_setting("cucumber", "cucumber")
 28 | call s:turbux_command_setting("prefix", "")
 29 | call s:turbux_command_setting("elixir_test", "mix test")
 30 | call s:turbux_command_setting("elixir_spec", "mix espec")
 31 | " }}}1
 32 | 
 33 | " Utility {{{1
 34 | "
 35 | function! s:has_rails_vim()
 36 |   return exists('g:autoloaded_rails') && !empty(rails#buffer()) && !empty(rails#app())
 37 | endfunction
 38 | 
 39 | function! s:filereadable(filename)
 40 |   let f = a:filename
 41 |   if s:has_rails_vim()
 42 |     let f = rails#app().path(f)
 43 |   endif
 44 |   return filereadable(f)
 45 | endfunction
 46 | 
 47 | function! s:first_readable_file(files) abort
 48 |   let files = type(a:files) == type([]) ? copy(a:files) : split(a:files,"\n")
 49 |   for file in files
 50 |     if s:filereadable(file)
 51 |       return file
 52 |     endif
 53 |   endfor
 54 |   return ''
 55 | endfunction
 56 | 
 57 | function! s:add(array, string)
 58 |   if type(a:string) == type("") && !empty(a:string)
 59 |     call add(a:array, a:string)
 60 |   endif
 61 | endfunction
 62 | 
 63 | " helper methods to find and parse test names in quotes
 64 | function! s:gsub(str,pat,rep)
 65 |   return substitute(a:str,'\v\C'.a:pat,a:rep,'g')
 66 | endfunction
 67 | 
 68 | function! s:shellescape(str)
 69 |   return s:gsub(s:gsub(s:gsub(a:str, '"', '\\"'), "'", "\\\\'"), '!', '\\!')
 70 | endfunction
 71 | " }}}1
 72 | 
 73 | " Test running {{{1
 74 | function! s:prefix_for_test(file)
 75 |   if a:file =~# '_spec.rb$'
 76 |     return g:turbux_command_rspec
 77 |   elseif a:file =~# '_spec.\(coffee\|js\)$'
 78 |     return g:turbux_command_teaspoon
 79 |   elseif a:file =~# '\(\<test_.*\|_test\)\.rb$'
 80 |     return g:turbux_command_test_unit
 81 |   elseif a:file =~# '.feature$'
 82 |     if a:file =~# '\<spec/'
 83 |       return g:turbux_command_turnip
 84 |     else
 85 |       return g:turbux_command_cucumber
 86 |     endif
 87 |   elseif a:file =~# '_test\.exs$'
 88 |     return g:turbux_command_elixir_test
 89 |   elseif a:file =~# '_spec\.exs$'
 90 |     return g:turbux_command_elixir_spec
 91 |   endif
 92 |   return ''
 93 | endfunction
 94 | 
 95 | function! s:test_file_for(file)
 96 |   let candidates = []
 97 |   if s:has_rails_vim()
 98 |     call s:add(candidates, rails#buffer().test_file())
 99 |   endif
100 |   if !empty(s:prefix_for_test(a:file))
101 |     call s:add(candidates, a:file)
102 |   endif
103 |   return s:first_readable_file(candidates)
104 | endfunction
105 | 
106 | function! s:command_for_file(file)
107 |   let executable = []
108 |   let test_file = s:test_file_for(a:file)
109 |   if !empty(test_file)
110 |     call s:add(executable, g:turbux_command_prefix)
111 |     call s:add(executable, s:prefix_for_test(test_file))
112 |     call s:add(executable, s:shellescape(test_file))
113 |   endif
114 | 
115 |   " executable: [prefix] command file
116 |   return join(executable, " ")
117 | endfunction
118 | 
119 | function! s:default_runner()
120 |   if exists(":Dispatch")
121 |     return 'dispatch'
122 |   elseif exists("*VimuxRunCommand")
123 |     return 'vimux'
124 |   elseif exists("*Send_to_Tmux")
125 |     return 'tslime'
126 |   elseif exists(":VtrSendCommandToRunner")
127 |     return 'vtr'
128 |   else
129 |     return 'vim'
130 |   endif
131 | endfunction
132 | 
133 | function! s:runner()
134 |   " If exists, use a custom user-defined runner
135 |   if exists("g:turbux_custom_runner")
136 |     let fn = g:turbux_custom_runner
137 |     if exists("*".fn)
138 |       return fn
139 |     else
140 |       echo "Custom test runner function '" . fn . "' doesn't exist."
141 |       unlet g:turbux_custom_runner
142 |     end
143 |   endif
144 | 
145 |   " If unset, determine the correct test runner
146 |   if !exists("g:turbux_runner")
147 |     let g:turbux_runner = s:default_runner()
148 |   endif
149 | 
150 |   " If the appropriate turbux runner if it exists
151 |   let fn = 's:run_command_with_'.g:turbux_runner
152 |   if exists("*".fn)
153 |     return fn
154 |   endif
155 | 
156 |   " Use 'vim' as failover runner
157 |   echo "No such runner: ". g:turbux_runner." . Setting runner to 'vim'."
158 |   let g:turbux_runner = 'vim'
159 |   return ''
160 | endfunction
161 | 
162 | function! s:run_command_with_dispatch(command)
163 |   :execute ":Dispatch" a:command
164 | endfunction
165 | 
166 | function! s:run_command_with_vimux(command)
167 |   return VimuxRunCommand(a:command)
168 | endfunction
169 | 
170 | function! s:run_command_with_tslime(command)
171 |   let executable = "".a:command
172 |   return Send_to_Tmux(executable."\n")
173 | endfunction
174 | 
175 | function! s:run_command_with_vtr(command)
176 |   :execute ":VtrSendCommandToRunner" a:command
177 | endfunction
178 | 
179 | function! s:run_command_with_vim(command)
180 |   exec ':silent !echo;echo;echo;echo;echo;echo;echo;echo;echo;echo'
181 |   exec ':!'.a:command
182 | endfunction
183 | 
184 | function! s:run_command_with_echo(command)
185 |   echo 'Command: `'.a:command.'`'
186 | endfunction
187 | 
188 | function! s:run_command(command)
189 |   let runner = s:runner()
190 |   if !empty(runner)
191 |     return call(runner, [a:command])
192 |   else
193 |     return ''
194 |   endif
195 | endfunction
196 | 
197 | function! s:send_test(executable)
198 |   let executable = a:executable
199 |   if empty(executable)
200 |     if exists("g:tmux_last_command") && !empty(g:tmux_last_command)
201 |       let executable = g:tmux_last_command
202 |     else
203 |       let executable = 'echo "Warning: No command has been run yet"'
204 |     endif
205 |   endif
206 |   return s:run_command(executable)
207 | endfunction
208 | 
209 | function! s:execute_test_by_name()
210 |   let s:line_no = search('^\s*def\s*test_', 'bcnW')
211 |   if s:line_no
212 |     return " -n \"" . split(getline(s:line_no))[1] . "\""
213 |   else
214 |     return ""
215 |   endif
216 | endfunction
217 | 
218 | function! s:find_unit_test_name_in_quotes()
219 |   let s:line_no = search('^\s*test\s*\([''"]\).*\1', 'bcnW')
220 |   if s:line_no
221 |     let line = getline(s:line_no)
222 |     let string = matchstr(line,'^\s*\w\+\s*\([''"]\)\zs.*\ze\1')
223 |     return 'test_'.s:gsub(string,' +','_')
224 |   else
225 |     return ""
226 |   endif
227 | endfunction
228 | 
229 | function! s:find_shoulda_test_name_in_quotes()
230 |   let s:line_no = search('^\s*should\s*\([''"]\).*\1', 'bcnW')
231 |   if s:line_no
232 |     let line = getline(s:line_no)
233 |     let string = matchstr(line,'^\s*\w\+\s*\([''"]\)\zs.*\ze\1')
234 |     return s:gsub(string,' +','\\ ')
235 |   else
236 |     return ""
237 |   endif
238 | endfunction
239 | 
240 | function! s:find_test_name_with_it()
241 |   let s:line_no = search('^\s*\(it\|describe\)\s*\([''"]\).*\2', 'bcnW')
242 |   if s:line_no
243 |     let line = getline(s:line_no)
244 |     let string = matchstr(line,'^\s*\w\+\s*\([''"]\)\zs.*\ze\1')
245 |     return string
246 |   else
247 |     return ""
248 |   endif
249 | endfunction
250 | "}}}1
251 | 
252 | " Public functions {{{1
253 | function! SendTestToTmux(file) abort
254 |   let executable = s:command_for_file(a:file)
255 |   if !empty(executable)
256 |     let g:tmux_last_command = executable
257 |   endif
258 |   return s:send_test(executable)
259 | endfunction
260 | 
261 | function! SendFocusedTestToTmux(file, line) abort
262 |   let focus = ":".a:line
263 | 
264 |   if s:prefix_for_test(a:file) == g:turbux_command_test_unit && g:turbux_test_type != 'minitest'
265 |     let quoted_test_name = s:find_unit_test_name_in_quotes()
266 |     if !empty(quoted_test_name)
267 |       let focus = " -n \"".quoted_test_name."\""
268 |     else
269 |       let quoted_test_name = s:find_shoulda_test_name_in_quotes()
270 |       if !empty(quoted_test_name)
271 |         let focus = " -n /".quoted_test_name."/"
272 |       else
273 |         let focus = s:execute_test_by_name()
274 |       endif
275 |     endif
276 |   endif
277 | 
278 |   if s:prefix_for_test(a:file) == g:turbux_command_teaspoon
279 |     let quoted_test_name = s:find_test_name_with_it()
280 |     if !empty(quoted_test_name)
281 |       let focus = " --filter=\"".quoted_test_name."\""
282 |     endif
283 |   endif
284 | 
285 | 
286 |   if !empty(s:prefix_for_test(a:file))
287 |     let executable = s:command_for_file(a:file).focus
288 |     let g:tmux_last_focused_command = executable
289 |   elseif exists("g:tmux_last_focused_command") && !empty(g:tmux_last_focused_command)
290 |     let executable = g:tmux_last_focused_command
291 |   else
292 |     let executable = ''
293 |   endif
294 |   return s:send_test(executable)
295 | endfunction
296 | " }}}1
297 | 
298 | " Mappings {{{1
299 | nnoremap <silent> <Plug>SendTestToTmux :<C-U>w \| call SendTestToTmux(expand('%'))<CR>
300 | nnoremap <silent> <Plug>SendFocusedTestToTmux :<C-U>w \| call SendFocusedTestToTmux(expand('%'), line('.'))<CR>
301 | 
302 | if !exists("g:no_turbux_mappings")
303 |   nmap <leader>t <Plug>SendTestToTmux
304 |   nmap <leader>T <Plug>SendFocusedTestToTmux
305 | endif
306 | "}}}1
307 | 
308 | 
309 | " vim:set ft=vim ts=4 sw=2 sts=2:
310 | 


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