withNormalizedHash

lib.fetchers.withNormalizedHash

Docs pulled from | This Revision | 4 days ago

Wraps a function which accepts outputHash{,Algo} into one which accepts hash or sha{256,512}

Example

withNormalizedHash { hashTypes = [ "sha256" "sha512" ]; } (
  { outputHash, outputHashAlgo, ... }:
  ...
)

is a function which accepts one of hash, sha256, or sha512 (or the original's outputHash and outputHashAlgo).

Its functionArgs metadata only lists hash as a parameter, optional iff. outputHash was an optional parameter of the original function. sha256, sha512, outputHash, or outputHashAlgo are not mentioned in the functionArgs metadata.

Type

withNormalizedHash :: { hashTypes :: List String } -> (AttrSet -> T) -> (AttrSet -> T)

Arguments

hashTypes: the set of attribute names accepted as hash inputs, in addition to hash; they must correspond to a valid value for outputHashAlgo, currently one of: md5, sha1, sha256, or sha512.
f: the function to be wrapped

In nixpkgs, mkDerivation rejects MD5 outputHashes, and SHA-1 is being deprecated.

As such, there is no reason to add md5 to hashTypes, and sha1 should only ever be included for backwards compatibility.

Output

withNormalizedHash { inherit hashTypes; } f is functionally equivalent to

args: f (normalizeHash {
  inherit hashTypes;
  required = !(lib.functionArgs f).outputHash;
} args)

However, withNormalizedHash preserves functionArgs metadata insofar as possible, and is implemented somewhat more efficiently.

Noogle detected

Implementation

The following is the current implementation of this function.

withNormalizedHash =
    {
      hashTypes ? [ "sha256" ],
    }:
    fetcher:
    let
      inherit (lib.attrsets) intersectAttrs removeAttrs;
      inherit (lib.trivial) functionArgs setFunctionArgs;

      inherit (commonH hashTypes) hashSet;
      fArgs = functionArgs fetcher;

      normalize = normalizeHash {
        inherit hashTypes;
        required = !fArgs.outputHash;
      };
    in
    # The o.g. fetcher must *only* accept outputHash and outputHashAlgo
    assert fArgs ? outputHash && fArgs ? outputHashAlgo;
    assert intersectAttrs fArgs hashSet == { };

    setFunctionArgs (args: fetcher (normalize args)) (
      removeAttrs fArgs [
        "outputHash"
        "outputHashAlgo"
      ]
      // {
        hash = fArgs.outputHash;
      }
    );