Hey, you're welcome, thanks for using it and your question.

The problem here is that the obj variable is not exported by your shell. Because jb runs json.bash in a new bash shell, the obj variable is not visible unless it's exported. If I run this myself I see:

$ foo=bar
$ obj={\"foo\":\"${foo}\"}
$ jb @obj:json
json(): Could not process argument '@obj:json'. Its value references unbound variable $obj. (Use the '~' flag after the :type to treat a missing value as empty.)
␘

I assume you're writing a shell script in bash yourself (rather than using the shell interactively). In this case the best thing to do is to use the json function instead of jb. The difference is that json is just a bash function, so it runs in the same bash process as the rest of your code and can see the bash variables without exporting them. Whereas jb runs a new bash process that itself calls json, so it can only see variables that the calling process exports.

So you should be able to do this:

source json.bash  # need to import the functions to use them in your script

foo=bar
obj={\"foo\":\"${foo}\"}
json @obj:json  # outputs: {"obj":{"foo":"bar"}}

If you were doing it interactively, you can either explicitly export obj, or define obj while running jb:

$ foo=bar
$ obj={\"foo\":\"${foo}\"}

$ obj=${obj:?} jb @obj:json
{"obj":{"foo":"bar"}}

$ export obj
$ jb @obj:json
{"obj":{"foo":"bar"}}

As an aside, if you're writing a script and would like to have the best performance, you can use the out argument of the json function to have it encode into a variable rather than printing to stdout. This allows you to capture the output without capturing stdout (which often requires forking a subshell):

source json.bash
foo=bar
out=obj json @foo  # this encodes into the $obj variable
json @obj:json  # prints: {"obj":{"foo":"bar"}}

A tip is to use declare -p to inspect bash variables, e.g. here we can see it created an array;

$ declare -p obj
declare -a obj=([0]="{\"foo\":\"bar\"}")

You could append another JSON value to the array by using out=obj again:

$ out=obj json test:number=123

$ # now we have two values in obj (I should probably have renamed the var 🙃)
$ declare -p obj
declare -a obj=([0]="{\"foo\":\"bar\"}" [1]="{\"test\":123}")

$ # So we can create an array with the values it holds
$ json @obj:json[]
{"obj":[{"foo":"bar"},{"test":123}]}

$ # or flatten them as properties
$ json ...@obj:json{:json}
{"foo":"bar","test":123}

And if you don't mind forking (not a big issue unless you're doing something thousands of times), you can simplify it by using process substitution to nest json calls:

$ json obj:json@<(json foo=bar)
{"obj":{"foo":"bar"}}

Hope that helps, let me know if you have trouble.

Variable usage #10

Description

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions