Skip to content

feat: use external nio #311

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Mar 18, 2024
Merged

feat: use external nio #311

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 4 additions & 2 deletions README.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9,26 +9,28 @@ good out of the box configuration.

## Installation

Install with your favourite package manager alongside nvim-dap
Install with your favourite package manager alongside nvim-dap and nvim-nio

[**dein**](https://github.com/Shougo/dein.vim):

```vim
call dein#add("mfussenegger/nvim-dap")
call dein#add("nvim-neotest/nvim-nio")
call dein#add("rcarriga/nvim-dap-ui")
```

[**vim-plug**](https://github.com/junegunn/vim-plug)

```vim
Plug 'mfussenegger/nvim-dap'
Plug 'nvim-neotest/nvim-nio'
Plug 'rcarriga/nvim-dap-ui'
```

[**packer.nvim**](https://github.com/wbthomason/packer.nvim)

```lua
use { "rcarriga/nvim-dap-ui", requires = {"mfussenegger/nvim-dap"} }
use { "rcarriga/nvim-dap-ui", requires = {"mfussenegger/nvim-dap", "nvim-neotest/nvim-nio"} }
```

It is highly recommended to use [neodev.nvim](https://github.com/folke/neodev.nvim) to enable type checking for nvim-dap-ui to get
Expand Down
326 changes: 0 additions & 326 deletions doc/nvim-dap-ui.txt
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11,7 +11,6 @@ nvim-dap-ui *nvim-dap-ui*
Watch Expressions...................................|dapui.elements.watches|
Breakpoints.....................................|dapui.elements.breakpoints|
Console.............................................|dapui.elements.console|
Async Library..................................................|dapui.async|

A UI for nvim-dap which provides a good out of the box configuration.
nvim-dap-ui is built on the idea of "elements". These elements are windows
Expand Down Expand Up @@ -431,329 +430,4 @@ dapui.elements.console *dapui.elements.console*
The console window used by nvim-dap for the integrated terminal.


==============================================================================
dapui.async *dapui.async*


The API is heavily inspired by Python's asyncio module and is currently
experimental meaning that interfaces may change without warning.
Users of nvim-dap-ui should not need to use this module directly.

*dapui.async.run()*
`run`({func}, {cb})

Run a function in an async context. This is the entrypoint to all async
functionality.
>lua
local async = require("dapui").async
async.run(function()
async.sleep(10)
print("Hello world")
end)
<
Parameters~
{func} `(function)`
Return~
`(dapui.async.tasks.Task)`

*dapui.async.wrap()*
`wrap`({func}, {argc})

Creates an async function with a callback style function.
>lua
local async = require("dapui").async
local sleep = async.wrap(function(ms, cb)
vim.defer_fn(cb, ms)
end, 2)

async.run(function()
sleep(10)
print("Slept for 10ms")
end)
<
Parameters~
{func} `(function)` A callback style function to be converted. The last argument must be the callback.
{argc} `(integer)` The number of arguments of func. Must be included.
Return~
`(function)` Returns an async function

*dapui.async.gather()*
`gather`({functions})

Run a collection of async functions concurrently and return when
all have finished.
If any of the functions fail, all pending tasks will be cancelled and the
error will be re-raised

Parameters~
{functions} `(function[])`
Return~
`(any[][])` Packed results of all functions

*dapui.async.first()*
`first`({functions})

Run a collection of async functions concurrently and return the result of
the first to finish.

Parameters~
{functions} `(function[])`
Return~
`(any)`

*dapui.async.sleep()*
`sleep`({ms})

Suspend the current task for given time.
Parameters~
{ms} `(number)` Time in milliseconds

*dapui.async.scheduler()*
`scheduler`()

Yields to the Neovim scheduler to be able to call the API.


dapui.async.api *dapui.async.api*

Safely proxies calls to the vim.api module while in an async context.

dapui.async.fn *dapui.async.fn*

Safely proxies calls to the vim.fn module while in an async context.

Async versions of vim.ui functions


==============================================================================
dapui.async.control *dapui.async.control*


Provides primitives for flow control to be used in async functions


An event can signal to multiple listeners to resume execution
The event can be set from a non-async context.
*dapui.async.control.Event*
Fields~
{set} `(fun(max_woken?: integer): nil)` Set the event and signal to all (or limited number of) listeners that the event has occurred. If max_woken is provided and there are more listeners then the event is cleared immediately
{wait} `(async fun(): nil)` Wait for the event to occur, returning immediately if
already set
{clear} `(fun(): nil)` Clear the event
{is_set} `(fun(): boolean)` Returns true if the event is set

*dapui.async.control.event()*
`event`()

Create a new event
Return~
`(dapui.async.control.Event)`


An future represents a value that will be available in the future.
The future result can be set from a non-async context.
*dapui.async.control.Future*
Fields~
{set} `(fun(value): nil)` Set the future value and wake all waiters.
{set_error} `(fun(message): nil)` Set the error for this future to raise to
waiters
{wait} `(async fun(): any)` Wait for the value to be set, returning immediately if already set

*dapui.async.control.future()*
`future`()

Create a new future
Return~
`(dapui.async.control.Future)`


A FIFO queue with async support.
*dapui.async.control.Queue*
Fields~
{size} `(fun(): number)` Returns the number of items in the queue
{max_size} `(fun(): number|nil)` Returns the maximum number of items in the queue
{get} `(async fun(): any)` Get a value from the queue, blocking if the queue is empty
{get_nowait} `(fun(): any)` Get a value from the queue, erroring if queue is empty.
{put} `(async fun(value: any): nil)` Put a value into the queue
{put_nowait} `(fun(value: any): nil)` Put a value into the queue, erroring if queue is full.

*dapui.async.control.queue()*
`queue`({max_size})

Create a new queue
Parameters~
{max_size?} `(integer)` The maximum number of items in the queue, defaults to no limit
Return~
`(dapui.async.control.Queue)`


An async semaphore that allows up to a given number of acquisitions.
*dapui.async.control.Semaphore*
Fields~
{with} `(async fun(callback: fun(): nil): nil)` Run the callback with the semaphore acquired

*dapui.async.control.semaphore()*
`semaphore`({value})

Create a new semaphore
Parameters~
{value} `(integer)` The number of allowed concurrent acquisitions


==============================================================================
dapui.async.uv *dapui.async.uv*


Provides asynchronous versions of vim.loop functions.
See corresponding function documentation for parameter and return
information.

Fields~
{close} `(async fun(handle: dapui.async.uv.Handle))`
{fs_open} `(async fun(path: any, flags: any, mode: any): (string|nil,integer|nil))`
{fs_read} `(async fun(fd: integer, size: integer, offset?: integer): (string|nil,string|nil))`
{fs_close} `(async fun(fd: integer): (string|nil,boolean|nil))`
{fs_unlink} `(async fun(path: string): (string|nil,boolean|nil))`
{fs_write} `(async fun(fd: any, data: any, offset?: any): (string|nil,integer|nil))`
{fs_mkdir} `(async fun(path: string, mode: integer): (string|nil,boolean|nil))`
{fs_mkdtemp} `(async fun(template: string): (string|nil,string|nil))`
{fs_rmdir} `(async fun(path: string): (string|nil,boolean|nil))`
{fs_stat} `(async fun(path: string): (string|nil,dapui.async.uv.Stat|nil))`
{fs_fstat} `(async fun(fd: integer): (string|nil,dapui.async.uv.Stat|nil))`
{fs_lstat} `(async fun(path: string): (string|nil,dapui.async.uv.Stat|nil))`
{fs_statfs} `(async fun(path: string): (string|nil,dapui.async.uv.StatFs|nil))`
{fs_rename} `(async fun(old_path: string, new_path: string): (string|nil,boolean|nil))`
{fs_fsync} `(async fun(fd: integer): (string|nil,boolean|nil))`
{fs_fdatasync} `(async fun(fd: integer): (string|nil,boolean|nil))`
{fs_ftruncate} `(async fun(fd: integer, offset: integer): (string|nil,boolean|nil))`
{fs_sendfile} `(async fun(out_fd: integer, in_fd: integer, in_offset: integer, length: integer): (string|nil,integer|nil))`
{fs_access} `(async fun(path: string, mode: integer): (string|nil,boolean|nil))`
{fs_chmod} `(async fun(path: string, mode: integer): (string|nil,boolean|nil))`
{fs_fchmod} `(async fun(fd: integer, mode: integer): (string|nil,boolean|nil))`
{fs_utime} `(async fun(path: string, atime: number, mtime: number): (string|nil,boolean|nil))`
{fs_futime} `(async fun(fd: integer, atime: number, mtime: number): (string|nil,boolean|nil))`
{fs_link} `(async fun(path: string, new_path: string): (string|nil,boolean|nil))`
{fs_symlink} `(async fun(path: string, new_path: string, flags?: integer): (string|nil,boolean|nil))`
{fs_readlink} `(async fun(path: string): (string|nil,string|nil))`
{fs_realpath} `(async fun(path: string): (string|nil,string|nil))`
{fs_chown} `(async fun(path: string, uid: integer, gid: integer): (string|nil,boolean|nil))`
{fs_fchown} `(async fun(fd: integer, uid: integer, gid: integer): (string|nil,boolean|nil))`
{fs_lchown} `(async fun(path: string, uid: integer, gid: integer): (string|nil,boolean|nil))`
{fs_copyfile} `(async fun(path: any, new_path: any, flags?: any): (string|nil,boolean|nil))`
{fs_opendir} `(async fun(path: string, entries?: integer): (string|nil,dapui.async.uv.Dir|nil))`
{fs_readdir} `(async fun(dir: dapui.async.uv.Dir): (string|nil,dapui.async.uv.DirEntry[]|nil))`
{fs_closedir} `(async fun(dir: dapui.async.uv.Dir): (string|nil,boolean|nil))`
{fs_scandir} `(async fun(path: string): (string|nil,dapui.async.uv.DirEntry[]|nil))`
{shutdown} `(async fun(stream: dapui.async.uv.Stream): string|nil)`
{listen} `(async fun(stream: dapui.async.uv.Stream, backlog: integer): string|nil)`
{write} `(async fun(stream: dapui.async.uv.Stream, data: string|string[]): string|nil)`
{write2} `(async fun(stream: dapui.async.uv.Stream, data: string|string[], send_handle: dapui.async.uv.Stream): string|nil)`

*dapui.async.uv.Handle*

*dapui.async.uv.Stream*
Inherits: `dapui.async.uv.Handle`


*dapui.async.uv.Stat*
Fields~
{dev} `(integer)`
{mode} `(integer)`
{nlink} `(integer)`
{uid} `(integer)`
{gid} `(integer)`
{rdev} `(integer)`
{ino} `(integer)`
{size} `(integer)`
{blksize} `(integer)`
{blocks} `(integer)`
{flags} `(integer)`
{gen} `(integer)`
{atime} `(dapui.async.uv.StatTime)`
{mtime} `(dapui.async.uv.StatTime)`
{ctime} `(dapui.async.uv.StatTime)`
{birthtime} `(dapui.async.uv.StatTime)`
{type} `(string)`

*dapui.async.uv.StatTime*
Fields~
{sec} `(integer)`
{nsec} `(integer)`

*dapui.async.uv.StatFs*
Fields~
{type} `(integer)`
{bsize} `(integer)`
{blocks} `(integer)`
{bfree} `(integer)`
{bavail} `(integer)`
{files} `(integer)`
{ffree} `(integer)`

*dapui.async.uv.Dir*

*dapui.async.uv.DirEntry*


==============================================================================
dapui.async.ui *dapui.async.ui*


Async versions of vim.ui functions.

*dapui.async.ui.input()*
`input`({args})


Parameters~
{args} `(dapui.async.ui.InputArgs)`

*dapui.async.ui.InputArgs*
Fields~
{prompt} `(string|nil)` Text of the prompt
{default} `(string|nil)` Default reply to the input
{completion} `(string|nil)` Specifies type of completion supported for input. Supported types are the same that can be supplied to a user-defined command using the "-complete=" argument. See |:command-completion|
{highlight} `(function)` Function that will be used for highlighting user inputs.

*dapui.async.ui.select()*
`select`({items}, {args})


Parameters~
{items} `(any[])`
{args} `(dapui.async.ui.SelectArgs)`

*dapui.async.ui.SelectArgs*
Fields~
{prompt} `(string|nil)` Text of the prompt. Defaults to `Select one of:`
{format_item} `(function|nil)` Function to format an individual item from `items`. Defaults to `tostring`.
{kind} `(string|nil)` Arbitrary hint string indicating the item shape. Plugins reimplementing `vim.ui.select` may wish to use this to infer the structure or semantics of `items`, or the context in which select() was called.


==============================================================================
dapui.async.tests *dapui.async.tests*


Async versions of plenary's test functions.

*dapui.async.tests.it()*
`it`({name}, {async_func})

Parameters~
{name} `(string)`
{async_func} `(function)`

*dapui.async.tests.before_each()*
`before_each`({async_func})

Parameters~
{async_func} `(function)`

*dapui.async.tests.after_each()*
`after_each`({async_func})

Parameters~
{async_func} `(function)`


vim:tw=78:ts=8:noet:ft=help:norl:
Loading
Loading