Prepend ENV variables

[jessevdp]

I find myself in a situation where I'd like to prepend (or append) something to an ENV variable in the wrapper (XDG_CONFIG_DIRS for example). Nix makeWrapper has flags like --prefix VAR SEP VAL to make this pretty seamless.

Is something similar supported for wrapModule?

Right now all I could come up with is something like the following, which feels pretty verbose with all the escaping etc.

env = {
  MY_VAR = "something\${MY_VAR:+:$MY_VAR}";
};

[Lassulus]

hmm, I think this should work:

env.MY_VAR = "something:$MY_VAR";

is this not enough or are there other issues? I guess we could want a default value if MY_VAR is not set?

[jessevdp]

If MYVAR wasn't defined it results in an error:

/nix/store/...-neovim-unwrapped/bin/nvim: line 8: MYVAR: unbound variable

The ${var:+$OTHER} part means "If var set, evaluate expression as $OTHER, otherwise as null string". (source)

So: if MYVAR is set, use :$MYVAR, else "".

I'm basically attempting to be safe and avoid a trailing : here :)

[Lassulus]

maybe we can define a simple helper in wlib, usage would maybe look like this:

env.MY_VAR = "something:${wlib.env "MY_VAR"}";

but this could have still the trailing : problem.

maybe something like

env.MY_VAR = wlib.env.build { sep = ":"; values = [ "something" "$MY_VAR" ]; };

or something like

env.MY_VAR = "something${wlib.env.get ":" "MY_VAR"}";

[jessevdp]

perhaps something like this? taking inspiration from makeWrapper (--prefix VAR SEP VAL)

env.MY_VAR = wlib.env.prefix "MY_VAR" ":" config.my_var_thingy

or with named arguments

env.MY_VAR = wlib.env.prefix { var = "MY_VAR"; separator = ":"; value = config.my_var_thingy; };

(although that feels overly verbose)

we could support the same range of utilities as makeWrapper even:

env.MY_VAR = wlib.env.prefix "MY_VAR" ":" "A"                  # ENV SEP VAL   : suffix/prefix ENV with VAL, separated by SEP
env.MY_VAR = wlib.env.suffix "MY_VAR" ":" "A"
env.MY_VAR = wlib.env.prefixEach "MY_VAR" ":" [ "A" "B" "C" ]; # same as prefix but for each item in the list
env.MY_VAR = wlib.env.suffixEach "MY_VAR" ":" [ "A" "B" "C" ]; # same as suffix but for each item in the list

[Lassulus]

hmm, the problem with prefix and suffix is that they don't compose very well, or composing gets very complex. if I want to prefix and suffix variables the overhead gets quite a lot.
So my preference would be to just handle the access to env special in the construction instead of handling the static values special. Not sure I explain it good enough.

I think prefix and suffix are in itself a bit clunky and a bit clunky and list construction in nix (with mkBefore and mkAfter) are the primitives we could use here instead

[jessevdp]

Hm yeah when writing a makeWrapper script you get to use the --prefix/suffix flag multiple times to "build" your ENV var.

...
--prefix MY_VAR : "A" \
--suffix MY_VAR : "B" \
...

Here, you got to assign it a single time. So with my approach you don't get to both prefix and suffix I suppose, unless you save to an intermediary variable or something (messy).

env.MY_VAR_1 = wlib.env.prefix "MY_VAR" ":" "A"
env.MY_VAR = wlib.env.suffix "MY_VAR_1" ":" "A"

My bad! That's horrible.

Aside from building it like this in wrapModule you somehow also need to be able to overwrite it via apply, but idk if you should be able to "extend" it via there too? Not sure how that would even work... (I'm a bit of a noob when it comes to Nix..)

Looking at this, I actually really like the build variant you proposed. You get to specify all of the entries including "maybe existing" env vars.

env.MYVAR = wlib.env.build {
  sep = ":";
  values = [
    "A"
    "B"
    "$MYVAR"
    "C"
    "$MYVAR2"
  ];
};

I wonder how you'd nicely do the "if env exists" checks from here? You're basically having to find all the values that start with $ and then wrap it so it's "only if it exists, in bash.

MYVAR="A:B${MYVAR:+:$MYVAR}:C${MYVAR2:+:$MYVAR2}"

The suffix only case is a bit different though:

env.MYVAR = wlib.env.build {
  sep = ":";
  values = [
    "$MYVAR"
    "C"
  ];
};

Because the first element is "maybe null" at runtime we have to use the operator slightly differently:

MYVAR="${MYVAR:+$MYVAR:}C"

Also, do you suppose it's ok to just do this for entries that start with a $? It feels a bit magic, but it might be OK since it's under wlib.env.xxx.

The alternative I can come up with just feel clunky...: values = [ "A" { env = "MYVAR" } "B" ];

[Lassulus]

I think the nicest way would be a new option, that does to env what flags does to args, basically constructing it in a nicer way. Currently unsure about the name, but the interface could be something like:

envBuilder.MYVAR = {
  separator = ":"; # : is also the default
  list = [ "A" "B" (wlib.env "MYVAR") "C" ];
};

this would render into this:

env.MYVAR = "A:B:\${MYVAR:+:$MYVAR}:C";

we could also detect if the first element is a var and handle it special when convertig from envBuilder to env. We just need to find better names now for envBuilder and list :)

[jessevdp]

Yeah that’s probably best!

I guess list should just be values.

envBuilder is harder to name.. 🤔

[jessevdp]

BTW, this env builder should probably also strip out null / empty-string entries.