Does yq have an equivalent to jq --slurp?

[polarathene]

Similar to #1636 , there is also some issues like this one with solutions that do a merge of files into a top-level array or object via reduce:

yq eval-all '. as $item ireduce ([]; . + $item )' *.yaml

It would be nice if there was a command flag that merged the inputs into a single array like jq can via --slurp?

---

jq comparison

arg-1.json:

{ "arg": "hello" }

arg-2.json:

{ "arg": "world" }

# `-s` / `--slurp` merges input into an array, which can then be operated on and joined into single string:
$ jq -sr 'map("--arg " + .arg) | join(" ")' arg-*.json
--arg hello --arg world

# Separate array per document without `--slurp`:
$ jq 'map("--arg " + .)' arg-*.json
[
  "--arg hello"
]
[
  "--arg world"
]

$ yq 'map("--arg " + .)' arg-*.json
[
  "--arg hello"
]
[
  "--arg world"
]

# Naturally those two separate arrays don't join (same for `jq`):
yq 'map("--arg " + .) | join(" ")' arg-*.json
"--arg hello"
"--arg world"

# Attempt to treat as JSONL and get a single array from that:
$ yq -p=j -o=j 'map("--arg " + .)' <(cat arg-*.json)
[
  "--arg hello"
]
[
  "--arg world"
]

# Attempt to collect into a single array:
$ yq -p=j -o=j '[.]' <(cat arg-*.json)
[
  {
    "arg": "hello"
  }
]
[
  {
    "arg": "world"
  }
]

With yq and lists:

One could try with the object files already as list items and try to go from there?

arg-1.yaml:

- arg: hello
- arg: example

arg-2.yaml:

- arg: world

$ yq 'map("--arg " + .arg) | join(" ")' arg-*.yaml
--arg hello --arg example
--arg world

$ yq 'map("--arg " + .arg)' arg-*.yaml
- --arg hello
- --arg example
- --arg world

$ yq '.' arg-*.yaml
- arg: hello
- arg: example
---
- arg: world

# Nope, cannot try to splat the inputs together and group under an array:
$ yq '[.[]] | map("--arg " + .arg) | join(" ")' arg-*.yaml
--arg hello --arg example
--arg world

# Nor this variation:
$ yq '[.] | flatten | map("--arg " + .arg) | join(" ")' arg-*.yaml
--arg hello --arg example
--arg world

yq ea / yq eval-all enables the functionality but makes no assumptions, requiring you to do the extra step to get the array of inputs combined (similar to the docs "merge all files" example but slight change for merging files when they're a top-level array instead of object):

$ yq eval-all '. as $item ireduce ([]; . + $item ) | map("--arg " + .arg) | join(" ")' arg-*.yaml
--arg hello --arg example --arg world

# Does seem that you can avoid the reduce verbosity in this case
# and use the earlier attempted splat inputs into grouped array:
$ yq eval-all'[.[]] | map("--arg " + .arg) | join(" ")' arg-*.yaml
--arg hello --arg example --arg world

# Similarly this works too now:
$ yq eval-all '[.] | flatten | map("--arg " + .arg) | join(" ")' arg-*.yaml
--arg hello --arg example --arg world

jaq

This is a Rust tool similar to jq but it has some differences. While it supports --slurp it also supports updating files inplace which likewise prevented the jq --slurp behaviour I was seeking.

It does support --slurp with arrays merged if all files were concatenated into a single input string (aka JSONL format), but this trick did not work for yq either with the lack of --slurp.

[polarathene]

It seems that the equivalent feature in yq without a --slurp option is yq eval-all '[.] | ..., which can then handle your expression (...) as if it were: yq --slurp '...'.