lib.lua
lib.lua.rawLua
Type: rawLua :: String -> (a -> String)
Embed raw lua code in a nix expression.
code
The lua expression to embed
lib.lua.rawLua
usage example
x = rawLua "function(msg) print('hello ' .. msg) end"
toLua x
=> _: "function(msg) print('hello ' .. msg) end"
lib.lua.luaFile
Type: luaFile :: String -> (a -> String)
Embed raw lua code from a file into a nix expression.
The contents of file
is embedded as-is into the assigned variable.
file
Function argument
lib.lua.luaFile
usage example
builtins.readFile ./test.lua
=> "function(msg) print('hello ' .. msg) end"
x = luaFile ./test.lua
=> _: "function(msg) print('hello ' .. msg) end"
lib.lua.processPrimitive
Type: processPrimitive :: value -> String
Converts a primitive value to its stringified lua counterpart.
Types nil
, boolean
, number
, string
, and table
are convertable from
their respective nix-equivalents. Functions are supported in limited a
fashion; a passed function must be callable with exactly one argument (which
should be ignored in the implementation). The function must return raw lua
code (stringified). The following lambda is an example of such a valid
function:
foo = _: "function(msg) print('hello ' .. msg) end"
The remaining types userdata
and thread
are not able to be converted to.
value
Value to convert to stringified lua representation
lib.lua.processPrimitive
usage example
x = { a = "foo"; b = null }
processPrimitive x.a
=> "\"foo\""
processPrimitive x.b
=> "nil"
lib.lua.toLua
Type: toLua :: values -> String
Converts an attribute set, list, or primitive into its stringified lua representation.
Note on converting attribute sets: Since lua supports both named and unnamed
table values (but nix attrsets do not), a magic identifier __index__
is
used to convert from named values to anonymous ones. This identified may
occur anywhere inside the name. Note that since attrsets are implicitly
sorted by key names, you will need to lexicographically sort the keys which
you want to anonymize by hand, ex: zzz__index__
.
values
values to convert to lua
lib.lua.toLua
usage example
x = { a = { b = 3; }; __index__baz = "some string"; c = "foo"; d = null; }
y = "some string"
toLua x
=> ''
{ "some string", a = { b = 3 }, c = "foo", d = nil }
''
toLua y
=> "\"some string\""
lib.vim
lib.vim.processVimPrefs
processes each vim namespace (for example vim.g
or vim.o
) into
stringified lua code
ns
Function argument
values
Function argument
lib.vim.mkKeymap
Creates a lua keymap. Note that opts
may be omitted when using this
function. Although this results in a curried function, the internal keymap
module takes care of this by automatically adding an empty option set at
eval-time (see modules/core/keymap.nix
).
mode
Function argument
lhs
Function argument
rhs
Function argument
opts
Function argument
lib.vim.mkSimplePlugin
Type: mkSimplePlugin :: Attrs -> Attrs
Convenience wrapper for creating plugin modules. Note that this function simply returns a standard module, and as such is equivalent to you doing so.
structured function argument
: config
: The top-level config you have access to in your module.
plugin
: The plugin source (for instance a source produced by pkgs.fetchFromGitHub
).
category
: The path to expose your module options under. Each element correspons to a level of nesting in the config. For instace, category = ["foo" "bar"]
would expose the options: foo.bar = {...}
. You may also pass a string where each nested level is separated by a /
. For instance, "foo/bar"
is equivalent to the example above.
derivePluginNameFunc
: A function to derive the plugin name from the plugin source. The default implementation uses the repo
attribute from plugin
(assumes structure similar to a source produced by fetchFromGitHub
). The input to this function is plugin
. The output must be a string.
moduleName
: The name of the plugin to use in the module options. By default, the implmentation uses the result of derivePluginNameFunc
to derive the option namespace from the plugin source.
extraPluginConfig
: Extra options to pass to the lazy plugin spec. The function receives the plugin config at evaluation time as its only input. The output must be an attribute set, which is merged with the final spec. Any options which are accepted by layz's plugin spec should be valid.
noSetup
: Omit the opt
options from the final module as well as the plugin spec. You may want to use this if the plugin which you specify does not support a conventional setup()
function, for example a vimscript plugin which simply gets loaded.
extraModuleOpts
: Any extra module options to generate for this module. Standard option-conventions apply.
extraConfig
: Extra config
to generate for this module if it is enabled. This is merged with the final config. You may, for example, use this to set additional pre/post-hooks or set keymaps, etc.
lib.vim.mkSimplePlugin
usage example
myPluginSrc = pkgs.fetchFromGitHub {
owner = "aUser";
repo = "aRepo";
# ...
}
# From inside a module, call mkSimplePlugin:
# myModule.nix
{pkgs, config, lib, ...}: lib.mkSimplePlugin {
inherit config;
plugin = myPluginSrc;
category = [ "colorschemes" "myColorscheme"]
}