dsf.txt

*dsf.txt*	Delete surrounding function call

==============================================================================
CONTENTS                                                    *dsf*   *dsf-contents*

    Installation................................: |dsf-installation|
    Usage.......................................: |dsf-usage|
    Settings....................................: |dsf-settings|
    Issues......................................: |dsf-issues|


==============================================================================
INSTALLATION                                                  *dsf-installation*

The easiest way to install the plugin is with a plugin manager:

- vim-plug: https://github.com/junegunn/vim-plug
- Vundle:   https://github.com/VundleVim/Vundle.vim

If you use one, just follow the instructions in its documentation.

You can install the plugin yourself using Vim's |packages| functionality by
cloning the project (or adding it as a submodule) under
`~/.vim/pack/<any-name>/start/`. For example:
>
    git clone https://github.com/AndrewRadev/dsf.vim ~/.vim/pack/_/start/dsf
<
This should automatically load the plugin for you on Vim start. Alternatively,
you can add it to `~/.vim/pack/<any-name>/opt/` instead and load it in your
.vimrc manually with:
>
    packadd dsf
<
If you'd rather not use git, you can download the files from the "releases"
tab and unzip them in the relevant directory:
https://github.com/AndrewRadev/dsf.vim/releases.


==============================================================================
USAGE                                                                *dsf-usage*

The plugin defines a mapping to delete a surrounding function call (or
something similar to one), even if it happens to be namespaced. Some examples:
>
    nested(function_call(cursor_here))   -> nested(cursor_here)
    nested(cursor_here(chewy_center))    -> cursor_here(chewy_center)
    One::Two.new([cursor_here])          -> [cursor_here]
    One::Two.new(Hash[cursor_here])      -> One::Two.new(cursor_here)
    SomeStruct{cursor_here: "Something"} -> cursor_here: "Something"
<
By pressing `dsf` (which stands for "delete surrounding function call") with
the cursor on `cursor_here`, you get the result on the right.

More mappings ~

The plugin defines `csf` to "change surrounding function call", which deletes
only the function itself and leaves the cursor waiting to enter a new name.

For convenience, the `dsnf` (the "n" standing for "next") mapping will look
for a function call after the cursor to delete:
>
    var result = function_call(foo, bar(baz));
    // With the cursor on "foo", pressing dsnf results in:
    var result = function_call(foo, baz);
<
Text objects ~

The text objects for `if` and `af` manipulate function calls with their
contents. Given this example:
>
    var result = function_call(one, two);
<
Typing `daf` ("a function call") with the cursor anywhere on
`function_call(one, two)` would result in:
>
    var result = ;
<
Typing `dif` ("inner function call") with the cursor anywhere on
`function_call(one, two)` would result in:
>
    var result = function_call();
<
To learn more about how text objects work, try the `:help` for |text-objects|.

Multiline ~

The plugin also works on multiline function calls, for example:
>
    foo = one(
      two
    )

    foo = two
<
The insides of the function will be automatically indented using the |=|
operator to compensate for any potential changes in indentation level.

Customization ~

If you'd like to set your own mappings, instead of using the built-ins, simply
set the variable `g:dsf_no_mappings` to `1` and use the <Plug> mappings
provided by the plugin:
>
    let g:dsf_no_mappings = 1

    nmap dsf <Plug>DsfDelete
    nmap csf <Plug>DsfChange

    nmap dsnf <Plug>DsfNextDelete
    nmap csnf <Plug>DsfNextChange

    omap af <Plug>DsfTextObjectA
    xmap af <Plug>DsfTextObjectA
    omap if <Plug>DsfTextObjectI
    xmap if <Plug>DsfTextObjectI
<
Change any of the left-hand sides of the `map` calls to whatever you'd like,
or remove lines to leave them unset.

For additional settings check the below section, |dsf-settings|.


==============================================================================
SETTINGS                                                          *dsf-settings*

                                                             *g:dsf_no_mappings*
>
    let g:dsf_no_mappings = 1
<

Default value: 0

If you set this variable to 1, the plugin will not define any default
mappings. You'll still have the <Plug> maps provided to you that you can map
any keys you want to. Check |dsf-usage| for details on that.

                                                                *g:dsf_brackets*
>
    let g:dsf_brackets = '('
<

Default value: '([{'

You can change this value to determine what brackets identify a "function
call". While in most languages, only "(" is used for those, a useful (even if
technically incorrect) interpretation of "function call" might include things
like `Hash[*some_list]` in ruby, or `SomeStruct{with: "values"}` in go. This
is why the plugin, by default, considers "([{" as brackets.

If you'd like to avoid this, so you don't accidentally delete structs or
something, set this to whatever opening brackets you'd like to detect.

Note that this can be changed per-buffer by setting `b:dsf_brackets`.

                                                        *g:dsf_function_pattern*
>
    let g:dsf_function_pattern = '\k\+'
<

Default value: '\k\+[?!]\='

The function pattern determines what will be identified as a function name.
This should not include the opening bracket. Usually, a keyword character will
do the trick, but the default also adds some extra characters allowed at the
end to cover special cases for ruby.

The pattern is a Vim regex, if you need more information on those, check the
:help on |pattern-overview|.

Note that this can be changed per-buffer by setting `b:dsf_function_pattern`.

                                                       *g:dsf_namespace_pattern*
>
    let g:dsf_namespace_pattern = '\k\+::'
<

Default value: '\k\+\%(\.\|::\|:\|#\)'

The namespace pattern determines what will be identified as a namespace that
prefixes a function. This will likely be a set of keyword characters, followed
by something like "::", ".", depending on the language. The default includes a
set of characters that cover a few languages.

If you'd like to NOT cover namespaces at all, and just manipulate the function
name, set it to the empty string:
>
    let g:namespace_pattern = ''
<
This might allow you, to, for example, easily change the function call with
`csf` to a different one in the same module/package.

The pattern is a Vim regex, if you need more information on those, check the
:help on |pattern-overview|.

Note that this can be changed per-buffer by setting `b:dsf_namespace_pattern`.

                                                  *g:dsf_latex_special_handling*
>
    let g:dsf_latex_special_handling = 0
<
Default value: 1

In a latex file, an expression like `\frac{dY}{dt}` is going to be treated as
a "function", though only with the cursor in the first pair of brackets. The
second pair of brackets will end up being left over in the case of a deletion.

This variable controls whether the plugin will attempt to also delete the
second pair of brackets. It's on by default, but it can be turned off in case
it causes trouble. It's only on when the filetype is `tex`, so if you want
support for other filetypes or find any problems, please open an issue.


==============================================================================
ISSUES                                                              *dsf-issues*

Any issues and suggestions are very welcome on the github bugtracker:
https://github.com/AndrewRadev/dsf.vim/issues


vim:tw=78:sw=4:ft=help:norl: