From 347b3bea0e5f5831e739d89909248504d3c9a0d8 Mon Sep 17 00:00:00 2001 From: amix Date: Sat, 14 May 2016 13:00:06 +0100 Subject: [PATCH] Added yankstack, a replacement for YankRing --- sources_non_forked/vim-yankstack/.gitignore | 2 + sources_non_forked/vim-yankstack/Gemfile | 4 + sources_non_forked/vim-yankstack/Gemfile.lock | 25 ++ sources_non_forked/vim-yankstack/README.md | 134 +++++++ .../vim-yankstack/autoload/yankstack.vim | 197 ++++++++++ .../vim-yankstack/doc/yankstack.txt | 124 +++++++ .../vim-yankstack/plugin/yankstack.vim | 1 + .../vim-yankstack/spec/fixtures/repeat.vim | 115 ++++++ .../vim-yankstack/spec/spec_helper.rb | 9 + .../spec/yankstack/yankstack_spec.rb | 343 ++++++++++++++++++ 10 files changed, 954 insertions(+) create mode 100644 sources_non_forked/vim-yankstack/.gitignore create mode 100644 sources_non_forked/vim-yankstack/Gemfile create mode 100644 sources_non_forked/vim-yankstack/Gemfile.lock create mode 100644 sources_non_forked/vim-yankstack/README.md create mode 100644 sources_non_forked/vim-yankstack/autoload/yankstack.vim create mode 100644 sources_non_forked/vim-yankstack/doc/yankstack.txt create mode 100644 sources_non_forked/vim-yankstack/plugin/yankstack.vim create mode 100644 sources_non_forked/vim-yankstack/spec/fixtures/repeat.vim create mode 100644 sources_non_forked/vim-yankstack/spec/spec_helper.rb create mode 100644 sources_non_forked/vim-yankstack/spec/yankstack/yankstack_spec.rb diff --git a/sources_non_forked/vim-yankstack/.gitignore b/sources_non_forked/vim-yankstack/.gitignore new file mode 100644 index 00000000..655a3682 --- /dev/null +++ b/sources_non_forked/vim-yankstack/.gitignore @@ -0,0 +1,2 @@ +.rvmrc +doc/tags diff --git a/sources_non_forked/vim-yankstack/Gemfile b/sources_non_forked/vim-yankstack/Gemfile new file mode 100644 index 00000000..f2e1aba5 --- /dev/null +++ b/sources_non_forked/vim-yankstack/Gemfile @@ -0,0 +1,4 @@ +source 'https://rubygems.org' + +gem "vimbot", :git => "git@github.com:maxbrunsfeld/vimbot.git" +gem "rspec" diff --git a/sources_non_forked/vim-yankstack/Gemfile.lock b/sources_non_forked/vim-yankstack/Gemfile.lock new file mode 100644 index 00000000..c17e2f41 --- /dev/null +++ b/sources_non_forked/vim-yankstack/Gemfile.lock @@ -0,0 +1,25 @@ +GIT + remote: git@github.com:maxbrunsfeld/vimbot.git + revision: 489cb3283a89d3e7891d9d9765188179c764317b + specs: + vimbot (0.0.1) + +GEM + remote: https://rubygems.org/ + specs: + diff-lcs (1.1.3) + rspec (2.8.0) + rspec-core (~> 2.8.0) + rspec-expectations (~> 2.8.0) + rspec-mocks (~> 2.8.0) + rspec-core (2.8.0) + rspec-expectations (2.8.0) + diff-lcs (~> 1.1.2) + rspec-mocks (2.8.0) + +PLATFORMS + ruby + +DEPENDENCIES + rspec + vimbot! diff --git a/sources_non_forked/vim-yankstack/README.md b/sources_non_forked/vim-yankstack/README.md new file mode 100644 index 00000000..2fcfc769 --- /dev/null +++ b/sources_non_forked/vim-yankstack/README.md @@ -0,0 +1,134 @@ +yankstack.vim +============= + +Author: Max Brunsfeld + +[Yankstack.vim](https://github.com/maxbrunsfeld/vim-yankstack) is a +lightweight implementation of the Emacs 'kill ring' for Vim. It allows you to +yank and delete things without worrying about losing the text that you yanked +previously. It effectively turns your default register into a stack, and lets +you cycle through the items in the stack after doing a paste. + +This plugin is intended to be a simpler alternative to the +[yankring](https://github.com/chrismetcalf/vim-yankring) plugin. It has a fairly +complete [test suite](https://github.com/maxbrunsfeld/vim-yankstack/blob/master/spec/yankstack/yankstack_spec.rb) +based on [rspec](https://www.relishapp.com/rspec) +and [vimbot](https://github.com/maxbrunsfeld/vimbot). + +## Installation ## + +I recommend loading your plugins with +[vundle](https://github.com/gmarik/vundle) or +[pathogen](https://github.com/tpope/vim-pathogen). + +## Key Mappings ## + +By default, yankstack adds only 2 key bindings, in normal and visual modes: + +- ```meta-p``` - cycle *backward* through your history of yanks +- ```meta-shift-p``` - cycle *forwards* through your history of yanks + +After pasting some text using ```p``` or ```P```, you can cycle through your +yank history using these commands. Typing either of these keys *without* pasting first +will do a normal paste (the same as typing `p`). This also works in insert mode. + +### the 'meta' key + +If you're using MacVim, and you want to use +this plugin's default key bindings (or any bindings involving the `option` +key), you must ```:set macmeta```. On Linux, you may have issues with the meta key if your terminal is running in 7bit mode. +Instructions for dealing with this can be found on the [wiki](https://github.com/maxbrunsfeld/vim-yankstack/wiki/Linux-terminal-configurations-for-correct-meta-key-handling) + +## Commands ## + +You can see the contents of the yank-stack using the ```:Yanks``` command. +Its output is similar to the ```:registers``` command. + +## Configuration ## + +Yankstack defines two plugin mappings that you can map to keys of your choosing. +The same mappings work in normal and insert modes. + +- ```yankstack_substitute_older_paste``` - cycle backwards through your history of yanks +- ```yankstack_substitute_newer_paste``` - cycle forwards through your history of yanks + +For example, if you wanted to define some mappings based on your 'leader' key, +you could do this: + +``` +nmap p yankstack_substitute_older_paste +nmap P yankstack_substitute_newer_paste +``` + +Also, if you want to load yankstack without the default key mappings, just +``` let g:yankstack_map_keys = 0 ``` +in your .vimrc file. + +## Compatibility ## + +Yankstack works by mapping the yank and paste keys to functions that do some +book-keeping before calling through to the normal yank/paste keys. You may want +to define your own mappings of the yank and paste keys. For example, I like to +map the ```Y``` key to ```y$```, so that it behaves the same as ```D``` and +```C```. The yankstack mappings need to happen **before** you define any such +mappings of your own. To achieve this, just call ```yankstack#setup()``` in +your vimrc, before defining your mappings: + +``` +call yankstack#setup() +nmap Y y$ +" other mappings involving y, d, c, etc +``` + +You can also prevent certain keys from being remapped by setting the `g:yankstack_yank_keys` +to the keys of your choosing. For example, if you only want Yankstack to remap `y` and `d`: + +``` +let g:yankstack_yank_keys = ['y', 'd'] +``` + +## Contributing, Feedback ## + +I'd enjoy hearing anybody's feedback on yankstack, and welcome any contribution. +Check it out on [github](https://github.com/maxbrunsfeld/vim-yankstack)! + +## Changelog ## + + +### 1.0.6 (2014-08-04) + - Allow customization of the list of keys to be remapped. + +### 1.0.5 (2012-07-19) + - Fix bug where on certain versions of vim, the first time you tried + to cycle through your yanks after doing a normal paste, an extra + paste was created. + +### 1.0.4 (2012-07-01) + - Make it so that yankstack-cycling keys cause a normal paste if they are + used without pasting first. Fix stack-cycling in insert-mode. + +### 1.0.3 (2012-05-04): + - Fix bug when overwriting text in select mode. This was causing + problems for snipMate users. + +### 1.0.2 (2012-4-20): + - Add test coverage using rspec and [vimbot](https://github.com/maxbrunsfeld/vimbot)! + - Perfect the behavior of the yankstack when pasting over text in visual + mode + - Fix bug where 's' and 'S' didn't push to the yankstack + +### 1.0.1 (2012-2-11): + - Change default key bindings, update readme, add link to github page. + +### 1.0.1 (2011-12-08): + - Fix bug when displaying empty yanks. + +### 1.0.0 (2011-12-04): + - Remove unnecessary dependency on the undotree() function. Plugin should + now work on any recent version of vim. + +## License ## +Copyright (c) Max Brunsfeld. Distributed under the same terms as Vim itself. +See the vim license. + + vim:tw=78:ts=8:ft=help:norl: diff --git a/sources_non_forked/vim-yankstack/autoload/yankstack.vim b/sources_non_forked/vim-yankstack/autoload/yankstack.vim new file mode 100644 index 00000000..8feb49e8 --- /dev/null +++ b/sources_non_forked/vim-yankstack/autoload/yankstack.vim @@ -0,0 +1,197 @@ +" yankstack.vim - keep track of your history of yanked/killed text +" +" Maintainer: Max Brunsfeld +" Version: 1.0.6 +" Todo: +" + +let s:yankstack_tail = [] +let g:yankstack_size = 30 +let s:last_paste = { 'changedtick': -1, 'key': '', 'mode': 'n', 'count': 1, 'register': '' } + +if !exists('g:yankstack_yank_keys') + let g:yankstack_yank_keys = ['c', 'C', 'd', 'D', 's', 'S', 'x', 'X', 'y', 'Y'] +endif + +function! s:yank_with_key(key) + call s:before_yank() + return a:key +endfunction + +function! s:paste_with_key(key, mode, register, count) + return s:paste_from_yankstack(a:key, a:mode, a:register, a:count, 1) +endfunction + +function! s:paste_from_yankstack(key, mode, register, count, is_new) + let keys = a:count . a:key + let keys = (a:register == s:default_register()) ? keys : ('"' . a:register . keys) + let s:last_paste = { 'key': a:key, 'mode': a:mode, 'register': a:register, 'count': a:count, 'changedtick': -1 } + call feedkeys("\yankstack_after_paste", "m") + + if a:mode == 'n' + exec 'normal!' keys + elseif a:mode == 'v' + if a:is_new + call s:before_yank() + call feedkeys("\yankstack_substitute_older_paste", "t") + exec 'normal! gv' . keys + else + let head = s:get_yankstack_head() + exec 'normal! gv' . keys + call s:set_yankstack_head(head) + endif + + " In insert mode, this function's return value is used in an + " expression mapping. In other modes, it is called for its + " side effects only. + elseif a:mode == 'i' + return keys + endif + + silent! call repeat#setreg(a:register) + silent! call repeat#set(a:key, a:count) +endfunction + +function! s:substitute_paste(offset, current_mode) + if s:last_change_was_paste() + silent undo + call s:yankstack_rotate(a:offset) + return s:paste_from_yankstack(s:last_paste.key, s:last_paste.mode, s:last_paste.register, s:last_paste.count, 0) + else + return s:paste_from_yankstack(s:default_paste_key(a:current_mode), a:current_mode, v:register, '', 1) + endif +endfunction + +function! s:before_yank() + let head = s:get_yankstack_head() + if !empty(head.text) && (empty(s:yankstack_tail) || (head != s:yankstack_tail[0])) + call insert(s:yankstack_tail, head) + let s:yankstack_tail = s:yankstack_tail[: g:yankstack_size-1] + endif +endfunction + +function! s:yankstack_rotate(offset) + if empty(s:yankstack_tail) | return | endif + let offset_left = a:offset + while offset_left != 0 + let head = s:get_yankstack_head() + if offset_left > 0 + let entry = remove(s:yankstack_tail, 0) + call add(s:yankstack_tail, head) + let offset_left -= 1 + elseif offset_left < 0 + let entry = remove(s:yankstack_tail, -1) + call insert(s:yankstack_tail, head) + let offset_left += 1 + endif + call s:set_yankstack_head(entry) + endwhile +endfunction + +function! s:get_yankstack_head() + let reg = s:default_register() + return { 'text': getreg(reg), 'type': getregtype(reg) } +endfunction + +function! s:set_yankstack_head(entry) + let reg = s:default_register() + call setreg(reg, a:entry.text, a:entry.type) +endfunction + +function! s:after_paste() + let s:last_paste.changedtick = b:changedtick +endfunction + +function! s:last_change_was_paste() + return b:changedtick == s:last_paste.changedtick +endfunction + +function! s:default_register() + let clipboard_flags = split(&clipboard, ',') + if index(clipboard_flags, 'unnamedplus') >= 0 + return "+" + elseif index(clipboard_flags, 'unnamed') >= 0 + return "*" + else + return "\"" + endif +endfunction + +function! s:default_paste_key(mode) + if a:mode == 'i' + return "\u\" . s:default_register() + else + return "p" + endif +endfunction + +function! g:Yankstack() + return [s:get_yankstack_head()] + s:yankstack_tail +endfunction + +command! -nargs=0 Yanks call s:show_yanks() +function! s:show_yanks() + echohl WarningMsg | echo "--- Yanks ---" | echohl None + let i = 0 + for yank in g:Yankstack() + call s:show_yank(yank, i) + let i += 1 + endfor +endfunction + +function! s:show_yank(yank, index) + let index = printf("%-4d", a:index) + let lines = split(a:yank.text, '\n') + let line = empty(lines) ? '' : lines[0] + let line = substitute(line, '\t', repeat(' ', &tabstop), 'g') + if len(line) > 80 || len(lines) > 1 + let line = line[: 80] . '…' + endif + + echohl Directory | echo index + echohl None | echon line + echohl None +endfunction + +function! yankstack#setup() + if exists('g:yankstack_did_setup') | return | endif + let g:yankstack_did_setup = 1 + + let paste_keys = ['p', 'P', 'gp', 'gP'] + let word_characters = split("qwertyuiopasdfghjklzxcvbnm1234567890_", '\zs') + + for key in g:yankstack_yank_keys + exec 'nnoremap ' key 'yank_with_key("' . key . '")' + exec 'xnoremap ' key 'yank_with_key("' . key . '")' + endfor + + for key in paste_keys + exec 'nnoremap ' key ':call paste_with_key("' . key . '", "n", v:register, v:count1)' + exec 'xnoremap ' key ':call paste_with_key("' . key . '", "v", v:register, v:count1)' + endfor + + for key in word_characters + exec 'smap ' key 'yank_with_key("' . key . '")' + endfor +endfunction + +nnoremap yankstack_substitute_older_paste :call substitute_paste(v:count1, 'n') +nnoremap yankstack_substitute_newer_paste :call substitute_paste(-v:count1, 'n') +xnoremap yankstack_substitute_older_paste :call substitute_paste(v:count1, 'v') +xnoremap yankstack_substitute_newer_paste :call substitute_paste(-v:count1, 'v') +inoremap yankstack_substitute_older_paste =substitute_paste(v:count1, 'i') +inoremap yankstack_substitute_newer_paste =substitute_paste(-v:count1, 'i') + +nnoremap yankstack_after_paste :call after_paste() +xnoremap yankstack_after_paste :call after_paste() +inoremap yankstack_after_paste :call after_paste() + +if !exists('g:yankstack_map_keys') || g:yankstack_map_keys + nmap yankstack_substitute_older_paste + xmap yankstack_substitute_older_paste + imap yankstack_substitute_older_paste + nmap yankstack_substitute_newer_paste + xmap yankstack_substitute_newer_paste + imap yankstack_substitute_newer_paste +endif + diff --git a/sources_non_forked/vim-yankstack/doc/yankstack.txt b/sources_non_forked/vim-yankstack/doc/yankstack.txt new file mode 100644 index 00000000..2a7dee5f --- /dev/null +++ b/sources_non_forked/vim-yankstack/doc/yankstack.txt @@ -0,0 +1,124 @@ +*yankstack.txt* Plugin for storing and cycling through yanked text strings. + +Author: Max Brunsfeld + +|yankstack-introduction| Introduction +|yankstack-installation| Installation +|yankstack-initialization| Initialization +|yankstack-commands| Commands +|yankstack-configuration| Configuration +|yankstack-changelog| Changelog + +INTRODUCTION *yankstack-introduction* + +[Yankstack.vim](https://github.com/maxbrunsfeld/vim-yankstack) is a +lightweight implementation of the Emacs 'kill ring' for Vim. It allows you to +yank and delete things without worrying about losing the text that you yanked +previously. It effectively turns your default register into a stack, and lets +you cycle through the items in the stack after doing a paste. + +This plugin is intended to be a simpler alternative to the {Yankring} plugin +(https://github.com/chrismetcalf/vim-yankring). + +INSTALLATION *yankstack-installation* + +I recommend loading your plugins with {Pathogen} +(https://github.com/tpope/vim-pathogen), so you can just clone this repo into +your "bundle" directory. + +KEY MAPPINGS *yankstack-mappings* + +By default, yankstack adds only 2 key mappings, in normal and visual modes: + +Mapping Action ~ +meta-p cycle backward through your history of yanks +meta-shift-p cycle forwards through your history of yanks + +After pasting some text using |p| or |P|, you can cycle through your +yank history using these commands. + +Typing either of these keys without pasting first will do a normal paste +(the same as typing `p`). This also works in insert mode. + +A note about the meta key - if you're using MacVim, and you want to use +this plugin's default key bindings (or any bindings involving the `option` +key), you must :set |macmeta|. + +COMMANDS *yankstack-commands* + +You can see the contents of the yank-stack using the :Yanks command. +Its output is similar to the |registers| command. > + + :Yanks (lists the contents of the yank-stack) + +CONFIGURATION *yankstack-configuration* + +If you want to load yankstack without defining any of the default key +mappings, just add > + + let g:yankstack_map_keys = 0 + +to your |.vimrc| file. + +Yankstack defines three plugin mappings that you can map to keys of your +choosing. The same mappings work in normal and insert modes. + +Mapping Name Action ~ +yankstack_substitute_older_paste cycle BACKWARDs through your history of yanks +yankstack_substitute_newer_paste cycle FORWARDS through your history of yanks + +For example, if you wanted to define some mappings based on your |leader| key, you could do this: > + + nmap p yankstack_substitute_older_paste + nmap P yankstack_substitute_newer_paste + + +COMPATIBILITY *yankstack-compatibility* + +Yankstack works by mapping the yank and paste keys to functions that do some +book-keeping before calling through to the normal yank/paste keys. You may +want to define your own mappings of the yank and paste keys. For example, I +like to map the |Y| key to "y$", so that it behaves the same as |D| and |C|. +The yankstack mappings need to happen **BEFORE** you define any such +mappings of your own. To achieve this, just call 'yankstack#setup()'in your +|vimrc|, before defining your mappings: > + + call yankstack#setup() + nmap Y y$ + +CHANGELOG *yankstack-changelog* + +1.0.5 (2012-07-19) + - Fix bug where on certain versions of vim, the first time you tried + to cycle through your yanks after doing a normal paste, an extra + paste was created. + +1.0.4 (2012-07-01) + - Make it so that yankstack-cycling keys cause a normal paste if they are + used without pasting first. Fix stack-cycling in insert-mode. + +1.0.3 (2012-05-04): + - Fix bug when overwriting text in select mode. This was causing + problems for snipMate users. + +1.0.2 (2012-4-20): + - Add test coverage using rspec and [vimbot](https://github.com/maxbrunsfeld/vimbot)! + - Perfect the behavior of the yankstack when pasting over text in visual + mode + - Fix bug where 's' and 'S' didn't push to the yankstack + +1.0.1 (2012-02-11): + - Change default key bindings, update readme, add link to github page. + +1.0.1 (2011-12-08): + - Fix bug when displaying empty yanks. + +1.0 (2011-12-04): + - Remove unnecessary dependency on the undotree() function. Plugin should + now work on any recent version of vim. + + *yankstack-license* +Copyright (c) Max Brunsfeld. Distributed under the same terms as Vim itself. +See |license|. + + vim:tw=78:ts=8:ft=help:norl: diff --git a/sources_non_forked/vim-yankstack/plugin/yankstack.vim b/sources_non_forked/vim-yankstack/plugin/yankstack.vim new file mode 100644 index 00000000..a5ad03b7 --- /dev/null +++ b/sources_non_forked/vim-yankstack/plugin/yankstack.vim @@ -0,0 +1 @@ +call yankstack#setup() diff --git a/sources_non_forked/vim-yankstack/spec/fixtures/repeat.vim b/sources_non_forked/vim-yankstack/spec/fixtures/repeat.vim new file mode 100644 index 00000000..e8fe7237 --- /dev/null +++ b/sources_non_forked/vim-yankstack/spec/fixtures/repeat.vim @@ -0,0 +1,115 @@ +" repeat.vim - Let the repeat command repeat plugin maps +" Maintainer: Tim Pope +" Version: 1.1 +" GetLatestVimScripts: 2136 1 :AutoInstall: repeat.vim + +" Installation: +" Place in either ~/.vim/plugin/repeat.vim (to load at start up) or +" ~/.vim/autoload/repeat.vim (to load automatically as needed). +" +" License: +" Copyright (c) Tim Pope. Distributed under the same terms as Vim itself. +" See :help license +" +" Developers: +" Basic usage is as follows: +" +" silent! call repeat#set("\MappingToRepeatCommand",3) +" +" The first argument is the mapping that will be invoked when the |.| key is +" pressed. Typically, it will be the same as the mapping the user invoked. +" This sequence will be stuffed into the input queue literally. Thus you must +" encode special keys by prefixing them with a backslash inside double quotes. +" +" The second argument is the default count. This is the number that will be +" prefixed to the mapping if no explicit numeric argument was given. The +" value of the v:count variable is usually correct and it will be used if the +" second parameter is omitted. If your mapping doesn't accept a numeric +" argument and you never want to receive one, pass a value of -1. +" +" Make sure to call the repeat#set function _after_ making changes to the +" file. +" +" For mappings that use a register and want the same register used on +" repetition, use: +" +" silent! call repeat#setreg("\MappingToRepeatCommand", v:register) +" +" This function can (and probably needs to be) called before making changes to +" the file (as those typically clear v:register). Therefore, the call sequence +" in your mapping will look like this: +" +" nnoremap MyMap +" \ :execute 'silent! call repeat#setreg("\Plug>MyMap", v:register)' +" \ call MyFunction(v:register, ...) +" \ silent! call repeat#set("\Plug>MyMap") + +if exists("g:loaded_repeat") || &cp || v:version < 700 + finish +endif +let g:loaded_repeat = 1 + +let g:repeat_tick = -1 +let g:repeat_reg = ['', ''] + +" Special function to avoid spurious repeats in a related, naturally repeating +" mapping when your repeatable mapping doesn't increase b:changedtick. +function! repeat#invalidate() + let g:repeat_tick = -1 +endfunction + +function! repeat#set(sequence,...) + let g:repeat_sequence = a:sequence + let g:repeat_count = a:0 ? a:1 : v:count + let g:repeat_tick = b:changedtick +endfunction + +function! repeat#setreg(sequence,register) + let g:repeat_reg = [a:sequence, a:register] +endfunction + +function! repeat#run(count) + if g:repeat_tick == b:changedtick + let r = '' + if g:repeat_reg[0] ==# g:repeat_sequence && !empty(g:repeat_reg[1]) + if g:repeat_reg[1] ==# '=' + " This causes a re-evaluation of the expression on repeat, which + " is what we want. + let r = '"=' . getreg('=', 1) . "\" + else + let r = '"' . g:repeat_reg[1] + endif + endif + + let c = g:repeat_count + let s = g:repeat_sequence + let cnt = c == -1 ? "" : (a:count ? a:count : (c ? c : '')) + call feedkeys(r . cnt, 'n') + call feedkeys(s) + else + call feedkeys((a:count ? a:count : '') . '.', 'n') + endif +endfunction + +function! repeat#wrap(command,count) + let preserve = (g:repeat_tick == b:changedtick) + exe 'norm! '.(a:count ? a:count : '').a:command . (&foldopen =~# 'undo' ? 'zv' : '') + if preserve + let g:repeat_tick = b:changedtick + endif +endfunction + +nnoremap . :call repeat#run(v:count) +nnoremap u :call repeat#wrap('u',v:count) +if maparg('U','n') ==# '' + nnoremap U :call repeat#wrap('U',v:count) +endif +nnoremap :call repeat#wrap("\C-R>",v:count) + +augroup repeatPlugin + autocmd! + autocmd BufLeave,BufWritePre,BufReadPre * let g:repeat_tick = (g:repeat_tick == b:changedtick || g:repeat_tick == 0) ? 0 : -1 + autocmd BufEnter,BufWritePost * if g:repeat_tick == 0|let g:repeat_tick = b:changedtick|endif +augroup END + +" vim:set ft=vim et sw=4 sts=4: diff --git a/sources_non_forked/vim-yankstack/spec/spec_helper.rb b/sources_non_forked/vim-yankstack/spec/spec_helper.rb new file mode 100644 index 00000000..8fa4b47f --- /dev/null +++ b/sources_non_forked/vim-yankstack/spec/spec_helper.rb @@ -0,0 +1,9 @@ +require "vimbot" + +PLUGIN_ROOT = File.expand_path("../..", __FILE__) +VIM_REPEAT_PATH = File.expand_path("spec/fixtures/repeat.vim", PLUGIN_ROOT) + +RSpec.configure do |c| + c.alias_it_should_behave_like_to :it_has_behavior, 'has behavior:' +end + diff --git a/sources_non_forked/vim-yankstack/spec/yankstack/yankstack_spec.rb b/sources_non_forked/vim-yankstack/spec/yankstack/yankstack_spec.rb new file mode 100644 index 00000000..327fb5fc --- /dev/null +++ b/sources_non_forked/vim-yankstack/spec/yankstack/yankstack_spec.rb @@ -0,0 +1,343 @@ +require "spec_helper" + +describe "Yankstack" do + let(:vim) { Vimbot::Driver.new } + + before(:all) do + vim.start + + vim.set "visualbell" + vim.set "noerrorbells" + vim.set "macmeta" + + vim.set "runtimepath+=#{PLUGIN_ROOT}" + vim.runtime "plugin/yankstack.vim" + + vim.source VIM_REPEAT_PATH + end + + after(:all) { vim.stop } + before(:each) { vim.clear_buffer } + + shared_examples "yanking and pasting" do + let(:yank_keys) { "yw" } + + before do + vim.insert "first_line", "second_line", "third_line", "fourth_line" + vim.normal "gg" + vim.normal yank_keys, 'j', yank_keys, 'j', yank_keys, 'j', yank_keys + end + + it "pushes every yanked string to the :Yanks stack" do + yank_entries[0].should match /0\s+fourth_line/ + yank_entries[1].should match /1\s+third_line/ + yank_entries[2].should match /2\s+second_line/ + yank_entries[3].should match /3\s+first_line/ + end + + describe "yanking with different keys" do + before do + vim.normal "A", "", "line to delete", "", "^" + end + + keys_that_change_register = [ + 'cc', 'C', + 'dd', 'D', + 's', 'S', + 'x', 'X', + 'yy', 'Y' + ] + + keys_that_change_register.each do |key| + it "pushes to the stack when deleting text with '#{key}'" do + vim.normal key + yank_entries[1].should match /1\s+fourth_line/ + end + end + + it "pushes to the stack when overwriting text in select mode" do + vim.type "V" + vim.type "", "this overwrites the last line" + yank_entries[0].should include "line to delete" + yank_entries[1].should include "fourth_line" + end + end + + context "in normal mode" do + before { vim.normal "o", "" } + + describe "pasting a string with 'p'" do + before { vim.normal "p" } + + it "pastes the most recently yanked string" do + vim.line_number.should == 5 + vim.line.should == "fourth_line" + end + + describe "pressing the repeat key with '.'" do + it "pastes again" do + pending unless File.exists?(VIM_REPEAT_PATH) + + vim.type "." + vim.line.should == "fourth_linefourth_line" + end + end + + describe "typing the 'cycle paste' key" do + before { vim.normal "" } + + it "replaces the pasted string with the previously yanked text" do + vim.line.should == "third_line" + end + + it "rotates the previously yanked text to the top of the yank stack" do + yank_entries[0].should include 'third_line' + yank_entries[1].should include 'second_line' + yank_entries[2].should include 'first_line' + yank_entries[-1].should include 'fourth_line' + end + + it "rotates through the yanks when pressed multiple times" do + vim.normal "" + vim.line.should == "second_line" + vim.normal "" + vim.line.should == "first_line" + + vim.normal "" + vim.line.should == "second_line" + vim.normal "" + vim.line.should == "third_line" + vim.normal "" + vim.line.should == "fourth_line" + end + end + end + + describe "typing the `substitute_older_paste` key without pasting first" do + before { vim.type "" } + + it "pastes the most recently yanked string" do + vim.line_number.should == 5 + vim.line.should == "fourth_line" + end + + describe "typing the 'cycle paste' key" do + before { vim.normal "" } + + it "replaces the pasted text with the previously yanked text" do + vim.line.should == "third_line" + end + end + end + + describe "typing the `substitute_newer_paste` key without pasting first" do + before { vim.type "" } + + it "pastes the most recently yanked string" do + vim.line_number.should == 5 + vim.line.should == "fourth_line" + end + + describe "typing the 'cycle paste' key" do + before { vim.normal "" } + + it "replaces the pasted text with the previously yanked text" do + vim.line.should == "third_line" + end + end + end + + it "allows pasting from a non-default register" do + reg = 'a' + vim.normal "gg" + vim.normal %("#{reg}y$) + vim.normal "G" + + vim.normal %("#{reg}p) + vim.line.should == "first_line" + end + + it "allows pasting with a count" do + vim.normal "3p" + vim.line_number.should == 5 + vim.line.should == "fourth_line" * 3 + end + end + + context "in visual mode, with text highlighted" do + before do + vim.normal "A", "line to overwrite" + vim.normal "V" + end + + describe "pasting a string with 'p'" do + before do + vim.type "p" + end + + it "overwrites the selection with the most recently yanked string" do + vim.line.should == "fourth_line" + end + + it "moves the the overwritten text to the bottom of the stack" do + yank_entries[0].should include "fourth_line" + yank_entries[1].should include "third_line" + yank_entries[2].should include "second_line" + yank_entries[-1].should include "line to overwrite" + end + + describe "typing the 'cycle older paste' key" do + before { vim.normal "" } + + it "replaces the pasted text with the previously yanked text" do + vim.line.should == "third_line" + end + + it "moves the previously yanked text to the top of the stack" do + yank_entries[0].should include "third_line" + yank_entries[1].should include "second_line" + yank_entries[2].should include "first_line" + yank_entries[-2].should include "line to overwrite" + yank_entries[-1].should include "fourth_line" + end + + describe "typing the 'cycle newer paste' key" do + before { vim.normal "" } + + it "replaces the pasted text with the previously yanked text" do + vim.line.should == "fourth_line" + end + + it "moves the previously yanked text to the top of the stack" do + yank_entries[0].should include "fourth_line" + yank_entries[1].should include "third_line" + yank_entries[2].should include "second_line" + yank_entries[3].should include "first_line" + yank_entries[-1].should include "line to overwrite" + end + end + end + end + + describe "typing the `substitute_older_paste` key without pasting first" do + before { vim.type "" } + + it "overwrites the selection with the most recently yanked string" do + vim.line_number.should == 5 + vim.line.should == "fourth_line" + end + end + + describe "typing the `substitute_newer_paste` key without pasting first" do + before { vim.type "" } + + it "overwrites the selection with the most recently yanked string" do + vim.line_number.should == 5 + vim.line.should == "fourth_line" + end + end + + it "allows pasting with a count" do + vim.type "3p" + + vim.line_number.should == 5 + vim.line.should == "fourth_line" + + vim.normal 'j' + vim.line_number.should == 6 + vim.line.should == "fourth_line" + + vim.normal 'j' + vim.line_number.should == 7 + vim.line.should == "fourth_line" + end + end + + context "in insert mode" do + before do + vim.normal "A", "()", "" + vim.type "" + end + + describe "typing the `substitute_older_paste` after a character-wise yank" do + it "pastes the most recently yanked text after the cursor" do + vim.line_number.should == 5 + vim.line.should == "(fourth_line)" + end + + it "stays in insert mode, with the cursor at the end of the pasted text" do + vim.should be_in_insert_mode + vim.column_number.should == "(fourth_line".length + 1 + end + + describe "typing the `substitute_older_paste` key again" do + before { vim.type "" } + + it "replaces the pasted text with the previously yanked text" do + vim.line_number.should == 5 + vim.line.should == "(third_line)" + end + + it "stays in insert mode, with the cursor at the end of the pasted text" do + vim.should be_in_insert_mode + vim.column_number.should == "(third_line".length+1 + end + + it "rotates the previously yanked text to the top of the yank stack" do + yank_entries[0].should include 'third_line' + yank_entries[1].should include 'second_line' + yank_entries[2].should include 'first_line' + yank_entries[-1].should include 'fourth_line' + end + + it "rotates through the yanks when pressed multiple times" do + vim.type "" + vim.line_number.should == 5 + vim.line.should == "(second_line)" + + vim.type "" + vim.line_number.should == 5 + vim.line.should == "(first_line)" + + vim.type "" + vim.line_number.should == 5 + vim.line.should == "(second_line)" + + vim.type "" + vim.line_number.should == 5 + vim.line.should == "(third_line)" + + vim.type "" + vim.line_number.should == 5 + vim.line.should == "(fourth_line)" + end + end + end + + describe "typing `substitute_older_paste` after a line-wise yank" do + let(:yank_keys) { "yy" } + + xit "pastes and puts the cursor after the pasted text" do + vim.line_number.should == 6 + vim.line.should == ")" + vim.type "" + vim.line.should == "(fourth_line" + end + end + end + end + + describe "when using the normal default register" do + it_has_behavior "yanking and pasting" + end + + describe "when using the system clipboard as the default register" do + before { vim.set "clipboard", "unnamed" } + it_has_behavior "yanking and pasting" + end + + def yank_entries + @yank_entries ||= vim.command("Yanks").split("\n")[1..-1] + end +end +