Huge progress on korora-based tempest generation
This commit is contained in:
Matei Adriel
parent
63d980ddf9
commit
42cd073278
|
|
@ -1,11 +1,14 @@
|
|||
local M = {}
|
||||
|
||||
function M.setup()
|
||||
vim.opt.runtimepath:append(vim.g.nix_extra_runtime)
|
||||
local tempest = require("my.tempest")
|
||||
local nix = require("nix")
|
||||
-- Import my other files
|
||||
require("my.options").setup()
|
||||
tempest.configureMany(nix.pre)
|
||||
require("my.keymaps").setup()
|
||||
require("my.lazy").setup()
|
||||
require("my.abbreviations").setup()
|
||||
tempest.configureMany(nix.post)
|
||||
end
|
||||
|
||||
return M
|
||||
|
|
|
|||
|
|
@ -55,92 +55,11 @@ end
|
|||
-- }}}
|
||||
|
||||
function M.setup()
|
||||
-- {{{ Free up q and Q
|
||||
M.move("q", "yq", { desc = "Record macro" })
|
||||
M.move("Q", "yQ")
|
||||
-- }}}
|
||||
-- {{{ Easier access to <C-^>
|
||||
M.move("<C-^>", "<Leader>a", { desc = "[A]lternate file" })
|
||||
-- }}}
|
||||
-- {{{ Quit all buffers
|
||||
M.nmap("Q", ":wqa<cr>", "Save all files and [q]uit")
|
||||
-- }}}
|
||||
-- {{{ Replace word in file
|
||||
M.nmap("<leader>rw", ":%s/<C-r><C-w>/", "[R]eplace [w]ord in file")
|
||||
-- }}}
|
||||
-- {{{ Toggle settings
|
||||
M.nmap(
|
||||
"<leader>sw",
|
||||
require("my.helpers.wrapMovement").toggle,
|
||||
"toggle word [w]rap"
|
||||
)
|
||||
-- }}}
|
||||
-- {{{ Text objects
|
||||
M.delimitedTextobject("q", '"', "[q]uotes")
|
||||
M.delimitedTextobject("a", "'", "[a]postrophes")
|
||||
M.delimitedTextobject("r", "[", "squa[r]e brackets")
|
||||
-- }}}
|
||||
-- {{{Diagnostic keymaps
|
||||
M.nmap("[d", vim.diagnostic.goto_prev, "Goto previous [d]iagnostic")
|
||||
M.nmap("]d", vim.diagnostic.goto_next, "Goto next [d]iagnostic")
|
||||
M.move("J", "qj")
|
||||
M.nmap("J", vim.diagnostic.open_float, "Open current diagnostic")
|
||||
M.nmap("<leader>D", vim.diagnostic.setloclist, "[D]iagnostic loclist")
|
||||
-- }}}
|
||||
-- {{{ Chords (save, clipboard)
|
||||
-- Different chords get mapped to f keys by a custom script of mine.
|
||||
-- In the future, I might get this on my keyboard firmware.
|
||||
vim.keymap.set({ "i", "v" }, "<f10>", "<Esc>", { desc = "Exit insert mode" }) -- Exit inset mode using *jk*
|
||||
vim.keymap.set({ "n", "v" }, "<f11>", '"+', { desc = "Use global clipboard" }) -- Use global clipboard with *cp*
|
||||
M.nmap("<f12>", "<cmd>silent write<cr>", "Save current file", true) -- Save using *ji*
|
||||
-- }}}
|
||||
-- {{{ Shift-Enter for not continuing the current comment
|
||||
-- This does not preserve intendation. Not sure what a better solution would look like.
|
||||
vim.keymap.set("i", "<S-CR>", function()
|
||||
vim.paste({ "", "" }, -1)
|
||||
end, { desc = "Insert newline without continuing the current comment" })
|
||||
-- }}}
|
||||
-- {{{ Allow quiting basic buffers with "qq"
|
||||
vim.api.nvim_create_autocmd("FileType", {
|
||||
pattern = { "help" },
|
||||
group = vim.api.nvim_create_augroup("BasicBufferQuitting", {}),
|
||||
callback = function(event)
|
||||
vim.keymap.set(
|
||||
"n",
|
||||
"qq",
|
||||
"<cmd>close<cr>",
|
||||
{ buffer = event.buf, silent = true, desc = "[q]uit current buffer" }
|
||||
)
|
||||
end,
|
||||
})
|
||||
-- }}}
|
||||
-- {{{ Winblend
|
||||
vim.api.nvim_create_autocmd("FileType", {
|
||||
pattern = { "*" },
|
||||
group = vim.api.nvim_create_augroup("WinblendSettings", {}),
|
||||
callback = function()
|
||||
vim.opt.winblend = 0
|
||||
end,
|
||||
})
|
||||
-- }}}
|
||||
-- {{{ Manage cmdheight
|
||||
vim.api.nvim_create_autocmd("CmdlineEnter", {
|
||||
group = vim.api.nvim_create_augroup("SetCmdheightCmdlineEnter", {}),
|
||||
callback = function()
|
||||
if not vim.g.inside_venn then
|
||||
vim.opt.cmdheight = 1
|
||||
end
|
||||
end,
|
||||
})
|
||||
vim.api.nvim_create_autocmd("CmdlineLeave", {
|
||||
group = vim.api.nvim_create_augroup("SetCmdheightCmdlineLeave", {}),
|
||||
callback = function()
|
||||
if not vim.g.inside_venn then
|
||||
vim.opt.cmdheight = 0
|
||||
end
|
||||
end,
|
||||
})
|
||||
-- }}}
|
||||
end
|
||||
|
||||
return M
|
||||
|
|
|
|||
|
|
@ -7,8 +7,8 @@ end
|
|||
function M.setup()
|
||||
require("lazy").setup({
|
||||
importFrom("my.plugins"),
|
||||
importFrom("nix.plugins"),
|
||||
importFrom("my.plugins.themes"),
|
||||
unpack(require("nix").lazy),
|
||||
}, {
|
||||
defaults = { lazy = true },
|
||||
install = {
|
||||
|
|
|
|||
|
|
@ -119,17 +119,26 @@ end
|
|||
|
||||
function M.configure(opts, context)
|
||||
if type(opts) == "function" then
|
||||
return M.configure(opts(context), context)
|
||||
opts = opts(context)
|
||||
end
|
||||
|
||||
if type(opts.mk_context) == "function" then
|
||||
context = opts.mk_context(context)
|
||||
if type(opts) ~= "table" then
|
||||
-- TODO: throw
|
||||
return
|
||||
end
|
||||
|
||||
if type(opts.mkContext) == "function" then
|
||||
context = opts.mkContext(context)
|
||||
end
|
||||
|
||||
if type(opts.vim) == "table" then
|
||||
recursive_assign(opts.vim, vim)
|
||||
end
|
||||
|
||||
if type(opts.keys) == "function" then
|
||||
opts.keys = opts.keys(context)
|
||||
end
|
||||
|
||||
if type(opts.keys) == "table" then
|
||||
local keys = opts.keys
|
||||
|
||||
|
|
@ -143,6 +152,10 @@ function M.configure(opts, context)
|
|||
end
|
||||
end
|
||||
|
||||
if type(opts.autocmds) == "function" then
|
||||
opts.autocmds = opts.autocmds(context)
|
||||
end
|
||||
|
||||
if type(opts.autocmds) == "table" then
|
||||
local autocmds = opts.autocmds
|
||||
|
||||
|
|
@ -180,8 +193,10 @@ function M.configure(opts, context)
|
|||
end
|
||||
end
|
||||
|
||||
M.lazy = function(lazy, opts, spec)
|
||||
return M.configure(spec, { lazy = lazy, opts = opts })
|
||||
function M.configureMany(specs, context)
|
||||
for _, spec in ipairs(specs) do
|
||||
M.configure(spec, context)
|
||||
end
|
||||
end
|
||||
-- }}}
|
||||
-- {{{ Neovim env handling
|
||||
|
|
@ -230,30 +245,47 @@ end
|
|||
-- {{{ Fixup lazy spec generated by nix
|
||||
function M.prepareLazySpec(spec)
|
||||
for _, module in ipairs(spec) do
|
||||
if spec.tempest ~= nil then
|
||||
spec.config = function(lazy, opts)
|
||||
M.configure(spec.tempest, { lazy = lazy, opts = opts })
|
||||
if module.package ~= nil then
|
||||
module[1] = module.package
|
||||
module.package = nil
|
||||
end
|
||||
|
||||
local configType = type(module.config)
|
||||
if configType == "function" or configType == "table" then
|
||||
local previousConfig = module.config
|
||||
module.config = function(lazy, opts)
|
||||
M.configure(previousConfig, { lazy = lazy, opts = opts })
|
||||
end
|
||||
end
|
||||
|
||||
if spec.dependencies ~= nil then
|
||||
spec.dependencies = spec.dependencies.lua
|
||||
if module.keys ~= nil then
|
||||
if type(module.keys) == "string" or module.keys.mapping ~= nil then
|
||||
module.keys = { module.keys }
|
||||
end
|
||||
|
||||
if spec.keys ~= nil then
|
||||
local keys = spec.keys
|
||||
if spec.keys.mapping ~= nil then
|
||||
keys = { keys }
|
||||
end
|
||||
|
||||
for _, key in ipairs(keys) do
|
||||
for _, key in ipairs(module.keys) do
|
||||
if type(key) ~= "string" then
|
||||
key[1] = key.mapping
|
||||
key.mapping = nil
|
||||
if key.mode ~= nil then
|
||||
key.mode = H.string_chars(key.mode)
|
||||
end
|
||||
if key.action ~= nil then
|
||||
key[2] = key.action
|
||||
key.action = nil
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
if type(module.cond) == "table" then
|
||||
local final = true
|
||||
for _, cond in ipairs(module.cond) do
|
||||
final = final and cond
|
||||
end
|
||||
module.cond = final
|
||||
end
|
||||
end
|
||||
end
|
||||
-- }}}
|
||||
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -2,52 +2,78 @@
|
|||
let
|
||||
k = korora;
|
||||
|
||||
# {{{ Lua encoders
|
||||
# {{{ Helpers
|
||||
helpers = rec {
|
||||
xor = a: b: (a || b) && (!a || !b);
|
||||
implies = a: b: !a || b;
|
||||
hasProp = obj: p: (obj.${p} or null) != null;
|
||||
propXor = a: b: obj: xor (hasProp obj a) (hasProp obj b);
|
||||
removeEmptyLines = str:
|
||||
lib.pipe str [
|
||||
(lib.splitString "\n")
|
||||
(lib.lists.filter
|
||||
(line: lib.any
|
||||
(c: c != " ")
|
||||
(lib.stringToCharacters line)))
|
||||
(lib.concatStringsSep "\n")
|
||||
];
|
||||
|
||||
# {{{ Verification helpers
|
||||
toPretty = lib.generators.toPretty { indent = " "; };
|
||||
withError = cond: err: if cond then null else err;
|
||||
hasProp = obj: p: obj ? ${p};
|
||||
propExists = p: obj:
|
||||
helpers.withError
|
||||
(helpers.hasProp obj p)
|
||||
"Expected property ${p}";
|
||||
propXor = a: b: obj:
|
||||
helpers.withError
|
||||
((hasProp obj a) != (hasProp obj b))
|
||||
"Expected only one of the properties ${a} and ${b} in object ${toPretty obj}";
|
||||
propOnlyOne = props: obj:
|
||||
1 == lib.count (prop: obj ? prop);
|
||||
propImplies = a: b: obj: implies (hasProp obj a) (hasProp obj b);
|
||||
helpers.withError
|
||||
(1 == lib.count (hasProp obj) props)
|
||||
"Expected exactly one property from the list ${toPretty props} in object ${toPretty obj}";
|
||||
propImplies = a: b: obj:
|
||||
helpers.withError
|
||||
((hasProp obj a) -> (hasProp obj b))
|
||||
"Property ${a} should imply property ${b} in object ${toPretty obj}";
|
||||
mkVerify = checks: obj:
|
||||
assert lib.all lib.isFunction checks;
|
||||
let
|
||||
results = lib.lists.map checks obj;
|
||||
results = lib.lists.map (c: c obj) checks;
|
||||
errors = lib.lists.filter (v: v != null) results;
|
||||
in
|
||||
assert lib.all lib.isString errors;
|
||||
if errors == [ ]
|
||||
then null
|
||||
else
|
||||
let prettyErrors =
|
||||
lib.lists.map (s: "\n- ${s}") errors;
|
||||
in
|
||||
"Multiple errors occured: ${prettyErrors}";
|
||||
|
||||
"Multiple errors occured: ${lib.concatStrings prettyErrors}";
|
||||
# }}}
|
||||
# {{{ Custom types
|
||||
intersection = l: r:
|
||||
k.typedef'
|
||||
"${l.name} ∧ ${r.name}"
|
||||
(helpers.mkVerify [ l r ]);
|
||||
|
||||
dependentAttrsOf =
|
||||
name: mkType:
|
||||
let
|
||||
typeError = name: v: "Expected type '${name}' but value '${toPretty v}' is of type '${typeOf v}'";
|
||||
addErrorContext = context: error: if error == null then null else "${context}: ${error}";
|
||||
|
||||
withErrorContext = addErrorContext "in ${name} value";
|
||||
in
|
||||
k.typedef' name
|
||||
(v:
|
||||
if ! lib.isAttrs v then
|
||||
typeError name v
|
||||
else
|
||||
withErrorContext
|
||||
(mkVerify
|
||||
(lib.mapAttrsToList (k: _: mkType k) v)
|
||||
v));
|
||||
|
||||
# dependentAttrsOf =
|
||||
# name: mkType:
|
||||
# let
|
||||
# typeError = name: v: "Expected type '${name}' but value '${toPretty v}' is of type '${typeOf v}'";
|
||||
# addErrorContext = context: error: if error == null then null else "${context}: ${error}";
|
||||
#
|
||||
# withErrorContext = addErrorContext "in ${name} value";
|
||||
# in
|
||||
# k.typedef' name
|
||||
# (v:
|
||||
# if ! lib.isAttrs v then
|
||||
# typeError name v
|
||||
# else
|
||||
# withErrorContext
|
||||
# (mkVerify
|
||||
# (lib.mapAttrsToList (k: _: mkType k) v)
|
||||
# v));
|
||||
# }}}
|
||||
# {{{ Encoding helpers
|
||||
mkRawLuaObject = chunks:
|
||||
''
|
||||
{
|
||||
|
|
@ -55,238 +81,83 @@ let
|
|||
}
|
||||
'';
|
||||
|
||||
encodeString = given: ''"${lib.escape ["\"" "\\"] (toString given)}"'';
|
||||
|
||||
mkAttrName = s:
|
||||
let
|
||||
# These list *are* incomplete
|
||||
forbiddenChars = lib.stringToCharacters "<>[]{}()'\".,;";
|
||||
forbiddenChars = lib.stringToCharacters "<>[]{}()'\".,:;";
|
||||
keywords = [ "if" "then" "else" "do" "for" "local" "" ];
|
||||
in
|
||||
if lib.any (c: lib.hasInfix c s) forbiddenChars || lib.elem s keywords then
|
||||
"[${m.string s}]"
|
||||
"[${helpers.encodeString s}]"
|
||||
else s;
|
||||
|
||||
# }}}
|
||||
};
|
||||
# }}}
|
||||
|
||||
# We provide a custom set of helpers for generating lua code for nix.enable
|
||||
#
|
||||
# An encoder is a function from some nix value to a string containing lua code.
|
||||
# This object provides combinators for writing such encoders.
|
||||
m = {
|
||||
# {{{ General helpers
|
||||
typed = type: toLua: type // {
|
||||
unsafeToLua = toLua;
|
||||
toLua = v: toLua (type.check v);
|
||||
override = a: m.typed (type.override a) toLua;
|
||||
};
|
||||
withDefault = type: default: type // {
|
||||
default.value = default;
|
||||
};
|
||||
typedWithDefault = type: toLua: default:
|
||||
m.withDefault (m.typed type toLua) default;
|
||||
unsafe = type: type // { toLua = type.unsafeToLua; };
|
||||
untyped = m.typed k.any;
|
||||
untype = type: m.untyped type.toLua;
|
||||
withName = name: type: type // { inherit name; }; # TODO: should we use override here?
|
||||
# `const` is mostly useful together with `bind`. See the lua encoder for
|
||||
# lazy modules for example usage.
|
||||
const = code: m.untyped (_: code);
|
||||
# Conceptually, this is the monadic bind operation for encoders.
|
||||
# This implementation is isomoprhic to that of the reader monad in haskell.
|
||||
bind = name: higherOrder:
|
||||
m.typed
|
||||
(k.typedef' name (v: (higherOrder v).verify v))
|
||||
(given: (higherOrder given).toLua given);
|
||||
# This is probably the most useful combinnator defined in this entire object.
|
||||
# Most of the combinators in the other categories are based on this.
|
||||
conditional = predicate: caseTrue: caseFalse:
|
||||
let base = m.bind
|
||||
m.bind
|
||||
"${caseTrue.name} ∨ ${caseFalse.name}"
|
||||
(given: if predicate given then caseTrue else caseFalse);
|
||||
in
|
||||
if caseTrue ? default then
|
||||
m.withDefault base caseTrue.default
|
||||
else if caseFalse ? default then
|
||||
m.withDefault base caseFalse.default
|
||||
else
|
||||
base;
|
||||
try = caseTrue: caseFalse:
|
||||
let base = m.bind
|
||||
"${caseTrue.name} ∨ ${caseFalse.name}"
|
||||
(given: if caseTrue.verify given == null then m.unsafe caseTrue else caseFalse);
|
||||
in
|
||||
if caseTrue ? default then
|
||||
m.withDefault base caseTrue.default
|
||||
else if caseFalse ? default then
|
||||
m.withDefault base caseFalse.default
|
||||
else
|
||||
base;
|
||||
oneOf = lib.foldr m.try
|
||||
(m.bottom (v: "No variants matched for value ${builtins.toJSON v}"));
|
||||
# This is simply left-composition of functions
|
||||
cmap = f: t:
|
||||
m.typed
|
||||
(lib.typedef' t.name (v: t.verify (f v)))
|
||||
(given: t.toLua (f given));
|
||||
# This is simply right-composition of functions
|
||||
map = f: t: m.typed t (given: f (t.toLua given));
|
||||
filter = predicate: type: given:
|
||||
m.conditional predicate type (m.untype m.nil);
|
||||
# This is mostly useful for debugging
|
||||
trace = message: m.cmap (f: lib.traceSeq message (lib.traceVal f));
|
||||
bottom = mkMessage: m.typed (m.typedef "⊥" mkMessage) lib.id;
|
||||
# }}}
|
||||
# {{{ Base types
|
||||
string = m.typed k.string (given: ''"${lib.escape ["\"" "\\"] (toString given)}"'');
|
||||
bool = m.typed k.bool (bool: if bool then "true" else "false");
|
||||
integer = m.typed k.int toString;
|
||||
float = m.typed k.float toString;
|
||||
number = m.typed k.number toString;
|
||||
ignored = type: m.typed type (_: "nil");
|
||||
nil = m.typedWithDefault
|
||||
(k.typedef "null" (v: v == null))
|
||||
(_: "nil")
|
||||
null;
|
||||
stringOr = m.try m.string;
|
||||
boolOr = m.try m.bool;
|
||||
numberOr = m.try m.number;
|
||||
nullOr = m.try m.nil;
|
||||
anything = m.withName "⊤" (m.oneOf [
|
||||
m.markedLuaCode # Lua code expressions have priority over attrsets
|
||||
m.string
|
||||
m.number
|
||||
m.bool
|
||||
m.null
|
||||
(m.listOf m.anything)
|
||||
(m.attrsetOf m.anything)
|
||||
]);
|
||||
# }}}
|
||||
# {{{ Lua code
|
||||
identity = m.typed k.string lib.id;
|
||||
markedLuaCode =
|
||||
m.typed
|
||||
(k.struct "marked lua code" {
|
||||
value = k.string;
|
||||
__luaEncoderTag = k.enum "lua encoder tag" [ "lua" ];
|
||||
})
|
||||
(obj: obj.value);
|
||||
# This is the most rudimentary (and currently only) way of handling paths.
|
||||
luaImport = tag:
|
||||
m.typed (k.typedef "path" lib.isPath)
|
||||
(path: "dofile(${m.string "${path}"}).${tag}");
|
||||
# Accepts both tagged and untagged strings of lua code.
|
||||
luaString = m.try m.markedLuaCode m.identity;
|
||||
# This simply combines the above combinators into one.
|
||||
luaCode = tag: m.try (m.luaImport tag) m.luaString;
|
||||
# }}}
|
||||
# {{{ Operators
|
||||
conjunction = left: right: given:
|
||||
m.typed (helpers.intersection left right) (
|
||||
# {{{ This function takes a nix value and encodes it to a lua string.
|
||||
isLuaLiteral = given: lib.isAttrs given && given.__luaEncoderTag or null == "lua";
|
||||
encodeWithDepth = depth: given:
|
||||
let recurse = encodeWithDepth depth; in
|
||||
if lib.isString given || lib.isDerivation given || lib.isPath given then
|
||||
helpers.encodeString given
|
||||
else if lib.isInt given || lib.isFloat given then
|
||||
toString given
|
||||
else if lib.isBool given then
|
||||
if given then "true" else "false"
|
||||
else if given == null then
|
||||
"nil"
|
||||
else if lib.isList given then
|
||||
helpers.mkRawLuaObject (lib.lists.map recurse given)
|
||||
else if lib.isAttrs given && given.__luaEncoderTag or null == "foldedList" then
|
||||
let
|
||||
l = left.toLua given;
|
||||
r = right.toLua given;
|
||||
makeFold = name: value: ''
|
||||
-- {{{ ${name}
|
||||
${recurse value},
|
||||
-- }}}'';
|
||||
folds = lib.mapAttrsToList makeFold given.value;
|
||||
in
|
||||
if l == "nil" then r
|
||||
else if r == "nil" then l
|
||||
else "${l} and ${r}"
|
||||
);
|
||||
all = lib.foldr m.conjunction m.nil;
|
||||
# Similar to `all` but takes in a list and
|
||||
# treats every element as a condition.
|
||||
allIndices = name: type:
|
||||
m.bind name
|
||||
(g: lib.pipe g [
|
||||
(lib.lists.imap0
|
||||
(i: _:
|
||||
m.cmap
|
||||
(builtins.elemAt i)
|
||||
type))
|
||||
m.all
|
||||
]);
|
||||
# }}}
|
||||
# {{{ Lists
|
||||
listOf = type: list:
|
||||
m.typedWithDefault
|
||||
(k.listOf type)
|
||||
(helpers.mkRawLuaObject (lib.lists.map type.toLua list))
|
||||
[ ];
|
||||
listOfOr = type: m.try (m.listOf type);
|
||||
# Returns nil when given empty lists
|
||||
tryNonemptyList = type:
|
||||
m.typedWithDefault
|
||||
(k.listOf type)
|
||||
(m.filter
|
||||
(l: l != [ ])
|
||||
(m.listOf type))
|
||||
[ ];
|
||||
oneOrMany = type: m.listOfOr type type;
|
||||
# Can encode:
|
||||
# - zero values as nil
|
||||
# - one value as itself
|
||||
# - multiple values as a list
|
||||
zeroOrMany = type: m.nullOr (m.oneOrMany type);
|
||||
# Coerces non list values to lists of one element.
|
||||
oneOrManyAsList = type: m.listOfOr type (m.map (e: [ e ]) type);
|
||||
# Coerces lists of one element to said element.
|
||||
listAsOneOrMany = type:
|
||||
m.cmap
|
||||
(l: if lib.length l == 1 then lib.head l else l)
|
||||
(m.oneOrMany type);
|
||||
# }}}
|
||||
# {{{ Attrsets
|
||||
attrsetOf = type:
|
||||
m.typed (k.attrsOf type)
|
||||
(object:
|
||||
helpers.mkRawLuaObject (lib.mapAttrsToList
|
||||
''
|
||||
{
|
||||
${lib.concatStringsSep "\n" folds}
|
||||
}''
|
||||
else if isLuaLiteral given then
|
||||
given.value
|
||||
else if lib.isAttrs given then
|
||||
helpers.mkRawLuaObject
|
||||
(lib.mapAttrsToList
|
||||
(name: value:
|
||||
let result = type.toLua value;
|
||||
let result = recurse value;
|
||||
in
|
||||
lib.optionalString (result != "nil")
|
||||
"${helpers.mkAttrName name} = ${result}"
|
||||
)
|
||||
object
|
||||
)
|
||||
);
|
||||
# This is the most general combinator provided in this section.
|
||||
#
|
||||
# We accept:
|
||||
# - order of props that should be interpreted as list elements
|
||||
# - spec of props that should be interpreted as list elements
|
||||
# - record of props that should be interpreted as attribute props
|
||||
attrset = name: listOrder: spec: attrset:
|
||||
m.cmap
|
||||
(given: lib.mapAttrs
|
||||
(key: type:
|
||||
if given ? ${key} then
|
||||
given.${key}
|
||||
else
|
||||
type.default or null)
|
||||
spec)
|
||||
(m.typed (k.struct name spec) (
|
||||
given)
|
||||
else if lib.isFunction given then
|
||||
let
|
||||
listChunks = lib.lists.map
|
||||
(attr:
|
||||
let result = spec.${attr}.toLua (attrset.${attr} or null);
|
||||
argNames = [ "context" "inner_context" "local_context" ];
|
||||
secretArg =
|
||||
if depth >= builtins.length argNames
|
||||
then "arg_${depth}"
|
||||
else builtins.elemAt argNames depth;
|
||||
body = given secretArg;
|
||||
encoded = encodeWithDepth (depth + 1) body;
|
||||
encodedBody =
|
||||
if isLuaLiteral body
|
||||
then encoded
|
||||
else "return ${encoded}";
|
||||
in
|
||||
lib.optionalString (result != "nil") result
|
||||
)
|
||||
listOrder;
|
||||
objectChunks = lib.mapAttrsToList
|
||||
(attr: type:
|
||||
let result = type.toLua (attrset.${attr} or null);
|
||||
in
|
||||
lib.optionalString (!(lib.elem attr listOrder) && result != "nil")
|
||||
"${helpers.mkAttrName attr} = ${result}"
|
||||
)
|
||||
spec;
|
||||
in
|
||||
helpers.mkRawLuaObject (listChunks ++ objectChunks)
|
||||
));
|
||||
withAttrsCheck = type: verify:
|
||||
type.override { inherit verify; };
|
||||
# }}}
|
||||
};
|
||||
if lib.hasInfix secretArg encoded
|
||||
then ''
|
||||
function(${secretArg})
|
||||
${encodedBody}
|
||||
end''
|
||||
else ''
|
||||
function()
|
||||
${encodedBody}
|
||||
end''
|
||||
else builtins.throw "Cannot encode value ${helpers.toPretty given}";
|
||||
# }}}
|
||||
encode = encodeWithDepth 0;
|
||||
in
|
||||
m // { inherit helpers; }
|
||||
{ inherit encode helpers; }
|
||||
|
|
|
|||
|
|
@ -1,36 +1,234 @@
|
|||
attrs@{ lib, ... }:
|
||||
attrs@{ lib, korora, ... }:
|
||||
let
|
||||
e = import ./korora-lua.nix attrs;
|
||||
k = korora;
|
||||
h = e.helpers;
|
||||
m = {
|
||||
lazyModule = e.withAttrsCheck
|
||||
(e.attrset "lazy module" [ "package" ] {
|
||||
package = e.nullOr e.string;
|
||||
dir = e.nullOr e.type;
|
||||
version = e.nullOr e.string;
|
||||
tag = e.nullOr e.string;
|
||||
name = e.nullOr e.string;
|
||||
main = e.nullOr e.string;
|
||||
lazy = e.nullOr e.bool;
|
||||
dependencies = e.tryNonemptyList (e.stringOr m.lazyModule);
|
||||
config = e.anything;
|
||||
cond = e.nullOr (e.bind (value: e.all [
|
||||
# TODO: we want a zip here
|
||||
(e.nullOr (e.luaCode "cond"))
|
||||
]));
|
||||
init = e.nullOr (e.luaCode "init");
|
||||
event = e.zeroOrMany e.string;
|
||||
cmd = e.zeroOrMany e.string;
|
||||
ft = e.zeroOrMany e.string;
|
||||
keys = e.listOf e.anything;
|
||||
passthrough = e.anything;
|
||||
opts = e.anything;
|
||||
})
|
||||
(h.mkVerify [
|
||||
struct = name: props: verify: (k.struct name props).override {
|
||||
total = false;
|
||||
unknown = false;
|
||||
verify = h.mkVerify verify;
|
||||
};
|
||||
|
||||
lazyType = name: mkType: k.typedef' name (v: (mkType true).verify v);
|
||||
|
||||
types = {
|
||||
# {{{ Helper types
|
||||
oneOrMany = type: k.union [ type (k.listOf type) ];
|
||||
luaValue = k.any;
|
||||
strictLuaLiteral = (k.struct "lua literal" {
|
||||
value = k.string;
|
||||
__luaEncoderTag = k.enum "lua literal tag" [ "lua" ];
|
||||
}).override { unknown = false; };
|
||||
derivation = k.typedef "derivation" lib.isDerivation;
|
||||
path = k.typedef "path" lib.isPath;
|
||||
functionCheckedWith = arg: type:
|
||||
k.typedef'
|
||||
"${h.toPretty arg} -> ${type.name}"
|
||||
(f:
|
||||
if lib.isFunction f
|
||||
then type.verify (f arg)
|
||||
else "Expected function, but got ${h.toPretty f} instead");
|
||||
luaEagerOrLazy = type: k.union [ type (types.functionCheckedWith "" type) ];
|
||||
luaLiteral = types.luaEagerOrLazy types.strictLuaLiteral;
|
||||
# }}}
|
||||
# {{{ Lazy key
|
||||
lazyKey = struct "lazy key"
|
||||
{
|
||||
mapping = k.string;
|
||||
action = k.union [ types.luaLiteral k.string ];
|
||||
mode = k.string;
|
||||
desc = k.string;
|
||||
expr = k.bool;
|
||||
ft = types.oneOrMany k.string;
|
||||
}
|
||||
[ (h.propExists "mapping") ];
|
||||
# }}}
|
||||
# {{{ Lazy module
|
||||
lazyModule = lazyType "actually lazy lazy module" (_: struct "lazy module"
|
||||
{
|
||||
package = k.string;
|
||||
dir = k.union [ k.string types.derivation types.path ];
|
||||
version = k.string;
|
||||
tag = k.string;
|
||||
name = k.string;
|
||||
main = k.string;
|
||||
lazy = k.bool;
|
||||
dependencies = struct "lazy dependencies"
|
||||
{
|
||||
lua = k.listOf (k.union [ k.string types.lazyModule ]);
|
||||
nix = k.listOf types.derivation;
|
||||
}
|
||||
[ ];
|
||||
cond = types.oneOrMany types.luaLiteral;
|
||||
init = types.luaLiteral;
|
||||
config = k.union [ types.luaLiteral k.bool types.tempestConfig ];
|
||||
event = types.oneOrMany k.string;
|
||||
cmd = types.oneOrMany k.string;
|
||||
ft = types.oneOrMany k.string;
|
||||
keys = types.oneOrMany (k.union [ k.string types.lazyKey ]);
|
||||
passthrough = types.luaValue;
|
||||
opts = types.luaValue;
|
||||
}
|
||||
[
|
||||
(h.propOnlyOne [ "dir" "package" ])
|
||||
(h.propImplies "tag" "package")
|
||||
(h.propImplies "version" "package")
|
||||
]);
|
||||
# }}}
|
||||
# {{{ Tempest key
|
||||
tempestKey = struct "tempest key"
|
||||
{
|
||||
mapping = k.string;
|
||||
action = k.union [ types.luaLiteral k.string ];
|
||||
mode = k.string;
|
||||
desc = k.string;
|
||||
expr = k.bool;
|
||||
silent = k.bool;
|
||||
ft = types.oneOrMany k.string;
|
||||
buffer = k.union [ k.bool k.number types.luaLiteral ];
|
||||
}
|
||||
[
|
||||
(h.propExists "mapping")
|
||||
(h.propExists "action")
|
||||
];
|
||||
# }}}
|
||||
# {{{ Tempest autocmd
|
||||
tempestAutocmd = struct "tempest autocommand"
|
||||
{
|
||||
event = types.oneOrMany k.string;
|
||||
pattern = types.oneOrMany k.string;
|
||||
group = k.string;
|
||||
action = k.union [ types.tempestConfig types.luaLiteral ];
|
||||
}
|
||||
[
|
||||
(h.propExists "event")
|
||||
(h.propExists "group")
|
||||
(h.propExists "action")
|
||||
];
|
||||
# }}}
|
||||
# {{{ Tempest config
|
||||
tempestConfig = lazyType "lazy tempest config" (_: struct "tempest config"
|
||||
{
|
||||
vim = types.luaValue;
|
||||
callback = k.union [ k.function types.luaLiteral ];
|
||||
setup = k.attrsOf types.luaValue;
|
||||
keys = types.luaEagerOrLazy (types.oneOrMany types.tempestKey);
|
||||
autocmds = types.luaEagerOrLazy (types.oneOrMany types.tempestAutocmd);
|
||||
mkContext = types.luaLiteral;
|
||||
}
|
||||
[ ]);
|
||||
# }}}
|
||||
# {{{ Neovim env
|
||||
neovimEnv = k.enum "neovim env"
|
||||
[ "neovide" "firenvim" "vscode" ];
|
||||
# }}}
|
||||
# {{{ Neovim config
|
||||
neovimConfig = struct "neovim configuration"
|
||||
{
|
||||
pre = k.attrsOf types.tempestConfig;
|
||||
lazy = k.attrsOf types.lazyModule;
|
||||
post = k.attrsOf types.tempestConfig;
|
||||
} [ ];
|
||||
# }}}
|
||||
};
|
||||
|
||||
hasType = type: value:
|
||||
let err = type.verify value; in
|
||||
lib.assertMsg (err == null) err;
|
||||
|
||||
mkLib = { tempestModule, languageServerModule }:
|
||||
assert hasType k.string tempestModule;
|
||||
assert hasType k.string languageServerModule;
|
||||
rec {
|
||||
inherit (e) encode;
|
||||
# {{{ Common generation helpers
|
||||
lua = value: assert hasType k.string value;
|
||||
{ inherit value; __luaEncoderTag = "lua"; };
|
||||
import = path: tag:
|
||||
assert lib.isPath path;
|
||||
assert hasType k.string tag;
|
||||
lua "dofile(${encode (toString path)}).${tag}";
|
||||
foldedList = value: assert hasType k.attrs value;
|
||||
{ inherit value; __luaEncoderTag = "foldedList"; };
|
||||
thunk = code: _: lua code;
|
||||
tempest = given: context: lua ''
|
||||
D.tempest.configure(
|
||||
${encode given},
|
||||
${context}
|
||||
)
|
||||
'';
|
||||
customLanguageServerOnAttach = given:
|
||||
assert hasType types.tempestConfig given;
|
||||
lua /* lua */ ''
|
||||
function(client, bufnr)
|
||||
D.tempest.configure(${encode given},
|
||||
{ client = client; bufnr = bufnr; })
|
||||
|
||||
D.language_server.on_attach(client, bufnr)
|
||||
end
|
||||
'';
|
||||
blacklist = given:
|
||||
assert hasType (types.oneOrMany types.neovimEnv) given;
|
||||
lua /* lua */ ''
|
||||
D.tempest.blacklist(${encode given})
|
||||
'';
|
||||
whitelist = given:
|
||||
assert hasType (types.oneOrMany types.neovimEnv) given;
|
||||
lua /* lua */ ''
|
||||
D.tempest.whitelist(${encode given})
|
||||
'';
|
||||
# }}}
|
||||
# {{{ Main config generation entrypoint
|
||||
generateConfig = rawConfig:
|
||||
assert hasType types.neovimConfig rawConfig;
|
||||
let
|
||||
config = { lazy = { }; pre = { }; post = { }; } // rawConfig;
|
||||
collectNixDeps = lazyModule:
|
||||
if lazyModule ? dependencies then
|
||||
let
|
||||
nix = lazyModule.dependencies.nix or [ ];
|
||||
other = lib.pipe (lazyModule.dependencies.lua or [ ]) [
|
||||
(lib.lists.map collectNixDeps)
|
||||
lib.lists.flatten
|
||||
];
|
||||
in
|
||||
nix ++ other
|
||||
else
|
||||
[ ];
|
||||
dependencies = lib.pipe config.lazy [
|
||||
(lib.mapAttrsToList (_: collectNixDeps))
|
||||
lib.lists.flatten
|
||||
];
|
||||
processedLazyModules =
|
||||
lib.mapAttrs
|
||||
(name: module: { inherit name; } // module // {
|
||||
dependencies = (module.dependencies or { }).lua or null;
|
||||
})
|
||||
config.lazy;
|
||||
|
||||
luaConfig = ''
|
||||
local M = {}
|
||||
local D = {
|
||||
tempest = require(${encode tempestModule}),
|
||||
langauge_server = require(${encode languageServerModule})
|
||||
}
|
||||
|
||||
-- {{{ Pre-plugin config
|
||||
M.pre = ${encode (foldedList config.pre)}
|
||||
-- }}}
|
||||
-- {{{ Lazy modules
|
||||
M.lazy = ${encode (foldedList processedLazyModules)}
|
||||
D.tempest.prepareLazySpec(M.lazy)
|
||||
-- }}}
|
||||
-- {{{ Post-plugin config
|
||||
M.post = ${encode (foldedList config.post)}
|
||||
-- }}}
|
||||
|
||||
return M
|
||||
'';
|
||||
in
|
||||
{ inherit dependencies; lua = luaConfig; };
|
||||
# }}}
|
||||
};
|
||||
in
|
||||
m
|
||||
mkLib
|
||||
|
|
|
|||
|
|
@ -196,7 +196,7 @@ in
|
|||
let
|
||||
destination = "${path}/${name}.lua";
|
||||
unformatted = pkgs.writeText "raw-lua-${name}" ''
|
||||
-- ❄️ This file was generated using nix ^~^
|
||||
-- ❄️ I was generated using nix ^~^
|
||||
${text}
|
||||
'';
|
||||
in
|
||||
|
|
|
|||
Loading…
Reference in a new issue