Simplify and speed up metadata query for journey tests

The journey tests need to know where the target directory is. For
robustness, we have not been assuming it is `target`, but instead
attempting to allow it to be in any location, and querying cargo
metadata to find out where it is. (Doing so has the effect of
taking care of resolving it to an absolute path, too.)

This preserves that, and continues to use `justfile` logic to find
it, but does so in a more streamlined way:

- Pass `--no-deps` to `cargo metadata`, since dependencies should
  not affect the location of the target directory.

- In the `jq` command that processes `cargo metadata` output, pass
  `-e`/`--exit-status` so `jq` reports a failing status if the query
  fails (such as by attempting to look up a missing key, due to
  `cargo metadata` having failed or otherwise not producing the
  expected kind of output).

- For `jq`, express `-r` as `--raw-output (and `-e` as
  `--exit-status`) so that the meaning is more readily clear.

- Extract a generalized `cargo metadata ... | jq ...` recipe with
  the flags we're using on both commands. This is parameterized on
  the `jq` query argument only. This is to make the code easier to
  read, and also in anticipation of other uses that would also want
  those flags and no others but with different query strings (such
  as to extract the MSRV).

And removes checks that are now unnecessary:

- Don't do a separate check for empty `jq` output anymore, since
  the goal is to check for an absent key (or totally empty input),
  and `-e`/`--exit-status` takes care of that.

- Don't repeat `dbg` as a prerequisite for the journey test recipes
  that rely on it, instead allowing the recipes to proceed until
  they get to where they really use it (which is by interpolation),
  because `--no-deps` should avoid any major delays at this point
  as well as making failure unlikely (but if it does fail, that is
  still checked and will still fail the recipe).

Author: EliahKagan

justfile

@@ -184,34 +184,36 @@ unit-tests:
 unit-tests-flaky:
     cargo test -p gix --features async-network-client-async-std
 
-# Depend on this to pre-generate metadata, and/or use it inside a recipe as `"$({{ j }} dbg)"`
+# Extract cargo metadata, excluding dependencies, and query it
+[private]
+get-metadata jq-query:
+    cargo metadata --format-version 1 | jq --exit-status --raw-output -- {{ quote(jq-query) }}
+
+# Get the path to the directory where debug binaries are created during builds
 [private]
 dbg:
-    set -eu; \
-        target_dir="$(cargo metadata --format-version 1 | jq -r .target_directory)"; \
-        test -n "$target_dir"; \
-        echo "$target_dir/debug"
+    target_dir="$({{ j }} get-metadata .target_directory)" && echo "$target_dir/debug"
 
 # Run journey tests (`max`)
-journey-tests: dbg
+journey-tests:
     cargo build --features http-client-curl-rustls
     cargo build -p gix-testtools --bin jtt
     dbg="$({{ j }} dbg)" && tests/journey.sh "$dbg/ein" "$dbg/gix" "$dbg/jtt" max
 
 # Run journey tests (`max-pure`)
-journey-tests-pure: dbg
+journey-tests-pure:
     cargo build --no-default-features --features max-pure
     cargo build -p gix-testtools --bin jtt
     dbg="$({{ j }} dbg)" && tests/journey.sh "$dbg/ein" "$dbg/gix" "$dbg/jtt" max-pure
 
 # Run journey tests (`small`)
-journey-tests-small: dbg
+journey-tests-small:
     cargo build --no-default-features --features small
     cargo build -p gix-testtools
     dbg="$({{ j }} dbg)" && tests/journey.sh "$dbg/ein" "$dbg/gix" "$dbg/jtt" small
 
 # Run journey tests (`lean-async`)
-journey-tests-async: dbg
+journey-tests-async:
     cargo build --no-default-features --features lean-async
     cargo build -p gix-testtools
     dbg="$({{ j }} dbg)" && tests/journey.sh "$dbg/ein" "$dbg/gix" "$dbg/jtt" async