* There are some edge cases where cargo will allow a lib.rs file to be
present but not a main.rs (e.g. a binary cannot be called "examples",
which will happen if the crate is called that and a main.rs file is
present)
* By default we pass everything through to the actual derivation itself,
but some internal parameters don't show up as environment variables
directly (or rather do not need to)
* In an effort to keep the build environment as lean as possible, we can
do some clean up (e.g. to avoid invalidating builds if some parameter
changes but is completely ignored/overridden elsewhere)
* Seems like whatever issue was preventing us from evaluating
derivations for other architectures (without actually building them)
has been resolved, and now we can nicely test everything with a single
invocation of `nix flake check`
* In this case, we set up a crate with various non-default features and
ensure that we can correctly influence the cargo build by passing in
the appropriate `--feature` flag
* This hook was never a great implementation to begin with since it
would simply search the cargo artifacts directory for binaries and
libraries to install
* This isn't really great since if we have multiple builds (say one with
debug artifacts, one with release artifacts) it isn't exactly clear
which artifacts would get installed (or which will get clobbered).
* Now that we have installFromCargoBuildLogHook we can simplify the
options a bit and only have one main installation method. The caller
can always provide their own if they wish
* The intention here is to split up different "responsibilities" into
smaller parts which can be composed as a DAG rather than mutually
recursive functions. Specifically:
* `mkCargoDerivation` represents a lower-level thin wrapper around
`stdenv.mkDerivation` which will
- set up hooks
- require the caller to define the variables needed by the hooks (like
vendor dir, or artifacts to inherit)
- ensure that build/check/install phases can be configured by the
caller without having them remember to call pre/post hooks
* This allows `buildDepsOnly` to only focus on setting some default
values (like good default commands to build all artifacts, setting the
derivation name, etc.) and delegating the rest to `mkCargoDerivation`
* Lastly, the responsibility of `buildWithCargo` ends up ensuring that
`cargoArtifacts` and `cargoVendorDir` are defined if the caller does
not pass them in
* Copying the cargo artifacts to their own separate output is a good
idea *in theory* where each derivation produces bins/libs so that
other things can depend on them without pulling in the cargo artifacts
as well
* In practice, it's much more likely that a derivation will produce
cargo artifacts (to be reused in other build/test steps) XOR produce
the final binaries
* Therefore _not_ separating the outputs will produce less friction when
forming dependency trees in the general path (e.g. no more forgetting
to specify `drv.target`)
* If a caller really wants to install cargo artifacts in a separate
output, they can easily add the customization themselves
* Some tools may try to inspect crate types (e.g. wasm-pack) so it may
be useful to retain the attribute
* In general, the crate-type can influence the project's "structure" so
we should remain faithful to that
* Turns out the `required-features` attribute is only used from hiding
targets from cargo's selection (e.g. do not build unless feature is
enabled) and does not actually influence what features cargo will
enable/build for dependencies
* Hook functions now will accept any relevant arguments and fall back to
our default variables if they are not provided, potentially allowing
them to be adapted externally (without needing more configuration
knobs on our end)
* Reducing the parameter surface area for good measure, zstd compression
works pretty well and it seems redundant to support multiple ways of
copying the target directory around
* `nix flake check` insists on evaluating all outputs for all systems,
which seems to include evaluating build inputs needed for other
systems (which gives us errors like `a 'aarch64-darwin' with features
{} is required to build '...', but I am a 'x86_64-linux'`)
* To work around this we'll move all tests to their own directory
outside of the flake's outputs, and manually invoke a test script to
build them
* If a derivation is created without a name *and* we cannot infer a name
from a Cargo.toml file, we'll throw a descriptive error message which
hints towards the remediation
* Otherwise nix can throw a pretty obtuse "derivation has no name" error
with no error trace
* Instead of always installing the hook but bailing early based on the
configuration, we will instead only install the hook if the
configuration requests it
* Hopefully the updated name should be more clear that we are inhering
some existing cargo artifacts and NOT inheriting something like
CARGO_BUILD_TARGET which refers to the host target being built
* This allows us to copy over the cargo artifacts as early as possible
so that any other phases/hooks (like running clippy) can take
advantage of the cache
* It also avoids installing the artifacts too soon (and making them
older than the source) and having cargo invalidate them
* Rather than clobbering the project's .cargo/config.toml file (if it
exists), the setup hook will update the base configuration used in
$CARGO_HOME/config.toml
* This potentially allows for projects who know what they are doing to
more easily replace their own sources, while falling back to our
configuration
* This will define CARGO_HOME to $PWD/.cargo-home to ensure that cargo
never tries to look for a missing HOME directory as it's default
location
* The hook is also added to `postPatchHooks` (instead of
`preConfigureHooks`) to ensure that it runs before all other
configuration-related hooks
