kevin/neovim
1
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2024-12-29 14:41:06 -07:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #14687 from kabouzeid/vim-docs

Browse Source 
Updated vim docs
This commit is contained in:
Michael Lingelbach 2021-05-31 11:27:58 -07:00 committed by GitHub
commit 0866df4d6a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 189 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
runtime/doc/api.txt
View File

@ -993,7 +993,7 @@ nvim_get_option_info({name}) *nvim_get_option_info()*
Resulting dictionary has keys:
• name: Name of the option (like 'filetype')
• shortname: Shortened name of the option (like 'ft')
• type: type of option ("string", "integer" or "boolean")
• type: type of option ("string", "number" or "boolean")
• default: The default value for the option
• was_set: Whether the option was set.
• last_set_sid: Last set script id (if any)
@ -1299,6 +1299,17 @@ nvim_open_win({buffer}, {enter}, {config}) *nvim_open_win()*
an external top-level window. Currently
accepts no other positioning configuration
together with this.
• `zindex`: Stacking order. floats with higher`zindex`go on top on floats with lower indices. Must
be larger than zero. The following screen
elements have hard-coded z-indices:
• 100: insert completion popupmenu
• 200: message scrollback
• 250: cmdline completion popupmenu (when
wildoptions+=pum) The default value for
floats are 50. In general, values below 100
are recommended, unless there is a good
reason to overshadow builtin elements.
• `style`: Configure the appearance of the window.
Currently only takes one non-empty value:
• "minimal" Nvim will display the window with
@ -1705,6 +1716,12 @@ nvim_set_hl({ns_id}, {name}, {val}) *nvim_set_hl()*
|nvim_get_hl_by_name|. in addition the following
keys are also recognized: `default` : don't
override existing definition, like `hi default`
`ctermfg` : sets foreground of cterm color
`ctermbg` : sets background of cterm color
`cterm` : cterm attribute map. sets attributed
for cterm colors. similer to `hi cterm` Note: by
default cterm attributes are same as attributes
of gui color
nvim_set_keymap({mode}, {lhs}, {rhs}, {opts}) *nvim_set_keymap()*
Sets a global |mapping| for the given mode.
@ -2269,7 +2286,12 @@ nvim_buf_set_extmark({buffer}, {ns_id}, {line}, {col}, {opts})
• "overlay": display over the specified
column, without shifting the underlying
text.
• "right_align": display right aligned in the
window.
• virt_text_win_col : position the virtual text
at a fixed window column (starting from the
first text column)
• virt_text_hide : hide the virtual text when
the background text is selected or hidden due
to horizontal scroll 'nowrap'

155
runtime/doc/lsp.txt
View File

@ -619,15 +619,15 @@ buf_request_sync({bufnr}, {method}, {params}, {timeout_ms})
Calls |vim.lsp.buf_request_all()| but blocks Nvim while
awaiting the result. Parameters are the same as
|vim.lsp.buf_request()| but the return result is different.
Wait maximum of {timeout_ms} (default 100) ms.
Wait maximum of {timeout_ms} (default 1000) ms.
Parameters: ~
{bufnr} (number) Buffer handle, or 0 for current.
{method} (string) LSP method name
{params} (optional, table) Parameters to send to the
server
{timeout_ms} (optional, number, default=100) Maximum time
in milliseconds to wait for a result.
{timeout_ms} (optional, number, default=1000) Maximum
time in milliseconds to wait for a result.
Return: ~
Map of client_id:request_result. On timeout, cancel or
@ -651,6 +651,14 @@ client() *vim.lsp.client*
{status} is `true` , the function returns {request_id} as
the second result. You can use this with
`client.cancel_request(request_id)` to cancel the request.
• request_sync(method, params, timeout_ms, bufnr) Sends a
request to the server and synchronously waits for the
response. This is a wrapper around {client.request}
Returns: { err=err, result=result }, a dictionary, where
`err` and `result` come from the |lsp-handler|. On
timeout, cancel or error, returns `(nil, err)` where `err`
is a string describing the failure reason. If the request
was unsuccessful returns `nil` .
• notify(method, params) Sends a notification to an LSP
server. Returns: a boolean to indicate if the notification
was successful. If it is false, then it will always be
@ -939,6 +947,9 @@ add_workspace_folder({workspace_folder})
not provided, the user will be prompted for a path using
|input()|.
call_hierarchy({method}) *vim.lsp.buf.call_hierarchy()*
TODO: Documentation
clear_references() *vim.lsp.buf.clear_references()*
Removes document highlights from current buffer.
@ -1017,6 +1028,32 @@ formatting({options}) *vim.lsp.buf.formatting()*
See also: ~
https://microsoft.github.io/language-server-protocol/specification#textDocument_formatting
*vim.lsp.buf.formatting_seq_sync()*
formatting_seq_sync({options}, {timeout_ms}, {order})
Formats the current buffer by sequentially requesting
formatting from attached clients.
Useful when multiple clients with formatting capability are
attached.
Since it's synchronous, can be used for running on save, to
make sure buffer is formatted prior to being saved.
{timeout_ms} is passed on to the |vim.lsp.client| `request_sync` method. Example: >
vim.api.nvim_command[[autocmd BufWritePre <buffer> lua vim.lsp.buf.formatting_seq_sync()]]
<
Parameters: ~
{options} (optional, table) `FormattingOptions`
entries
{timeout_ms} (optional, number) Request timeout
{order} (optional, table) List of client names.
Formatting is requested from clients in the
following order: first all clients that are
not in the `order` list, then the remaining
clients in the order as they occur in the
`order` list.
*vim.lsp.buf.formatting_sync()*
formatting_sync({options}, {timeout_ms})
Performs |vim.lsp.buf.formatting()| synchronously.
@ -1033,6 +1070,9 @@ formatting_sync({options}, {timeout_ms})
{options} Table with valid `FormattingOptions` entries
{timeout_ms} (number) Request timeout
See also: ~
|vim.lsp.buf.formatting_seq_sync|
hover() *vim.lsp.buf.hover()*
Displays hover information about the symbol under the cursor
in a floating window. Calling the function twice will jump
@ -1650,12 +1690,15 @@ convert_input_to_markdown_lines({input}, {contents})
https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_hover
*vim.lsp.util.convert_signature_help_to_markdown_lines()*
convert_signature_help_to_markdown_lines({signature_help})
convert_signature_help_to_markdown_lines({signature_help}, {ft})
Converts `textDocument/SignatureHelp` response to markdown
lines.
Parameters: ~
{signature_help} Response of `textDocument/SignatureHelp`
{ft} optional filetype that will be use as
the `lang` for the label markdown code
block
Return: ~
list of lines of converted markdown.
@ -1683,65 +1726,6 @@ extract_completion_items({result})
See also: ~
https://microsoft.github.io/language-server-protocol/specification#textDocument_completion
*vim.lsp.util.fancy_floating_markdown()*
fancy_floating_markdown({contents}, {opts})
Converts markdown into syntax highlighted regions by stripping
the code blocks and converting them into highlighted code.
This will by default insert a blank line separator after those
code block regions to improve readability. The result is shown
in a floating preview.
Parameters: ~
{contents} table of lines to show in window
{opts} dictionary with optional fields
• height of floating window
• width of floating window
• wrap_at character to wrap at for computing
height
• max_width maximal width of floating window
• max_height maximal height of floating window
• pad_left number of columns to pad contents
at left
• pad_right number of columns to pad contents
at right
• pad_top number of lines to pad contents at
top
• pad_bottom number of lines to pad contents
at bottom
• separator insert separator after code block
Return: ~
width,height size of float
focusable_float({unique_name}, {fn}) *vim.lsp.util.focusable_float()*
Parameters: ~
{unique_name} (string) Window variable
{fn} (function) should return create a new
window and return a tuple of
({focusable_buffer_id}, {window_id}). if
{focusable_buffer_id} is a valid buffer id,
the newly created window will be the new
focus associated with the current buffer
via the tag `unique_name` .
Return: ~
(pbufnr, pwinnr) if `fn()` has created a new window; nil
otherwise
*vim.lsp.util.focusable_preview()*
focusable_preview({unique_name}, {fn})
Focuses/unfocuses the floating preview window associated with
the current buffer via the window variable `unique_name` . If
no such preview window exists, makes a new one.
Parameters: ~
{unique_name} (string) Window variable
{fn} (function) The return values of this
function will be passed directly to
|vim.lsp.util.open_floating_preview()|, in
the case that a new floating window should
be created
get_effective_tabstop({bufnr}) *vim.lsp.util.get_effective_tabstop()*
Returns visual width of tabstop.
@ -1755,6 +1739,14 @@ get_effective_tabstop({bufnr}) *vim.lsp.util.get_effective_tabstop()*
See also: ~
|softtabstop|
get_line({uri}, {row}) *vim.lsp.util.get_line()*
Parameters: ~
{uri} string uri of the resource to get the line from
{row} number zero-indexed line number
Return: ~
string the line at row in filename
get_progress_messages() *vim.lsp.util.get_progress_messages()*
TODO: Documentation
@ -1897,7 +1889,7 @@ parse_snippet({input}) *vim.lsp.util.parse_snippet()*
Return: ~
(string) parsed snippet
preview_location({location}) *vim.lsp.util.preview_location()*
preview_location({location}, {opts}) *vim.lsp.util.preview_location()*
Previews a location in a floating window
behavior depends on type of location:
@ -1946,6 +1938,41 @@ set_qflist({items}) *vim.lsp.util.set_qflist()*
Parameters: ~
{items} (table) list of items
*vim.lsp.util.stylize_markdown()*
stylize_markdown({bufnr}, {contents}, {opts})
Converts markdown into syntax highlighted regions by stripping
the code blocks and converting them into highlighted code.
This will by default insert a blank line separator after those
code block regions to improve readability.
This method configures the given buffer and returns the lines
to set.
If you want to open a popup with fancy markdown, use
`open_floating_preview` instead
Parameters: ~
{contents} table of lines to show in window
{opts} dictionary with optional fields
• height of floating window
• width of floating window
• wrap_at character to wrap at for computing
height
• max_width maximal width of floating window
• max_height maximal height of floating window
• pad_left number of columns to pad contents
at left
• pad_right number of columns to pad contents
at right
• pad_top number of lines to pad contents at
top
• pad_bottom number of lines to pad contents
at bottom
• separator insert separator after code block
Return: ~
width,height size of float
symbols_to_items({symbols}, {bufnr}) *vim.lsp.util.symbols_to_items()*
Converts symbols to quickfix list items.

76
runtime/doc/lua.txt
View File

@ -1118,6 +1118,23 @@ vim.wo *vim.wo*
==============================================================================
Lua module: vim *lua-vim*
defer_fn({fn}, {timeout}) *vim.defer_fn()*
Defers calling `fn` until `timeout` ms passes.
Use to do a one-shot timer that calls `fn` Note: The {fn} is |schedule_wrap|ped automatically, so API
functions are safe to call.
Parameters: ~
{fn} Callback to call once `timeout` expires
{timeout} Number of milliseconds to wait before calling
`fn`
Return: ~
timer luv timer object
insert_keys({obj}) *vim.insert_keys()*
TODO: Documentation
inspect({object}, {options}) *vim.inspect()*
Return a human-readable representation of the given object.
@ -1125,9 +1142,19 @@ inspect({object}, {options}) *vim.inspect()*
https://github.com/kikito/inspect.lua
https://github.com/mpeterv/vinspect
make_meta_accessor({get}, {set}, {del}) *vim.make_meta_accessor()*
make_dict_accessor({scope}) *vim.make_dict_accessor()*
TODO: Documentation
notify({msg}, {log_level}, {_opts}) *vim.notify()*
Notification provider without a runtime, writes to :Messages
Parameters: ~
{msg} Content of the notification to show to the
user
{log_level} Optional log level
{opts} Dictionary with optional options (timeout,
etc)
paste({lines}, {phase}) *vim.paste()*
Paste handler, invoked by |nvim_paste()| when a conforming UI
(such as the |TUI|) pastes text into the editor.
@ -1160,6 +1187,53 @@ paste({lines}, {phase}) *vim.paste()*
See also: ~
|paste|
region({bufnr}, {pos1}, {pos2}, {regtype}, {inclusive}) *vim.region()*
Get a table of lines with start, end columns for a region
marked by two points
Parameters: ~
{bufnr} number of buffer
{pos1} (line, column) tuple marking beginning of
region
{pos2} (line, column) tuple marking end of region
{regtype} type of selection (:help setreg)
{inclusive} boolean indicating whether the selection is
end-inclusive
Return: ~
region lua table of the form {linenr = {startcol,endcol}}
*vim.register_keystroke_callback()*
register_keystroke_callback({fn}, {ns_id})
Register a lua {fn} with an {id} to be run after every
keystroke.
If {fn} is nil, it removes the callback for the associated
{ns_id}
Note:
{fn} will not be cleared from |nvim_buf_clear_namespace()|
Note:
{fn} will receive the keystrokes after mappings have been
evaluated
Parameters: ~
{fn} function: Function to call. It should take one
argument, which is a string. The string will contain
the literal keys typed. See |i_CTRL-V|
{ns_id} number? Namespace ID. If not passed or 0, will
generate and return a new namespace ID from
|nvim_create_namesapce()|
Return: ~
number Namespace ID associated with {fn}
Note:
{fn} will be automatically removed if an error occurs
while calling. This is to prevent the annoying situation
of every keystroke erroring while trying to remove a
broken callback.
schedule_wrap({cb}) *vim.schedule_wrap()*
Defers callback `cb` until the Nvim API is safe to call.