mirror of
https://github.com/neovim/neovim.git
synced 2025-12-11 09:02:40 +00:00
Merge pull request #20103 from lewis6991/refactor/vim_opt
This commit is contained in:
Lewis Russell
@@ -2,197 +2,6 @@
|
||||
local vim = assert(vim)
|
||||
|
||||
local a = vim.api
|
||||
local validate = vim.validate
|
||||
|
||||
local SET_TYPES = setmetatable({
|
||||
SET = 0,
|
||||
LOCAL = 1,
|
||||
GLOBAL = 2,
|
||||
}, { __index = error })
|
||||
|
||||
local options_info = nil
|
||||
local buf_options = nil
|
||||
local glb_options = nil
|
||||
local win_options = nil
|
||||
|
||||
local function _setup()
|
||||
if options_info ~= nil then
|
||||
return
|
||||
end
|
||||
options_info = {}
|
||||
for _, v in pairs(a.nvim_get_all_options_info()) do
|
||||
options_info[v.name] = v
|
||||
if v.shortname ~= '' then
|
||||
options_info[v.shortname] = v
|
||||
end
|
||||
end
|
||||
|
||||
local function get_scoped_options(scope)
|
||||
local result = {}
|
||||
for name, option_info in pairs(options_info) do
|
||||
if option_info.scope == scope then
|
||||
result[name] = true
|
||||
end
|
||||
end
|
||||
|
||||
return result
|
||||
end
|
||||
|
||||
buf_options = get_scoped_options('buf')
|
||||
glb_options = get_scoped_options('global')
|
||||
win_options = get_scoped_options('win')
|
||||
end
|
||||
|
||||
local function make_meta_accessor(get, set, del, validator)
|
||||
validator = validator or function()
|
||||
return true
|
||||
end
|
||||
|
||||
validate({
|
||||
get = { get, 'f' },
|
||||
set = { set, 'f' },
|
||||
del = { del, 'f', true },
|
||||
validator = { validator, 'f' },
|
||||
})
|
||||
|
||||
local mt = {}
|
||||
function mt:__newindex(k, v)
|
||||
if not validator(k) then
|
||||
return
|
||||
end
|
||||
|
||||
if del and v == nil then
|
||||
return del(k)
|
||||
end
|
||||
return set(k, v)
|
||||
end
|
||||
function mt:__index(k)
|
||||
if not validator(k) then
|
||||
return
|
||||
end
|
||||
|
||||
return get(k)
|
||||
end
|
||||
return setmetatable({}, mt)
|
||||
end
|
||||
|
||||
vim.env = make_meta_accessor(function(k)
|
||||
local v = vim.fn.getenv(k)
|
||||
if v == vim.NIL then
|
||||
return nil
|
||||
end
|
||||
return v
|
||||
end, vim.fn.setenv)
|
||||
|
||||
do -- buffer option accessor
|
||||
local function new_buf_opt_accessor(bufnr)
|
||||
local function get(k)
|
||||
if bufnr == nil and type(k) == 'number' then
|
||||
return new_buf_opt_accessor(k)
|
||||
end
|
||||
|
||||
return a.nvim_get_option_value(k, { buf = bufnr or 0 })
|
||||
end
|
||||
|
||||
local function set(k, v)
|
||||
return a.nvim_set_option_value(k, v, { buf = bufnr or 0 })
|
||||
end
|
||||
|
||||
return make_meta_accessor(get, set, nil, function(k)
|
||||
if type(k) == 'string' then
|
||||
_setup()
|
||||
if win_options[k] then
|
||||
error(
|
||||
string.format([['%s' is a window option, not a buffer option. See ":help %s"]], k, k)
|
||||
)
|
||||
elseif glb_options[k] then
|
||||
error(
|
||||
string.format([['%s' is a global option, not a buffer option. See ":help %s"]], k, k)
|
||||
)
|
||||
end
|
||||
end
|
||||
|
||||
return true
|
||||
end)
|
||||
end
|
||||
|
||||
vim.bo = new_buf_opt_accessor(nil)
|
||||
end
|
||||
|
||||
do -- window option accessor
|
||||
local function new_win_opt_accessor(winnr)
|
||||
local function get(k)
|
||||
if winnr == nil and type(k) == 'number' then
|
||||
return new_win_opt_accessor(k)
|
||||
end
|
||||
return a.nvim_get_option_value(k, { win = winnr or 0 })
|
||||
end
|
||||
|
||||
local function set(k, v)
|
||||
return a.nvim_set_option_value(k, v, { win = winnr or 0 })
|
||||
end
|
||||
|
||||
return make_meta_accessor(get, set, nil, function(k)
|
||||
if type(k) == 'string' then
|
||||
_setup()
|
||||
if buf_options[k] then
|
||||
error(
|
||||
string.format([['%s' is a buffer option, not a window option. See ":help %s"]], k, k)
|
||||
)
|
||||
elseif glb_options[k] then
|
||||
error(
|
||||
string.format([['%s' is a global option, not a window option. See ":help %s"]], k, k)
|
||||
)
|
||||
end
|
||||
end
|
||||
|
||||
return true
|
||||
end)
|
||||
end
|
||||
|
||||
vim.wo = new_win_opt_accessor(nil)
|
||||
end
|
||||
|
||||
-- vim global option
|
||||
-- this ONLY sets the global option. like `setglobal`
|
||||
vim.go = make_meta_accessor(function(k)
|
||||
return a.nvim_get_option_value(k, { scope = 'global' })
|
||||
end, function(k, v)
|
||||
return a.nvim_set_option_value(k, v, { scope = 'global' })
|
||||
end)
|
||||
|
||||
-- vim `set` style options.
|
||||
-- it has no additional metamethod magic.
|
||||
vim.o = make_meta_accessor(function(k)
|
||||
return a.nvim_get_option_value(k, {})
|
||||
end, function(k, v)
|
||||
return a.nvim_set_option_value(k, v, {})
|
||||
end)
|
||||
|
||||
---@brief [[
|
||||
--- vim.opt, vim.opt_local and vim.opt_global implementation
|
||||
---
|
||||
--- To be used as helpers for working with options within neovim.
|
||||
--- For information on how to use, see :help vim.opt
|
||||
---
|
||||
---@brief ]]
|
||||
|
||||
--- Preserves the order and does not mutate the original list
|
||||
local remove_duplicate_values = function(t)
|
||||
local result, seen = {}, {}
|
||||
if type(t) == 'function' then
|
||||
error(debug.traceback('asdf'))
|
||||
end
|
||||
for _, v in ipairs(t) do
|
||||
if not seen[v] then
|
||||
table.insert(result, v)
|
||||
end
|
||||
|
||||
seen[v] = true
|
||||
end
|
||||
|
||||
return result
|
||||
end
|
||||
|
||||
-- TODO(tjdevries): Improve option metadata so that this doesn't have to be hardcoded.
|
||||
-- Can be done in a separate PR.
|
||||
@@ -205,51 +14,124 @@ local key_value_options = {
|
||||
winhl = true,
|
||||
}
|
||||
|
||||
---@class OptionTypes
|
||||
--- Option Type Enum
|
||||
local OptionTypes = setmetatable({
|
||||
BOOLEAN = 0,
|
||||
NUMBER = 1,
|
||||
STRING = 2,
|
||||
ARRAY = 3,
|
||||
MAP = 4,
|
||||
SET = 5,
|
||||
}, {
|
||||
__index = function(_, k)
|
||||
error('Not a valid OptionType: ' .. k)
|
||||
end,
|
||||
__newindex = function(_, k)
|
||||
error('Cannot set a new OptionType: ' .. k)
|
||||
--- Convert a vimoption_T style dictionary to the correct OptionType associated with it.
|
||||
---@return string
|
||||
local function get_option_metatype(name, info)
|
||||
if info.type == 'string' then
|
||||
if info.flaglist then
|
||||
return 'set'
|
||||
elseif info.commalist then
|
||||
if key_value_options[name] then
|
||||
return 'map'
|
||||
end
|
||||
return 'array'
|
||||
end
|
||||
return 'string'
|
||||
end
|
||||
return info.type
|
||||
end
|
||||
|
||||
local options_info = setmetatable({}, {
|
||||
__index = function(t, k)
|
||||
local info = a.nvim_get_option_info(k)
|
||||
info.metatype = get_option_metatype(k, info)
|
||||
rawset(t, k, info)
|
||||
return rawget(t, k)
|
||||
end,
|
||||
})
|
||||
|
||||
--- Convert a vimoption_T style dictionary to the correct OptionType associated with it.
|
||||
---@return OptionType
|
||||
local get_option_type = function(name, info)
|
||||
if info.type == 'boolean' then
|
||||
return OptionTypes.BOOLEAN
|
||||
elseif info.type == 'number' then
|
||||
return OptionTypes.NUMBER
|
||||
elseif info.type == 'string' then
|
||||
if not info.commalist and not info.flaglist then
|
||||
return OptionTypes.STRING
|
||||
vim.env = setmetatable({}, {
|
||||
__index = function(_, k)
|
||||
local v = vim.fn.getenv(k)
|
||||
if v == vim.NIL then
|
||||
return nil
|
||||
end
|
||||
return v
|
||||
end,
|
||||
|
||||
__newindex = function(_, k, v)
|
||||
vim.fn.setenv(k, v)
|
||||
end,
|
||||
})
|
||||
|
||||
local function opt_validate(option_name, target_scope)
|
||||
local scope = options_info[option_name].scope
|
||||
if scope ~= target_scope then
|
||||
local scope_to_string = { buf = 'buffer', win = 'window' }
|
||||
error(
|
||||
string.format(
|
||||
[['%s' is a %s option, not a %s option. See ":help %s"]],
|
||||
option_name,
|
||||
scope_to_string[scope] or scope,
|
||||
scope_to_string[target_scope] or target_scope,
|
||||
option_name
|
||||
)
|
||||
)
|
||||
end
|
||||
end
|
||||
|
||||
local function new_opt_accessor(handle, scope)
|
||||
return setmetatable({}, {
|
||||
__index = function(_, k)
|
||||
if handle == nil and type(k) == 'number' then
|
||||
return new_opt_accessor(k, scope)
|
||||
end
|
||||
opt_validate(k, scope)
|
||||
return a.nvim_get_option_value(k, { [scope] = handle or 0 })
|
||||
end,
|
||||
|
||||
__newindex = function(_, k, v)
|
||||
opt_validate(k, scope)
|
||||
return a.nvim_set_option_value(k, v, { [scope] = handle or 0 })
|
||||
end,
|
||||
})
|
||||
end
|
||||
|
||||
vim.bo = new_opt_accessor(nil, 'buf')
|
||||
vim.wo = new_opt_accessor(nil, 'win')
|
||||
|
||||
-- vim global option
|
||||
-- this ONLY sets the global option. like `setglobal`
|
||||
vim.go = setmetatable({}, {
|
||||
__index = function(_, k)
|
||||
return a.nvim_get_option_value(k, { scope = 'global' })
|
||||
end,
|
||||
__newindex = function(_, k, v)
|
||||
return a.nvim_set_option_value(k, v, { scope = 'global' })
|
||||
end,
|
||||
})
|
||||
|
||||
-- vim `set` style options.
|
||||
-- it has no additional metamethod magic.
|
||||
vim.o = setmetatable({}, {
|
||||
__index = function(_, k)
|
||||
return a.nvim_get_option_value(k, {})
|
||||
end,
|
||||
__newindex = function(_, k, v)
|
||||
return a.nvim_set_option_value(k, v, {})
|
||||
end,
|
||||
})
|
||||
|
||||
---@brief [[
|
||||
--- vim.opt, vim.opt_local and vim.opt_global implementation
|
||||
---
|
||||
--- To be used as helpers for working with options within neovim.
|
||||
--- For information on how to use, see :help vim.opt
|
||||
---
|
||||
---@brief ]]
|
||||
|
||||
--- Preserves the order and does not mutate the original list
|
||||
local function remove_duplicate_values(t)
|
||||
local result, seen = {}, {}
|
||||
for _, v in ipairs(t) do
|
||||
if not seen[v] then
|
||||
table.insert(result, v)
|
||||
end
|
||||
|
||||
if key_value_options[name] then
|
||||
assert(info.commalist, 'Must be a comma list to use key:value style')
|
||||
return OptionTypes.MAP
|
||||
seen[v] = true
|
||||
end
|
||||
|
||||
if info.flaglist then
|
||||
return OptionTypes.SET
|
||||
elseif info.commalist then
|
||||
return OptionTypes.ARRAY
|
||||
end
|
||||
|
||||
error('Fallthrough in OptionTypes')
|
||||
else
|
||||
error('Not a known info.type:' .. info.type)
|
||||
end
|
||||
return result
|
||||
end
|
||||
|
||||
-- Check whether the OptionTypes is allowed for vim.opt
|
||||
@@ -272,31 +154,43 @@ local function assert_valid_value(name, value, types)
|
||||
)
|
||||
end
|
||||
|
||||
local function passthrough(_, x)
|
||||
return x
|
||||
end
|
||||
|
||||
local function tbl_merge(left, right)
|
||||
return vim.tbl_extend('force', left, right)
|
||||
end
|
||||
|
||||
local function tbl_remove(t, value)
|
||||
if type(value) == 'string' then
|
||||
t[value] = nil
|
||||
else
|
||||
for _, v in ipairs(value) do
|
||||
t[v] = nil
|
||||
end
|
||||
end
|
||||
|
||||
return t
|
||||
end
|
||||
|
||||
local valid_types = {
|
||||
[OptionTypes.BOOLEAN] = { 'boolean' },
|
||||
[OptionTypes.NUMBER] = { 'number' },
|
||||
[OptionTypes.STRING] = { 'string' },
|
||||
[OptionTypes.SET] = { 'string', 'table' },
|
||||
[OptionTypes.ARRAY] = { 'string', 'table' },
|
||||
[OptionTypes.MAP] = { 'string', 'table' },
|
||||
boolean = { 'boolean' },
|
||||
number = { 'number' },
|
||||
string = { 'string' },
|
||||
set = { 'string', 'table' },
|
||||
array = { 'string', 'table' },
|
||||
map = { 'string', 'table' },
|
||||
}
|
||||
|
||||
--- Convert a lua value to a vimoption_T value
|
||||
local convert_value_to_vim = (function()
|
||||
-- Map of functions to take a Lua style value and convert to vimoption_T style value.
|
||||
-- Each function takes (info, lua_value) -> vim_value
|
||||
local to_vim_value = {
|
||||
[OptionTypes.BOOLEAN] = function(_, value)
|
||||
return value
|
||||
end,
|
||||
[OptionTypes.NUMBER] = function(_, value)
|
||||
return value
|
||||
end,
|
||||
[OptionTypes.STRING] = function(_, value)
|
||||
return value
|
||||
end,
|
||||
-- Map of functions to take a Lua style value and convert to vimoption_T style value.
|
||||
-- Each function takes (info, lua_value) -> vim_value
|
||||
local to_vim_value = {
|
||||
boolean = passthrough,
|
||||
number = passthrough,
|
||||
string = passthrough,
|
||||
|
||||
[OptionTypes.SET] = function(info, value)
|
||||
set = function(info, value)
|
||||
if type(value) == 'string' then
|
||||
return value
|
||||
end
|
||||
@@ -323,7 +217,7 @@ local convert_value_to_vim = (function()
|
||||
end
|
||||
end,
|
||||
|
||||
[OptionTypes.ARRAY] = function(info, value)
|
||||
array = function(info, value)
|
||||
if type(value) == 'string' then
|
||||
return value
|
||||
end
|
||||
@@ -333,7 +227,7 @@ local convert_value_to_vim = (function()
|
||||
return table.concat(value, ',')
|
||||
end,
|
||||
|
||||
[OptionTypes.MAP] = function(_, value)
|
||||
map = function(_, value)
|
||||
if type(value) == 'string' then
|
||||
return value
|
||||
end
|
||||
@@ -346,36 +240,27 @@ local convert_value_to_vim = (function()
|
||||
table.sort(result)
|
||||
return table.concat(result, ',')
|
||||
end,
|
||||
}
|
||||
}
|
||||
|
||||
return function(name, info, value)
|
||||
--- Convert a lua value to a vimoption_T value
|
||||
local function convert_value_to_vim(name, info, value)
|
||||
if value == nil then
|
||||
return vim.NIL
|
||||
end
|
||||
|
||||
local option_type = get_option_type(name, info)
|
||||
assert_valid_value(name, value, valid_types[option_type])
|
||||
assert_valid_value(name, value, valid_types[info.metatype])
|
||||
|
||||
return to_vim_value[option_type](info, value)
|
||||
end
|
||||
end)()
|
||||
return to_vim_value[info.metatype](info, value)
|
||||
end
|
||||
|
||||
--- Converts a vimoption_T style value to a Lua value
|
||||
local convert_value_to_lua = (function()
|
||||
-- Map of OptionType to functions that take vimoption_T values and convert to lua values.
|
||||
-- Each function takes (info, vim_value) -> lua_value
|
||||
local to_lua_value = {
|
||||
[OptionTypes.BOOLEAN] = function(_, value)
|
||||
return value
|
||||
end,
|
||||
[OptionTypes.NUMBER] = function(_, value)
|
||||
return value
|
||||
end,
|
||||
[OptionTypes.STRING] = function(_, value)
|
||||
return value
|
||||
end,
|
||||
-- Map of OptionType to functions that take vimoption_T values and convert to lua values.
|
||||
-- Each function takes (info, vim_value) -> lua_value
|
||||
local to_lua_value = {
|
||||
boolean = passthrough,
|
||||
number = passthrough,
|
||||
string = passthrough,
|
||||
|
||||
[OptionTypes.ARRAY] = function(info, value)
|
||||
array = function(info, value)
|
||||
if type(value) == 'table' then
|
||||
if not info.allows_duplicates then
|
||||
value = remove_duplicate_values(value)
|
||||
@@ -392,9 +277,7 @@ local convert_value_to_lua = (function()
|
||||
|
||||
-- Handles unescaped commas in a list.
|
||||
if string.find(value, ',,,') then
|
||||
local comma_split = vim.split(value, ',,,')
|
||||
local left = comma_split[1]
|
||||
local right = comma_split[2]
|
||||
local left, right = unpack(vim.split(value, ',,,'))
|
||||
|
||||
local result = {}
|
||||
vim.list_extend(result, vim.split(left, ','))
|
||||
@@ -407,9 +290,7 @@ local convert_value_to_lua = (function()
|
||||
end
|
||||
|
||||
if string.find(value, ',^,,', 1, true) then
|
||||
local comma_split = vim.split(value, ',^,,', true)
|
||||
local left = comma_split[1]
|
||||
local right = comma_split[2]
|
||||
local left, right = unpack(vim.split(value, ',^,,', true))
|
||||
|
||||
local result = {}
|
||||
vim.list_extend(result, vim.split(left, ','))
|
||||
@@ -424,7 +305,7 @@ local convert_value_to_lua = (function()
|
||||
return vim.split(value, ',')
|
||||
end,
|
||||
|
||||
[OptionTypes.SET] = function(info, value)
|
||||
set = function(info, value)
|
||||
if type(value) == 'table' then
|
||||
return value
|
||||
end
|
||||
@@ -455,7 +336,7 @@ local convert_value_to_lua = (function()
|
||||
end
|
||||
end,
|
||||
|
||||
[OptionTypes.MAP] = function(info, raw_value)
|
||||
map = function(info, raw_value)
|
||||
if type(raw_value) == 'table' then
|
||||
return raw_value
|
||||
end
|
||||
@@ -474,30 +355,23 @@ local convert_value_to_lua = (function()
|
||||
|
||||
return result
|
||||
end,
|
||||
}
|
||||
}
|
||||
|
||||
return function(name, info, option_value)
|
||||
return to_lua_value[get_option_type(name, info)](info, option_value)
|
||||
end
|
||||
end)()
|
||||
|
||||
--- Handles the mutation of various different values.
|
||||
local value_mutator = function(name, info, current, new, mutator)
|
||||
return mutator[get_option_type(name, info)](current, new)
|
||||
--- Converts a vimoption_T style value to a Lua value
|
||||
local function convert_value_to_lua(info, option_value)
|
||||
return to_lua_value[info.metatype](info, option_value)
|
||||
end
|
||||
|
||||
--- Handles the '^' operator
|
||||
local prepend_value = (function()
|
||||
local methods = {
|
||||
[OptionTypes.NUMBER] = function()
|
||||
local prepend_methods = {
|
||||
number = function()
|
||||
error("The '^' operator is not currently supported for")
|
||||
end,
|
||||
|
||||
[OptionTypes.STRING] = function(left, right)
|
||||
string = function(left, right)
|
||||
return right .. left
|
||||
end,
|
||||
|
||||
[OptionTypes.ARRAY] = function(left, right)
|
||||
array = function(left, right)
|
||||
for i = #right, 1, -1 do
|
||||
table.insert(left, 1, right[i])
|
||||
end
|
||||
@@ -505,38 +379,28 @@ local prepend_value = (function()
|
||||
return left
|
||||
end,
|
||||
|
||||
[OptionTypes.MAP] = function(left, right)
|
||||
return vim.tbl_extend('force', left, right)
|
||||
end,
|
||||
map = tbl_merge,
|
||||
set = tbl_merge,
|
||||
}
|
||||
|
||||
[OptionTypes.SET] = function(left, right)
|
||||
return vim.tbl_extend('force', left, right)
|
||||
end,
|
||||
}
|
||||
|
||||
return function(name, info, current, new)
|
||||
return value_mutator(
|
||||
name,
|
||||
info,
|
||||
convert_value_to_lua(name, info, current),
|
||||
convert_value_to_lua(name, info, new),
|
||||
methods
|
||||
--- Handles the '^' operator
|
||||
local function prepend_value(info, current, new)
|
||||
return prepend_methods[info.metatype](
|
||||
convert_value_to_lua(info, current),
|
||||
convert_value_to_lua(info, new)
|
||||
)
|
||||
end
|
||||
end)()
|
||||
end
|
||||
|
||||
--- Handles the '+' operator
|
||||
local add_value = (function()
|
||||
local methods = {
|
||||
[OptionTypes.NUMBER] = function(left, right)
|
||||
local add_methods = {
|
||||
number = function(left, right)
|
||||
return left + right
|
||||
end,
|
||||
|
||||
[OptionTypes.STRING] = function(left, right)
|
||||
string = function(left, right)
|
||||
return left .. right
|
||||
end,
|
||||
|
||||
[OptionTypes.ARRAY] = function(left, right)
|
||||
array = function(left, right)
|
||||
for _, v in ipairs(right) do
|
||||
table.insert(left, v)
|
||||
end
|
||||
@@ -544,29 +408,19 @@ local add_value = (function()
|
||||
return left
|
||||
end,
|
||||
|
||||
[OptionTypes.MAP] = function(left, right)
|
||||
return vim.tbl_extend('force', left, right)
|
||||
end,
|
||||
map = tbl_merge,
|
||||
set = tbl_merge,
|
||||
}
|
||||
|
||||
[OptionTypes.SET] = function(left, right)
|
||||
return vim.tbl_extend('force', left, right)
|
||||
end,
|
||||
}
|
||||
|
||||
return function(name, info, current, new)
|
||||
return value_mutator(
|
||||
name,
|
||||
info,
|
||||
convert_value_to_lua(name, info, current),
|
||||
convert_value_to_lua(name, info, new),
|
||||
methods
|
||||
--- Handles the '+' operator
|
||||
local function add_value(info, current, new)
|
||||
return add_methods[info.metatype](
|
||||
convert_value_to_lua(info, current),
|
||||
convert_value_to_lua(info, new)
|
||||
)
|
||||
end
|
||||
end)()
|
||||
end
|
||||
|
||||
--- Handles the '-' operator
|
||||
local remove_value = (function()
|
||||
local remove_one_item = function(t, val)
|
||||
local function remove_one_item(t, val)
|
||||
if vim.tbl_islist(t) then
|
||||
local remove_index = nil
|
||||
for i, v in ipairs(t) do
|
||||
@@ -581,18 +435,18 @@ local remove_value = (function()
|
||||
else
|
||||
t[val] = nil
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
local methods = {
|
||||
[OptionTypes.NUMBER] = function(left, right)
|
||||
local remove_methods = {
|
||||
number = function(left, right)
|
||||
return left - right
|
||||
end,
|
||||
|
||||
[OptionTypes.STRING] = function()
|
||||
string = function()
|
||||
error('Subtraction not supported for strings.')
|
||||
end,
|
||||
|
||||
[OptionTypes.ARRAY] = function(left, right)
|
||||
array = function(left, right)
|
||||
if type(right) == 'string' then
|
||||
remove_one_item(left, right)
|
||||
else
|
||||
@@ -604,41 +458,19 @@ local remove_value = (function()
|
||||
return left
|
||||
end,
|
||||
|
||||
[OptionTypes.MAP] = function(left, right)
|
||||
if type(right) == 'string' then
|
||||
left[right] = nil
|
||||
else
|
||||
for _, v in ipairs(right) do
|
||||
left[v] = nil
|
||||
end
|
||||
end
|
||||
map = tbl_remove,
|
||||
set = tbl_remove,
|
||||
}
|
||||
|
||||
return left
|
||||
end,
|
||||
--- Handles the '-' operator
|
||||
local function remove_value(info, current, new)
|
||||
return remove_methods[info.metatype](convert_value_to_lua(info, current), new)
|
||||
end
|
||||
|
||||
[OptionTypes.SET] = function(left, right)
|
||||
if type(right) == 'string' then
|
||||
left[right] = nil
|
||||
else
|
||||
for _, v in ipairs(right) do
|
||||
left[v] = nil
|
||||
end
|
||||
end
|
||||
local function create_option_accessor(scope)
|
||||
local option_mt
|
||||
|
||||
return left
|
||||
end,
|
||||
}
|
||||
|
||||
return function(name, info, current, new)
|
||||
return value_mutator(name, info, convert_value_to_lua(name, info, current), new, methods)
|
||||
end
|
||||
end)()
|
||||
|
||||
local create_option_metatable = function(set_type)
|
||||
local set_mt, option_mt
|
||||
|
||||
local make_option = function(name, value)
|
||||
_setup()
|
||||
local function make_option(name, value)
|
||||
local info = assert(options_info[name], 'Not a valid option name: ' .. name)
|
||||
|
||||
if type(value) == 'table' and getmetatable(value) == option_mt then
|
||||
@@ -654,67 +486,58 @@ local create_option_metatable = function(set_type)
|
||||
}, option_mt)
|
||||
end
|
||||
|
||||
local scope
|
||||
if set_type == SET_TYPES.GLOBAL then
|
||||
scope = 'global'
|
||||
elseif set_type == SET_TYPES.LOCAL then
|
||||
scope = 'local'
|
||||
end
|
||||
|
||||
option_mt = {
|
||||
-- To set a value, instead use:
|
||||
-- opt[my_option] = value
|
||||
_set = function(self)
|
||||
local value = convert_value_to_vim(self._name, self._info, self._value)
|
||||
a.nvim_set_option_value(self._name, value, { scope = scope })
|
||||
|
||||
return self
|
||||
end,
|
||||
|
||||
get = function(self)
|
||||
return convert_value_to_lua(self._name, self._info, self._value)
|
||||
return convert_value_to_lua(self._info, self._value)
|
||||
end,
|
||||
|
||||
append = function(self, right)
|
||||
return self:__add(right):_set()
|
||||
self._value = add_value(self._info, self._value, right)
|
||||
self:_set()
|
||||
end,
|
||||
|
||||
__add = function(self, right)
|
||||
return make_option(self._name, add_value(self._name, self._info, self._value, right))
|
||||
return make_option(self._name, add_value(self._info, self._value, right))
|
||||
end,
|
||||
|
||||
prepend = function(self, right)
|
||||
return self:__pow(right):_set()
|
||||
self._value = prepend_value(self._info, self._value, right)
|
||||
self:_set()
|
||||
end,
|
||||
|
||||
__pow = function(self, right)
|
||||
return make_option(self._name, prepend_value(self._name, self._info, self._value, right))
|
||||
return make_option(self._name, prepend_value(self._info, self._value, right))
|
||||
end,
|
||||
|
||||
remove = function(self, right)
|
||||
return self:__sub(right):_set()
|
||||
self._value = remove_value(self._info, self._value, right)
|
||||
self:_set()
|
||||
end,
|
||||
|
||||
__sub = function(self, right)
|
||||
return make_option(self._name, remove_value(self._name, self._info, self._value, right))
|
||||
return make_option(self._name, remove_value(self._info, self._value, right))
|
||||
end,
|
||||
}
|
||||
option_mt.__index = option_mt
|
||||
|
||||
set_mt = {
|
||||
return setmetatable({}, {
|
||||
__index = function(_, k)
|
||||
return make_option(k, a.nvim_get_option_value(k, { scope = scope }))
|
||||
end,
|
||||
|
||||
__newindex = function(_, k, v)
|
||||
local opt = make_option(k, v)
|
||||
opt:_set()
|
||||
make_option(k, v):_set()
|
||||
end,
|
||||
}
|
||||
|
||||
return set_mt
|
||||
})
|
||||
end
|
||||
|
||||
vim.opt = setmetatable({}, create_option_metatable(SET_TYPES.SET))
|
||||
vim.opt_local = setmetatable({}, create_option_metatable(SET_TYPES.LOCAL))
|
||||
vim.opt_global = setmetatable({}, create_option_metatable(SET_TYPES.GLOBAL))
|
||||
vim.opt = create_option_accessor()
|
||||
vim.opt_local = create_option_accessor('local')
|
||||
vim.opt_global = create_option_accessor('global')
|
||||
|
||||
@@ -1421,7 +1421,7 @@ describe('lua stdlib', function()
|
||||
]]
|
||||
eq('', funcs.luaeval "vim.bo.filetype")
|
||||
eq(true, funcs.luaeval "vim.bo[BUF].modifiable")
|
||||
matches("unknown option 'nosuchopt'$",
|
||||
matches("no such option: 'nosuchopt'$",
|
||||
pcall_err(exec_lua, 'return vim.bo.nosuchopt'))
|
||||
matches("Expected lua string$",
|
||||
pcall_err(exec_lua, 'return vim.bo[0][0].autoread'))
|
||||
@@ -1442,7 +1442,7 @@ describe('lua stdlib', function()
|
||||
eq(0, funcs.luaeval "vim.wo.cole")
|
||||
eq(0, funcs.luaeval "vim.wo[0].cole")
|
||||
eq(0, funcs.luaeval "vim.wo[1001].cole")
|
||||
matches("unknown option 'notanopt'$",
|
||||
matches("no such option: 'notanopt'$",
|
||||
pcall_err(exec_lua, 'return vim.wo.notanopt'))
|
||||
matches("Expected lua string$",
|
||||
pcall_err(exec_lua, 'return vim.wo[0][0].list'))
|
||||
|
||||
Reference in New Issue
Block a user