lazy.nvim.nix/pkgs/luaUtils.nix

163 lines
4.1 KiB
Nix

{
lib,
pkgs,
extraAttrs ? { },
}:
with lib;
let
luaUtils = rec {
# Primitives
/**
Converts a nix null into its Lua representation.
Type:
nullToLua :: Null -> "nil"
*/
nullToLua =
nullValue:
assert builtins.isNull nullValue;
"nil";
/**
Converts a nix boolean into its Lua representation.
Type:
boolToLua :: Bool -> String
*/
boolToLua =
bool:
assert builtins.isBool bool;
if bool then "true" else "false";
/**
Converts a nix string into its Lua representation.
Type:
stringToLua :: String -> String
*/
stringToLua =
string:
assert builtins.isString string;
''"${string}"'';
/**
Nix lambdas are called with luaUtils as an argument, the result will be used as a raw value.
This function is used to insert unwrapped strings (like lua functions).
Type:
functionToLua :: lambda -> String
*/
functionToLua =
lambda:
assert builtins.isFunction lambda;
lambda (extraAttrs // { inherit luaUtils; });
/**
Converts a nix integer/float into its Lua representation.
Type:
numberToLua :: Int|Float -> String
*/
numberToLua =
number:
assert ((builtins.isInt number) || (builtins.isFloat number));
toString number;
/**
Converts a nix list into a Lua Table.
The resulting Lua table will have its brackets removed if the first element of the list is "__unpack".
Type:
listToLua :: List -> String
*/
listToLua =
list:
assert builtins.isList list;
let
wrap = (lib.elemAt list 0) != "__unpack";
strippedList = if wrap then list else (lib.drop 1 list);
in
lib.concatStrings [
(optionalString wrap "{")
(concatStringsSep "," (map toLua strippedList))
(optionalString wrap "}")
];
/**
Converts a nix set into its Lua representation.
Derivations are converted to their string representation (outPath).
Sets are converted into Lua tables.
Sets take two special arguments:
__unpack (Bool): Removes the brackets around the resulting Lua table.
__posArgs (List): Positional arguments which precede the key value pairs.
Type:
setToLua :: Derivation|Set -> String
*/
setToLua =
set:
assert builtins.isAttrs set;
if (lib.isDerivation set) then
(stringToLua (builtins.toString set))
else if set != { } then
let
unpack = lib.optional (set ? __unpack) "__unpack";
posArgs = lib.optionals (set ? __posArgs) set.__posArgs;
strippedSet = (
attrsets.removeAttrs set [
"__unpack"
"__posArgs"
]
);
keyArgs = (mapAttrsToList (key: val: (_: "${key} = ${toLua val}")) strippedSet);
in
listToLua (unpack ++ posArgs ++ keyArgs)
else
"{}";
/**
A helper function to map nix data types to the correct function.
Type:
toLua :: Any -> String
*/
toLua = (
value:
let
# can be: null, bool, string, path, int, float, list, set or lambda
type = builtins.typeOf value;
in
assert
!(builtins.isFunction type)
|| builtins.throw "Nix functions (${type}) have no correspoinding Lua representation.";
{
"null" = nullToLua;
"bool" = boolToLua;
"string" = stringToLua;
"lambda" = functionToLua;
"path" = stringToLua;
"int" = numberToLua;
"float" = numberToLua;
"list" = listToLua;
"set" = setToLua;
}
."${type}"
value
);
/**
Writes a formatted Lua file containing ${text} to ${path}.lua
Type:
writeLuaFileDir :: Path -> String -> Derivation
*/
writeLuaFileDir =
path: text:
pkgs.writeTextFile rec {
inherit text;
destination = "/${path}.lua";
name = builtins.baseNameOf path;
checkPhase = ''
${pkgs.stylua}/bin/stylua $out/${destination}
'';
};
};
in
luaUtils