AdeAttwood/ivy.nvim
1
0
Fork 0
Code Issues Pull requests Projects Wiki Activity Actions
ivy.nvim/lua/ivy/init.lua

50 lines
1.2 KiB
Lua
Raw Normal View History

feat: implement a setup function Summary: Now when using ivy.nvim you will need to call the `setup` function. This will need to register any backends you want to use. This is an example config, this can be put into a plugin in `~/.config/nvim/plugin/ivy.lua` for example. ```lua require('ivy').setup { backends = { "ivy.backends.buffers", "ivy.backends.files", }, } ``` If you are using Lazy you can use the `config` directly to call the setup function. ```lua return { "AdeAttwood/ivy.nvim", build = "cargo build --release", config = { backends = { "ivy.backends.buffers", "ivy.backends.files", } } } ``` The `setup` function can only be called once, if its called a second time any backends or config will not be used. The module does expose the `register_backend` function, this can be used to load backends before or after the setup function is called. ```lua require('ivy').register_backend("ivy.backends.files") ``` As well as the `register_backend` the core `run`function is exposed. With this exposed we should be able to build anything we want. ```lua vim.ivy.run( "Title", function(input) return { { content = "One" }, { content = "Two" }, { content = "Three" }, } end, function(result) vim.cmd("edit " .. result) end ) ``` Test Plan: Not much to test in this one, it has been tested locally on my config that does not use any plugin managers, also a sandbox Lazy env using `NVIM_APPNAME` NVIM_APPNAME
2024-06-24 19:07:44 +00:00
local controller = require "ivy.controller"
chore: make public api consistent Summary: Right now we have two ways to access the public api we have `require('ivy')` and `vim.ivy. Each way has a different api that will cause some confusion. Now both apis are the same so anyone that wants to integrate with ivy can do so without having to figure out what one they need to use. Test Plan: The unit tests cover most of the work, I have also been using this locally for quite some time now with now issues.
2024-09-03 18:34:17 +00:00
local libivy = require "ivy.libivy"
feat: setup configuration with default fallbacks Summary: Now the users configuration and the default configuration is separated. This will make it easier to setup ivy with some defaults. Right now we only have the backends configurable however, it looks like we will be making other components of ivy configurable. To use this you can now call `ivy.setup` with no parameters and you will get the default config. You can also call it with a partial config and if the option is not found in the users config it will fallback to the users config value. Test Plan: Manual testing and with unit tests in CI
2024-06-27 06:39:05 +00:00
local config = require "ivy.config"
chore: make public api consistent Summary: Right now we have two ways to access the public api we have `require('ivy')` and `vim.ivy. Each way has a different api that will cause some confusion. Now both apis are the same so anyone that wants to integrate with ivy can do so without having to figure out what one they need to use. Test Plan: The unit tests cover most of the work, I have also been using this locally for quite some time now with now issues.
2024-09-03 18:34:17 +00:00
local utils = require "ivy.utils"
feat: implement a setup function Summary: Now when using ivy.nvim you will need to call the `setup` function. This will need to register any backends you want to use. This is an example config, this can be put into a plugin in `~/.config/nvim/plugin/ivy.lua` for example. ```lua require('ivy').setup { backends = { "ivy.backends.buffers", "ivy.backends.files", }, } ``` If you are using Lazy you can use the `config` directly to call the setup function. ```lua return { "AdeAttwood/ivy.nvim", build = "cargo build --release", config = { backends = { "ivy.backends.buffers", "ivy.backends.files", } } } ``` The `setup` function can only be called once, if its called a second time any backends or config will not be used. The module does expose the `register_backend` function, this can be used to load backends before or after the setup function is called. ```lua require('ivy').register_backend("ivy.backends.files") ``` As well as the `register_backend` the core `run`function is exposed. With this exposed we should be able to build anything we want. ```lua vim.ivy.run( "Title", function(input) return { { content = "One" }, { content = "Two" }, { content = "Three" }, } end, function(result) vim.cmd("edit " .. result) end ) ``` Test Plan: Not much to test in this one, it has been tested locally on my config that does not use any plugin managers, also a sandbox Lazy env using `NVIM_APPNAME` NVIM_APPNAME
2024-06-24 19:07:44 +00:00
local register_backend = require "ivy.register_backend"
local ivy = {}
chore: make public api consistent Summary: Right now we have two ways to access the public api we have `require('ivy')` and `vim.ivy. Each way has a different api that will cause some confusion. Now both apis are the same so anyone that wants to integrate with ivy can do so without having to figure out what one they need to use. Test Plan: The unit tests cover most of the work, I have also been using this locally for quite some time now with now issues.
2024-09-03 18:34:17 +00:00
ivy.action = utils.actions
ivy.utils = utils
ivy.match = libivy.ivy_match
feat: implement a setup function Summary: Now when using ivy.nvim you will need to call the `setup` function. This will need to register any backends you want to use. This is an example config, this can be put into a plugin in `~/.config/nvim/plugin/ivy.lua` for example. ```lua require('ivy').setup { backends = { "ivy.backends.buffers", "ivy.backends.files", }, } ``` If you are using Lazy you can use the `config` directly to call the setup function. ```lua return { "AdeAttwood/ivy.nvim", build = "cargo build --release", config = { backends = { "ivy.backends.buffers", "ivy.backends.files", } } } ``` The `setup` function can only be called once, if its called a second time any backends or config will not be used. The module does expose the `register_backend` function, this can be used to load backends before or after the setup function is called. ```lua require('ivy').register_backend("ivy.backends.files") ``` As well as the `register_backend` the core `run`function is exposed. With this exposed we should be able to build anything we want. ```lua vim.ivy.run( "Title", function(input) return { { content = "One" }, { content = "Two" }, { content = "Three" }, } end, function(result) vim.cmd("edit " .. result) end ) ``` Test Plan: Not much to test in this one, it has been tested locally on my config that does not use any plugin managers, also a sandbox Lazy env using `NVIM_APPNAME` NVIM_APPNAME
2024-06-24 19:07:44 +00:00
ivy.run = controller.run
ivy.register_backend = register_backend
chore: make public api consistent Summary: Right now we have two ways to access the public api we have `require('ivy')` and `vim.ivy. Each way has a different api that will cause some confusion. Now both apis are the same so anyone that wants to integrate with ivy can do so without having to figure out what one they need to use. Test Plan: The unit tests cover most of the work, I have also been using this locally for quite some time now with now issues.
2024-09-03 18:34:17 +00:00
ivy.checkpoint = controller.checkpoint
ivy.paste = controller.paste
ivy.complete = controller.complete
ivy.destroy = controller.destroy
ivy.input = controller.input
ivy.next = controller.next
ivy.previous = controller.previous
ivy.search = controller.search
feat: setup configuration with default fallbacks Summary: Now the users configuration and the default configuration is separated. This will make it easier to setup ivy with some defaults. Right now we only have the backends configurable however, it looks like we will be making other components of ivy configurable. To use this you can now call `ivy.setup` with no parameters and you will get the default config. You can also call it with a partial config and if the option is not found in the users config it will fallback to the users config value. Test Plan: Manual testing and with unit tests in CI
2024-06-27 06:39:05 +00:00
-- Private variable to check if ivy has been setup, this is to prevent multiple
-- setups of ivy. This is only exposed for testing purposes.
---@private
ivy.has_setup = false
feat: implement a setup function Summary: Now when using ivy.nvim you will need to call the `setup` function. This will need to register any backends you want to use. This is an example config, this can be put into a plugin in `~/.config/nvim/plugin/ivy.lua` for example. ```lua require('ivy').setup { backends = { "ivy.backends.buffers", "ivy.backends.files", }, } ``` If you are using Lazy you can use the `config` directly to call the setup function. ```lua return { "AdeAttwood/ivy.nvim", build = "cargo build --release", config = { backends = { "ivy.backends.buffers", "ivy.backends.files", } } } ``` The `setup` function can only be called once, if its called a second time any backends or config will not be used. The module does expose the `register_backend` function, this can be used to load backends before or after the setup function is called. ```lua require('ivy').register_backend("ivy.backends.files") ``` As well as the `register_backend` the core `run`function is exposed. With this exposed we should be able to build anything we want. ```lua vim.ivy.run( "Title", function(input) return { { content = "One" }, { content = "Two" }, { content = "Three" }, } end, function(result) vim.cmd("edit " .. result) end ) ``` Test Plan: Not much to test in this one, it has been tested locally on my config that does not use any plugin managers, also a sandbox Lazy env using `NVIM_APPNAME` NVIM_APPNAME
2024-06-24 19:07:44 +00:00
---@class IvySetupOptions
---@field backends (IvyBackend | { ["1"]: string, ["2"]: IvyBackendOptions} | string)[]
feat: setup configuration with default fallbacks Summary: Now the users configuration and the default configuration is separated. This will make it easier to setup ivy with some defaults. Right now we only have the backends configurable however, it looks like we will be making other components of ivy configurable. To use this you can now call `ivy.setup` with no parameters and you will get the default config. You can also call it with a partial config and if the option is not found in the users config it will fallback to the users config value. Test Plan: Manual testing and with unit tests in CI
2024-06-27 06:39:05 +00:00
---@param user_config IvySetupOptions
function ivy.setup(user_config)
if ivy.has_setup then
feat: implement a setup function Summary: Now when using ivy.nvim you will need to call the `setup` function. This will need to register any backends you want to use. This is an example config, this can be put into a plugin in `~/.config/nvim/plugin/ivy.lua` for example. ```lua require('ivy').setup { backends = { "ivy.backends.buffers", "ivy.backends.files", }, } ``` If you are using Lazy you can use the `config` directly to call the setup function. ```lua return { "AdeAttwood/ivy.nvim", build = "cargo build --release", config = { backends = { "ivy.backends.buffers", "ivy.backends.files", } } } ``` The `setup` function can only be called once, if its called a second time any backends or config will not be used. The module does expose the `register_backend` function, this can be used to load backends before or after the setup function is called. ```lua require('ivy').register_backend("ivy.backends.files") ``` As well as the `register_backend` the core `run`function is exposed. With this exposed we should be able to build anything we want. ```lua vim.ivy.run( "Title", function(input) return { { content = "One" }, { content = "Two" }, { content = "Three" }, } end, function(result) vim.cmd("edit " .. result) end ) ``` Test Plan: Not much to test in this one, it has been tested locally on my config that does not use any plugin managers, also a sandbox Lazy env using `NVIM_APPNAME` NVIM_APPNAME
2024-06-24 19:07:44 +00:00
return
end
feat: setup configuration with default fallbacks Summary: Now the users configuration and the default configuration is separated. This will make it easier to setup ivy with some defaults. Right now we only have the backends configurable however, it looks like we will be making other components of ivy configurable. To use this you can now call `ivy.setup` with no parameters and you will get the default config. You can also call it with a partial config and if the option is not found in the users config it will fallback to the users config value. Test Plan: Manual testing and with unit tests in CI
2024-06-27 06:39:05 +00:00
config.user_config = user_config or {}
for _, backend in ipairs(config:get { "backends" } or {}) do
feat: implement a setup function Summary: Now when using ivy.nvim you will need to call the `setup` function. This will need to register any backends you want to use. This is an example config, this can be put into a plugin in `~/.config/nvim/plugin/ivy.lua` for example. ```lua require('ivy').setup { backends = { "ivy.backends.buffers", "ivy.backends.files", }, } ``` If you are using Lazy you can use the `config` directly to call the setup function. ```lua return { "AdeAttwood/ivy.nvim", build = "cargo build --release", config = { backends = { "ivy.backends.buffers", "ivy.backends.files", } } } ``` The `setup` function can only be called once, if its called a second time any backends or config will not be used. The module does expose the `register_backend` function, this can be used to load backends before or after the setup function is called. ```lua require('ivy').register_backend("ivy.backends.files") ``` As well as the `register_backend` the core `run`function is exposed. With this exposed we should be able to build anything we want. ```lua vim.ivy.run( "Title", function(input) return { { content = "One" }, { content = "Two" }, { content = "Three" }, } end, function(result) vim.cmd("edit " .. result) end ) ``` Test Plan: Not much to test in this one, it has been tested locally on my config that does not use any plugin managers, also a sandbox Lazy env using `NVIM_APPNAME` NVIM_APPNAME
2024-06-24 19:07:44 +00:00
register_backend(backend)
end
feat: setup configuration with default fallbacks Summary: Now the users configuration and the default configuration is separated. This will make it easier to setup ivy with some defaults. Right now we only have the backends configurable however, it looks like we will be making other components of ivy configurable. To use this you can now call `ivy.setup` with no parameters and you will get the default config. You can also call it with a partial config and if the option is not found in the users config it will fallback to the users config value. Test Plan: Manual testing and with unit tests in CI
2024-06-27 06:39:05 +00:00
ivy.has_setup = true
feat: implement a setup function Summary: Now when using ivy.nvim you will need to call the `setup` function. This will need to register any backends you want to use. This is an example config, this can be put into a plugin in `~/.config/nvim/plugin/ivy.lua` for example. ```lua require('ivy').setup { backends = { "ivy.backends.buffers", "ivy.backends.files", }, } ``` If you are using Lazy you can use the `config` directly to call the setup function. ```lua return { "AdeAttwood/ivy.nvim", build = "cargo build --release", config = { backends = { "ivy.backends.buffers", "ivy.backends.files", } } } ``` The `setup` function can only be called once, if its called a second time any backends or config will not be used. The module does expose the `register_backend` function, this can be used to load backends before or after the setup function is called. ```lua require('ivy').register_backend("ivy.backends.files") ``` As well as the `register_backend` the core `run`function is exposed. With this exposed we should be able to build anything we want. ```lua vim.ivy.run( "Title", function(input) return { { content = "One" }, { content = "Two" }, { content = "Three" }, } end, function(result) vim.cmd("edit " .. result) end ) ``` Test Plan: Not much to test in this one, it has been tested locally on my config that does not use any plugin managers, also a sandbox Lazy env using `NVIM_APPNAME` NVIM_APPNAME
2024-06-24 19:07:44 +00:00
end
return ivy
Reference in a new issue Copy permalink