]> git.wincent.com - docvim.git/commitdiff
Add Vim help integration tests
authorGreg Hurrell <greg@hurrell.net>
Fri, 10 Jun 2016 16:27:06 +0000 (09:27 -0700)
committerGreg Hurrell <greg@hurrell.net>
Fri, 10 Jun 2016 16:27:06 +0000 (09:27 -0700)
With the magic of copy-pasta. Will refactor away the duplication presently.

tests/fixtures/integration/ferret/golden/plaintext.golden [new file with mode: 0644]
tests/fixtures/integration/scalpel/golden/plaintext.golden [new file with mode: 0644]
tests/tasty.hs

diff --git a/tests/fixtures/integration/ferret/golden/plaintext.golden b/tests/fixtures/integration/ferret/golden/plaintext.golden
new file mode 100644 (file)
index 0000000..42633e4
--- /dev/null
@@ -0,0 +1,569 @@
+*ferret.txt*    Ferret plug-in for Vim      *ferret*
+
+CONTENTS                                                       *ferret-contents*
+
+1. Intro                  |ferret-intro|
+2. Installation           |ferret-installation|
+3. Options                |ferret-options|
+4. Commands               |ferret-commands|
+5. Mappings               |ferret-mappings|
+6. Custom autocommands    |ferret-custom-autocommands|
+7. Overrides              |ferret-overrides|
+8. Troubleshooting        |ferret-troubleshooting|
+9. FAQ                    |ferret-faq|
+10. Related               |ferret-related|
+11. Website               |ferret-website|
+12. License               |ferret-license|
+13. Development           |ferret-development|
+14. Authors               |ferret-authors|
+15. History               |ferret-history|
+
+INTRO                                                             *ferret-intro*
+
+    "ferret (verb)
+    (ferret something out) search tenaciously for and find something: she
+    had the ability to ferret out the facts."
+
+
+                                                               *ferret-features*
+Ferret improves Vim's multi-file search in four ways:
+
+1. Powerful multi-file search ~
+
+Ferret provides an |:Ack| command for searching across multiple files using
+The Silver Searcher (https://github.com/ggreer/the_silver_searcher), Ack
+(http://beyondgrep.com/), or Grep (http://www.gnu.org/software/grep/).
+Support for passing options through to the underlying search command exists,
+along with the ability to use full regular expression syntax without doing
+special escaping.
+
+Shortcut mappings are provided to start an |:Ack| search (<leader>a) or to
+search for the word currently under the cursor (<leader>s).
+
+Results are normally displayed in the |quickfix| window, but Ferret also
+provides a |:Lack| command that behaves like |:Ack| but uses the |location-list|
+instead, and a <leader>l mapping as a shortcut to |:Lack|.
+
+Finally, Ferret offers integration with dispatch.vim
+(https://github.com/tpope/vim-dispatch), which enables asynchronous
+searching despite the fact that Vim itself is single-threaded.
+
+2. Streamlined multi-file replace ~
+
+The companion to |:Ack| is |:Acks| (mnemonic: "Ack substitute", accessible via
+shortcut <leader>r), which allows you to run a multi-file replace across all
+the files placed in the |quickfix| window by a previous invocation of |:Ack|.
+
+3. Quickfix listing enhancements ~
+
+The |quickfix| listing itself is enhanced with settings to improve its
+usability, and natural mappings that allow quick removal of items from the
+list (for example, you can reduce clutter in the listing by removing lines
+that you don't intend to make changes to).
+
+Additionally, Vim's |:cn|, |:cp|, |:cnf| and |:cpf| commands are tweaked to make it
+easier to immediately identify matches by centering them within the viewport.
+
+4. Easy operations on files in the quickfix listing ~
+
+Finally, Ferret provides a |:Qargs| command that puts the files currently in
+the |quickfix| listing into the |:args| list, where they can be operated on in
+bulk via the |:argdo| command. This is what's used under the covers by |:Acks|
+to do its work.
+
+INSTALLATION                                               *ferret-installation*
+
+To install Ferret, use your plug-in management system of choice.
+
+If you don't have a "plug-in management system of choice", I recommend
+Pathogen (https://github.com/tpope/vim-pathogen) due to its simplicity and
+robustness. Assuming that you have Pathogen installed and configured, and
+that you want to install Ferret into `~/.vim/bundle`, you can do so with:
+>
+    git clone https://github.com/wincent/ferret.git ~/.vim/bundle/ferret
+<
+Alternatively, if you use a Git submodule for each Vim plug-in, you could do
+the following after `cd`-ing into the top-level of your Git superproject:
+>
+    git submodule add https://github.com/wincent/ferret.git ~/vim/bundle/ferret
+    git submodule init
+<
+To generate help tags under Pathogen, you can do so from inside Vim with:
+>
+    :call pathogen#helptags()
+<
+OPTIONS                                                         *ferret-options*
+
+COMMANDS                                                       *ferret-commands*
+
+:Ack {pattern} {options}                                                  *:Ack*
+
+Searches for {pattern} in all the files under the current directory (see
+|:pwd|), unless otherwise overridden via {options}, and displays the results
+in the |quickfix| listing.
+
+`ag` (The Silver Searcher) will be used preferentially if present on the
+system, because it is faster, falling back to `ack` and then `grep` as needed.
+
+If dispatch.vim is installed the search process will run asynchronously via
+the |:Make| command, otherwise it will be run synchronously via |:cexpr|.
+Asynchronous searches are preferred because they do not block, despite the
+fact that Vim itself is single threaded. The |g:FerretDispatch| option can be
+used to prevent the use of dispatch.vim.
+
+The {pattern} is passed through as-is to the underlying search program, and
+no escaping is required other than preceding spaces by a single backslash.
+For example, to search for "\bfoo[0-9]{2} bar\b" (ie. using `ag`'s Perl-style
+regular expression syntax), you could do:
+>
+    :Ack \bfoo[0-9]{2}\ bar\b
+<
+Likewise, {options} are passed through. In this example, we pass the `-w`
+option (to search on word boundaries), and scope the search to the "foo" and
+"bar" subdirectories: >
+>
+    :Ack -w something foo bar
+<
+As a convenience <leader>a is set-up (|<Plug>(FerretAck)|) as a shortcut to
+enter |Cmdline-mode| with `:Ack` inserted on the |Cmdline|. Likewise <leader>s
+(|<Plug>(FerretAckWord)|) is a shortcut for running |:Ack| with the word
+currently under the cursor.
+
+:Lack {pattern} {options}                                                *:Lack*
+
+Just like |:Ack|, but instead of using the |quickfix| listing, which is global
+across an entire Vim instance, it uses the |location-list|, which is a
+per-window construct.
+
+Note that |:Lack| always runs synchronously via |:cexpr|, because dispatch.vim
+doesn't currently support the |location-list|.
+
+:Acks /{pattern}/{replacement}/                                          *:Acks*
+
+Takes all of the files currently in the |quickfix| listing and performs a
+substitution of all instances of {pattern} (a standard Vim search |pattern|)
+by {replacement}.
+
+A typical sequence consists of an |:Ack| invocation to populate the |quickfix|
+listing and then |:Acks| (mnemonic: "Ack substitute") to perform replacements.
+For example, to replace "foo" with "bar" across all files in the current
+directory:
+>
+    :Ack foo
+    :Acks /foo/bar/
+<
+:Qargs                                                                  *:Qargs*
+
+This is a utility function that is used by the |:Acks| command but is also
+generally useful enough to warrant being exposed publicly.
+
+It takes the files currently in the |quickfix| listing and sets them as |:args|
+so that they can be operated on en masse via the |:argdo| command.
+
+MAPPINGS                                                       *ferret-mappings*
+
+Circumstances where mappings do not get set up ~
+
+Note that Ferret will not try to set up the <leader> mappings if any of the
+following are true:
+
+- A mapping for already exists.
+- An alternative mapping for the same functionality has already been set up
+  from a |.vimrc|.
+- The mapping has been suppressed by setting |g:FerretMap| to 1 in your |.vimrc|.
+
+Mappings specific to the quickfix window ~
+
+Additionally, Ferret will set up special mappings in |quickfix| listings,
+unless prevented from doing so by |g:FerretQFMap|:
+
+- `d` (|visual-mode|): delete visual selection
+- `dd` (|Normal-mode|): delete current line
+- `d`{motion} (|Normal-mode|): delete range indicated by {motion}
+
+
+                                                             *<Plug>(FerretAck)*
+Ferret maps <leader>a to |<Plug>(FerretAck)|, which triggers the |:Ack| command.
+To use an alternative mapping instead, create a different one in your |.vimrc|
+instead using |:nmap|:
+>
+    " Instead of <leader>a, use <leader>x.
+    nmap <leader>x <Plug>(FerretAck)
+<
+
+                                                            *<Plug>(FerretLack)*
+Ferret maps <leader>l to |<Plug>(FerretLack)|, which triggers the |:Lack|
+command. To use an alternative mapping instead, create a different one in
+your |.vimrc| instead using |:nmap|:
+>
+    " Instead of <leader>l, use <leader>y.
+    nmap <leader>y <Plug>(FerretLack)
+<
+
+                                                         *<Plug>(FerretAckWord)*
+Ferret maps <leader>s (mnemonix: "selection) to |<Plug>(FerretAckWord)|, which
+uses |:Ack| to search for the word currently under the cursor. To use an
+alternative mapping instead, create a different one in your |.vimrc| instead
+using |:nmap|:
+>
+    " Instead of <leader>s, use <leader>z.
+    nmap <leader>z <Plug>(FerretAckWord)
+<
+
+                                                            *<Plug>(FerretAcks)*
+Ferret maps <leader>r (mnemonic: "replace") to |<Plug>(FerretAcks)|, which
+triggers the |:Acks| command and fills the prompt with the last search term
+from Ferret. to use an alternative mapping instead, create a different one
+in your |.vimrc| instead using |:nmap|:
+>
+    " Instead of <leader>r, use <leader>u.
+    nmap <leader>u <Plug>(FerretAcks)
+<
+
+                                                              *g:FerretDispatch*
+|g:FerretDispatch|                                          boolean (default: 1)
+
+Controls whether to use vim-dispatch (and specifically, |:Make|) to run |:Ack|
+searches asynchronously, when available. To prevent vim-dispatch from being
+used, set to 0:
+>
+    let g:FerretDispatch=0
+<
+
+                                                              *g:FerretHlsearch*
+|g:FerretHlsearch|                                       boolean (default: none)
+
+Controls whether Ferret should attempt to highlight the search pattern when
+running |:Ack| or |:Lack|. If left unset, Ferret will respect the current
+'hlsearch' setting. To force highlighting on or off irrespective of
+'hlsearch', set |g:FerretHlsearch| to 1 (on) or 0 (off):
+>
+    let g:FerretHlsearch=0
+<
+
+                                                             *g:FerretQFOptions*
+|g:FerretQFOptions|                                         boolean (default: 1)
+
+Controls whether to set up setting overrides for |quickfix| windows. These are
+various settings, such as |norelativenumber|, |nolist| and |nowrap|, that are
+intended to make the |quickfix| window, which is typically very small relative
+to other windows, more usable.
+
+A full list of overridden settings can be found in |ferret-overrides|.
+
+To prevent the custom settings from being applied, set |g:FerretQFOptions| to
+0:
+>
+    let g:FerretQFOptions=0
+<
+
+                                                                 *g:FerretQFMap*
+|g:FerretQFMap|                                             boolean (default: 1)
+
+Controls whether to set up mappings in the |quickfix| results window for
+deleting results. The mappings include:
+
+- `d` (|visual-mode|): delete visual selection
+- `dd` (|Normal-mode|): delete current line
+- `d`{motion} (|Normal-mode|): delete range indicated by {motion}
+
+To prevent these mappings from being set up, set to 0:
+>
+    let g:FerretQFMap=0
+<
+
+                                                                *g:FerretLoaded*
+|g:FerretLoaded|                                             any (default: none)
+
+To prevent Ferret from being loaded, set |g:FerretLoaded| to any value in your
+|.vimrc|. For example:
+>
+    let g:FerretLoaded=1
+<
+
+                                                                   *g:FerretMap*
+|g:FerretMap|                                               boolean (default: 1)
+
+Controls whether to set up the Ferret mappings, such as |<Plug>(FerretAck)|
+(see |ferret-mappings| for a full list). To prevent any mapping from being
+configured, set to 0:
+>
+    let g:FerretMap=0
+<
+
+                                                            *g:FerretQFCommands*
+|g:FerretQFCommands|                                        boolean (default: 1)
+
+Controls whether to set up custom versions of the |quickfix| commands, |:cn|,
+|:cnf|, |:cp| an |:cpf|. These overrides vertically center the match within the
+viewport on each jump. To prevent the custom versions from being configured,
+set to 0:
+>
+    let g:FerretQFCommands=0
+<
+CUSTOM AUTOCOMMANDS                                 *ferret-custom-autocommands*
+
+
+                                                *FerretDidWrite* *FerretWillWrite*
+For maximum compatibility with other plug-ins, Ferret runs the following
+"User" autocommands before and after running the file writing operations
+during |:Acks|:
+
+- FerretWillWrite
+- FerretDidWrite
+
+For example, to call a pair of custom functions in response to these events,
+you might do:
+>
+    autocmd! User FerretWillWrite
+    autocmd User FerretWillWrite call CustomWillWrite()
+    autocmd! User FerretDidWrite
+    autocmd User FerretDidWrite call CustomDidWrite()
+<
+OVERRIDES                                                     *ferret-overrides*
+
+Ferret overrides the 'grepformat' and 'grepprg' settings, preferentially
+setting `ag`, `ack` or `grep` as the 'grepprg' (in that order) and configuring a
+suitable 'grepformat'.
+
+Additionally, Ferret includes an |ftplugin| for the |quickfix| listing that
+adjusts a number of settings to improve the usability of search results.
+
+
+                                                                 *ferret-nolist*
+'nolist'
+
+Turned off to reduce visual clutter in the search results, and because
+'list' is most useful in files that are being actively edited, which is not
+the case for |quickfix| results.
+
+
+                                                       *ferret-norelativenumber*
+'norelativenumber'
+
+Turned off, because it is more useful to have a sense of absolute progress
+through the results list than to have the ability to jump to nearby results
+(especially seeing as the most common operations are moving to the next or
+previous file, which are both handled nicely by |:cnf| and |:cpf| respectively).
+
+
+                                                                 *ferret-nowrap*
+'nowrap'
+
+Turned off to avoid ugly wrapping that makes the results list hard to read,
+and because in search results, the most relevant information is the
+filename, which is on the left and is usually visible even without wrapping.
+
+
+                                                                 *ferret-number*
+'number'
+
+Turned on to give a sense of absolute progress through the results.
+
+
+                                                              *ferret-scrolloff*
+'scrolloff'
+
+Set to 0 because the |quickfix| listing is usually small by default, so trying
+to keep the current line away from the edge of the viewpoint is futile; by
+definition it is usually near the edge.
+
+
+                                                           *ferret-nocursorline*
+'nocursorline'
+
+Turned off to reduce visual clutter.
+
+To prevent any of these |quickfix|-specific overrides from being set up, you
+can set |g:FerretQFOptions| to 0 in your |.vimrc|:
+>
+    let g:FerretQFOptions=0
+<
+TROUBLESHOOTING                                         *ferret-troubleshooting*
+
+
+                                                                 *ferret-quotes*
+Ferret fails to find patterns containing spaces ~
+
+As described in the documentation for |:Ack|, the search pattern is passed
+through as-is to the underlying search command, and no escaping is required
+other than preceding spaces by a single backslash.
+
+So, to find "foo bar", you would search like:
+>
+    :Ack foo\ bar
+<
+Unescaped spaces in the search are treated as argument separators, so a
+command like the following means pass the `-w` option through, search for
+pattern "foo", and limit search to the "bar" directory:
+>
+    :Ack -w foo bar
+<
+Note that including quotes will not do what you intend.
+>
+     " Search for '"foo' in the 'bar"' directory:
+     :Ack "foo bar"
+
+     " Search for "'foo' in the "bar'" directory:
+     :Ack 'foo bar'
+<
+This approach to escaping is taken in order to make it straightfoward to use
+powerful Perl-compatible regular expression syntax in an unambiguous way
+without having to worry about shell escaping rules:
+>
+    :Ack \blog\((['"]).*?\1\) -i --ignore-dir=src/vendor src dist build
+<
+FAQ                                                                 *ferret-faq*
+
+Why do Ferret commands start with "Ack", "Lack" and so on? ~
+
+Ferret was originally the thinnest of wrappers (7 lines of code in my
+|.vimrc|) around `ack`. The earliest traces of it can be seen in the initial
+commit to my dotfiles repo in May, 2009 (https://wt.pe/h).
+
+So, even though Ferret has a new name now and actually prefers `ag` over `ack`
+when available, I prefer to keep the command names intact and benefit from
+years of accumulated muscle-memory.
+
+RELATED                                                         *ferret-related*
+
+Just as Ferret aims to improve the multi-file search and replace experience,
+Loupe does the same for within-file searching:
+
+https://github.com/wincent/loupe
+
+WEBSITE                                                         *ferret-website*
+
+The official Ferret source code repo is at:
+
+http://git.wincent.com/ferret.git
+
+A mirror exists at:
+
+https://github.com/wincent/ferret
+
+Official releases are listed at:
+
+http://www.vim.org/scripts/script.php?script_id=5220
+
+LICENSE                                                         *ferret-license*
+
+Copyright 2015-present Greg Hurrell. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+DEVELOPMENT                                                 *ferret-development*
+
+Contributing patches ~
+
+Patches can be sent via mail to greg@hurrell.net, or as GitHub pull requests
+at: https://github.com/wincent/ferret/pulls
+
+Cutting a new release ~
+
+At the moment the release process is manual:
+
+- Perform final sanity checks and manual testing
+- Update the |ferret-history| section of the documentation
+- Verify clean work tree:
+>
+    git status
+<
+- Tag the release:
+>
+    git tag -s -m "$VERSION release" $VERSION
+<
+- Publish the code:
+>
+    git push origin master --follow-tags
+    git push github master --follow-tags
+<
+- Produce the release archive:
+>
+    git archive -o ferret-$VERSION.zip HEAD -- .
+<
+- Upload to http://www.vim.org/scripts/script.php?script_id=5220
+
+AUTHORS                                                         *ferret-authors*
+
+Ferret is written and maintained by Greg Hurrell <greg@hurrell.net>.
+
+The idea for vim-dispatch integration was taken from Miles Sterrett's
+ack.vim plug-in (https://github.com/mileszs/ack.vim).
+
+Other contributors that have submitted patches include (in alphabetical
+order):
+
+- Daniel Silva
+- Joe Lencioni
+- Nelo-Thara Wallus
+- Vaibhav Sagar
+
+HISTORY                                                         *ferret-history*
+
+1.2a (16 May 2016) ~
+
+- Add optional support for running searches asynchronously using Vim's |+job|
+  feature (enabled by default in sufficiently recent versions of Vim); see
+  |g:FerretJob|, |:FerretCancelAsync| and |:FerretPullAsync|.
+
+1.1.1 (7 March 2016) ~
+
+- Fix another edge case when searching for patterns containing "#", only
+  manifesting under dispatch.vim.
+
+1.1 (7 March 2016) ~
+
+- Fix edge case when searching for strings of the form "<foo>".
+- Fix edge case when searching for patterns containing "#" and "%".
+- Provide completion for `ag` and `ack` options when using |:Ack| and |:Lack|.
+- Fix display of error messages under dispatch.vim.
+
+1.0 (28 December 2015) ~
+
+- Fix broken |:Qargs| command (patch from Daniel Silva).
+- Add |g:FerretQFHandler| and |g:FerretLLHandler| options (patch from Daniel
+  Silva).
+- Make |<Plug>| mappings accessible even |g:FerretMap| is set to 0.
+- Fix failure to report filename when using `ack` and explicitly scoping
+  search to a single file (patch from Daniel Silva).
+- When using `ag`, report multiple matches per line instead of just the first
+  (patch from Daniel Silva).
+- Improve content and display of error messages.
+
+0.3 (24 July 2015) ~
+
+- Added highlighting of search pattern and related |g:FerretHlsearch| option
+  (patch from Nelo-Thara Wallus).
+- Add better error reporting for failed or incorrect searches.
+
+0.2 (16 July 2015) ~
+
+- Added |FerretDidWrite| and |FerretWillWrite| autocommands (patch from Joe
+  Lencioni).
+- Add |<Plug>(FerretAcks)| mapping (patch from Nelo-Thara Wallus).
+
+0.1 (8 July 2015) ~
+
+- Initial release, extracted from my dotfiles
+  (https://github.com/wincent/wincent).
diff --git a/tests/fixtures/integration/scalpel/golden/plaintext.golden b/tests/fixtures/integration/scalpel/golden/plaintext.golden
new file mode 100644 (file)
index 0000000..61b8e9d
--- /dev/null
@@ -0,0 +1,182 @@
+*scalpel.txt*    Scalpel plug-in for Vim      *scalpel*
+
+CONTENTS                                                      *scalpel-contents*
+
+1. Intro            |scalpel-intro|
+2. Installation     |scalpel-installation|
+3. Website          |scalpel-website|
+4. License          |scalpel-license|
+5. Development      |scalpel-development|
+6. Authors          |scalpel-authors|
+7. History          |scalpel-history|
+
+INTRO                                                            *scalpel-intro*
+
+Scalpel provides a streamlined shortcut for replacing all instances of the
+word currently under the cursor throughout a file.
+
+In normal mode pressing `<Leader>e` (mnemonic: "edit") will display a prompt
+pre-populated with the current word and with the cursor placed so that you
+can start typing the desired replacement:
+>
+    :Scalpel/\v<foo>//
+<
+Press `<Enter>` and Scalpel will prompt to confirm each substitution, starting
+at the current word (unlike a normal `:%s` command, which starts at the top of
+the file).
+
+Scalpel works similarly in visual mode, except that it scopes itself to the
+current visual selection rather than operating over the entire file.
+
+Note that `:Scalpel` just calls through to an underlying `scalpel#substitute`
+function that does the real work, ultimately calling Vim's own `:substitute`.
+As such, be aware that whatever changes you make to the command-line prior
+to pressing `<Enter>` must keep it a valid pattern, or bad things will happen.
+
+The mapping can be suppressed by setting:
+>
+    let g:ScalpelMap=0
+<
+Or overridden:
+>
+    " Use <Leader>s instead of default <Leader>e:
+    nmap <Leader>s <Plug>(Scalpel)
+<
+In any case, Scalpel won't overwrite any pre-existing mapping that you might
+have defined for `<Leader>e`, nor will it create an unnecessary redundant
+mapping if you've already mapped something to `<Plug>(Scalpel)`.
+
+The `:Scalpel` command name can be overridden if desired. For example, you
+could shorten it to `:S` with:
+>
+    let g:ScalpelCommand='S'
+<
+Then your Scalpel prompt would look like:
+>
+    :S/\v<foo>//
+<
+The command can be entirely suppressed by setting `g:ScalpelCommand` to an
+empty string:
+>
+    let g:ScalpelCommand=''
+<
+Finally, all plug-in functionality can be deactivated by setting:
+>
+    let g:ScalpelLoaded=1
+<
+in your `~/.vimrc`.
+
+INSTALLATION                                              *scalpel-installation*
+
+To install Scalpel, use your plug-in management system of choice.
+
+If you don't have a "plug-in management system of choice" and your version
+of Vim has `packages` support (ie. `+packages` appears in the output of
+`:version`) then you can simply place the plugin at a location under your
+`'packpath'` (eg. `~/.vim/pack/bundle/start/scalpel` or similar).
+
+For older versions of Vim, I recommend
+[Pathogen](https://github.com/tpope/vim-pathogen) due to its simplicity and
+robustness. Assuming that you have Pathogen installed and configured, and
+that you want to install Scalpel into `~/.vim/bundle`, you can do so with:
+>
+    git clone https://github.com/wincent/scalpel.git ~/.vim/bundle/scalpel
+<
+Alternatively, if you use a Git submodule for each Vim plug-in, you could do
+the following after `cd`-ing into the top-level of your Git superproject:
+>
+    git submodule add https://github.com/wincent/scalpel.git ~/vim/bundle/scalpel
+    git submodule init
+<
+To generate help tags under Pathogen, you can do so from inside Vim with:
+>
+    :call pathogen#helptags()
+<
+WEBSITE                                                        *scalpel-website*
+
+The official Scalpel source code repo is at:
+
+http://git.wincent.com/scalpel.git
+
+Mirrors exist at:
+
+- https://github.com/wincent/scalpel
+- https://gitlab.com/wincent/scalpel
+- https://bitbucket.org/ghurrell/scalpel
+
+Official releases are listed at:
+
+http://www.vim.org/scripts/script.php?script_id=5381
+
+LICENSE                                                        *scalpel-license*
+
+Copyright (c) 2016-present Greg Hurrell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.
+
+DEVELOPMENT                                                *scalpel-development*
+
+Contributing patches ~
+
+Patches can be sent via mail to greg@hurrell.net, or as GitHub pull requests
+at: https://github.com/wincent/scalpel/pulls
+
+Cutting a new release ~
+
+At the moment the release process is manual:
+
+- Perform final sanity checks and manual testing.
+- Update the [scalpel-history](#user-content-scalpel-history) section of the
+  documentation.
+- Regenerate the documentation:
+>
+    docvim README.md doc/scalpel.txt
+<
+- Verify clean work tree:
+>
+    git status
+<
+- Tag the release:
+>
+    git tag -s -m "$VERSION release" $VERSION
+<
+- Publish the code:
+>
+    git push origin master --follow-tags
+    git push github master --follow-tags
+<
+- Produce the release archive:
+>
+    git archive -o scalpel-$VERSION.zip HEAD -- .
+<
+- Upload to http://www.vim.org/scripts/script.php?script_id=5381
+
+AUTHORS                                                        *scalpel-authors*
+
+Scalpel is written and maintained by Greg Hurrell <greg@hurrell.net>.
+
+HISTORY                                                        *scalpel-history*
+
+0.2 (not yet released) ~
+
+- Support visual mode.
+
+0.1 (29 April 2016) ~
+
+- Initial release.
index efa483ed3f111f3cb0f216755507f7059f4475a3..2369070078e60def104e0f728e5d38512e327ea3 100644 (file)
@@ -112,23 +112,43 @@ goldenTests description sources transform = testGroup groupName $ do
     groupName = "Golden " ++ description ++ " tests"
 
 integrationTests :: [FilePath] -> TestTree
-integrationTests sources = testGroup "Integration tests" $ do
-  source <- sources -- list monad
-  let
-    markdown = do
-      inputs <- getFixtures $ source </> "input"
-      contents <- mapM readFile inputs
-      return $ pack $ normalize $ pm contents
-    name = takeBaseName source
-    golden = "tests/fixtures/integration" </> (takeBaseName source) </> "golden/markdown.golden"
-    diff ref new = [ "git"
-                   , "diff"
-                   , "--color"
-                   , "--diff-algorithm=histogram"
-                   , ref
-                   , new
-                   ]
-  return $ goldenVsStringDiff' name diff golden markdown
+integrationTests sources = testGroup "Integration tests" $
+    concat [m, v]
+  where
+    m = do
+      source <- sources -- list monad
+      let
+        markdown = do
+          inputs <- getFixtures $ source </> "input"
+          contents <- mapM readFile inputs
+          return $ pack $ normalize $ pm contents
+        name = takeBaseName source
+        golden = "tests/fixtures/integration" </> (takeBaseName source) </> "golden/markdown.golden"
+        diff ref new = [ "git"
+                      , "diff"
+                      , "--color"
+                      , "--diff-algorithm=histogram"
+                      , ref
+                      , new
+                      ]
+      return $ goldenVsStringDiff' (name ++ " (Markdown)") diff golden markdown
+    v = do
+      source <- sources -- list monad
+      let
+        help = do
+          inputs <- getFixtures $ source </> "input"
+          contents <- mapM readFile inputs
+          return $ pack $ normalize $ pv contents
+        name = takeBaseName source
+        golden = "tests/fixtures/integration" </> (takeBaseName source) </> "golden/plaintext.golden"
+        diff ref new = [ "git"
+                      , "diff"
+                      , "--color"
+                      , "--diff-algorithm=histogram"
+                      , ref
+                      , new
+                      ]
+      return $ goldenVsStringDiff' (name ++ " (Vim help)") diff golden help
 
 -- | Normalize a string to always end with a newline, unless zero-length, to
 -- match standard text editor behavior.