alternative `var=true` joining

[jdx]

right now we just use shell_words::join() to deal with the problem of using var=true which populates $usage_foo as a space-delimited string where each arg may itself contain spaces.

I believe this logic just puts ' around each element if it has spaces. This is very bash-specific though, so it might not be desirable when using a different language. I'm open to alternatives here like customizing the escape behavior, or potentially having multiple env vars for this purpose like this:

usage_foo = "1 '2 3' 4"
usage_foo_n = "3"
usage_foo_0 = "1"
usage_foo_1 = "2 3"
usage_foo_2 = "4"

I didn't go with that initially because I think it would be a huge pain in bash, but the nice thing about it is it's much more formal about this and doesn't require any escaping.

[docwhat]

Just an idea (brainstorming)...

Save all the variables in a variable as JSON and then have a toolkit that can re-hydrate
the variables via eval.

e.g.,

#USAGE arg "<foo>" var=#true

# usage sets these variables
__usage_variables='{ "foo": ["1", "2 3", 4] }'
foo="1 '2 3' 4"

# We can re-hydrate usage_foo:
eval "$(usage toolkit bash)"

# Now the variables look like this:
foo=(1 '2 3' 4)

🤔 Now that I think about it, having a tool that converts a limited subset of JSON into variables in bash is generally useful for passing around structured data.

There is one downside to this, though... since usage is passing in the arguments by exporting environment variables this will more than double the amount of environment memory being used by the process (and any child processes that don't have their environments reset).

The maximum amount of environment variables is determined by the maximum you can pass to execve() in the Linux kernel.

The size of a single variable is the size of the name of the variable + the size of the value + 2. They are stored in text lines as NAME=VALUE\n.

The maximum size of a single environment variable in Linux is MAX_ARG_STRLEN which is usually 128kb, depending on the PAGESIZE of the kernel.

I think the maximum size of environment variable space is MAX_ARGS * MAX_ARG_STRLEN, but it would be really hard to use all that because it assumes that you are using maximum size variables for every variable.

I don't remember how this works in Windows.

On macOs it's the kern.argmax value:

$ sysctl kern.argmax
kern.argmax: 1048576

[docwhat]

FYI for anyone who trips across this issue trying to figure out how to use var=#true args with @ in usage today...

# Prevent shellcheck from having a cow.
files=()
# shellcheck disable=SC2154
eval "files=(${usage_file})"

printf "file: %q\n" "${files[@]}"

[docwhat]

I believe this logic just puts ' around each element if it has spaces. This is very bash-specific though, so it might not be desirable when using a different language.

FYI: It's POSIX shell, not only bash. 😜