core/pkgs/pkgs-lib/formats/hocon/default.nix

{ lib
, pkgs
}:
let
  inherit (pkgs) buildPackages callPackage;

  hocon-generator = buildPackages.rustPlatform.buildRustPackage {
    name = "hocon-generator";
    version = "0.1.0";
    src = ./src;

    passthru.updateScript = ./update.sh;

    cargoLock.lockFile = ./src/Cargo.lock;
  };

  hocon-validator = pkgs.writers.writePython3Bin "hocon-validator" {
    libraries = [ pkgs.python3Packages.pyhocon ];
  } ''
    from sys import argv
    from pyhocon import ConfigFactory

    if not len(argv) == 2:
        print("USAGE: hocon-validator <file>")

    ConfigFactory.parse_file(argv[1])
  '';
in
{
  # https://github.com/lightbend/config/blob/main/HOCON.md
  format = {
    generator ? hocon-generator
    , validator ? hocon-validator
    # `include classpath("")` is not implemented in pyhocon.
    # In the case that you need this functionality,
    # you will have to disable pyhocon validation.
    , doCheck ? true
  }: let
    hoconLib = {
      mkInclude = value: let
        includeStatement = if lib.isAttrs value && !(lib.isDerivation value) then {
          required = false;
          type = null;
          _type = "include";
        } // value else {
          value = toString value;
          required = false;
          type = null;
          _type = "include";
        };
      in
        assert lib.assertMsg (lib.elem includeStatement.type [ "file" "url" "classpath" null ]) ''
          Type of HOCON mkInclude is not of type 'file', 'url' or 'classpath':
          ${(lib.generators.toPretty {}) includeStatement}
        '';
        includeStatement;

      mkAppend = value: {
        inherit value;
        _type = "append";
      };

      mkSubstitution = value:
      if lib.isString value
        then
          {
            inherit value;
            optional = false;
            _type = "substitution";
          }
        else
          assert lib.assertMsg (lib.isAttrs value) ''
            Value of invalid type provided to `hocon.lib.mkSubstition`: ${lib.typeOf value}
          '';
          assert lib.assertMsg (value ? "value") ''
            Argument to `hocon.lib.mkSubstition` is missing a `value`:
            ${builtins.toJSON value}
          '';
          {
            value = value.value;
            optional = value.optional or false;
            _type = "substitution";
          };
    };

  in {
    type = let
      type' = with lib.types; let
        atomType = nullOr (oneOf [
          bool
          float
          int
          path
          str
        ]);
      in (oneOf [
        atomType
        (listOf atomType)
        (attrsOf type')
      ]) // {
        description = "HOCON value";
      };
    in type';

    lib = hoconLib;

    generate = name: value:
      let
        # TODO: remove in 24.11
        # Backwards compatibility for generators in the following locations:
        #  - nixos/modules/services/networking/jibri/default.nix (__hocon_envvar)
        #  - nixos/modules/services/networking/jicofo.nix (__hocon_envvar, __hocon_unquoted_string)
        #  - nixos/modules/services/networking/jitsi-videobridge.nix (__hocon_envvar)
        replaceOldIndicators = value:
          if lib.isAttrs value then
            (if value ? "__hocon_envvar"
              then
              lib.warn ''
                Use of `__hocon_envvar` has been deprecated, and will
                be removed in the future.

                Please use `(pkgs.formats.hocon {}).lib.mkSubstitution` instead.
              ''
              (hoconLib.mkSubstitution value.__hocon_envvar)
            else if value ? "__hocon_unquoted_string"
              then
              lib.warn ''
                Use of `__hocon_unquoted_string` has been deprecated, and will
                be removed in the future.

                Please make use of the freeform options of
                `(pkgs.formats.hocon {}).format` instead.
              ''
              {
                value = value.__hocon_unquoted_string;
                _type = "unquoted_string";
              }
            else lib.mapAttrs (_: replaceOldIndicators) value)
          else if lib.isList value
            then map replaceOldIndicators value
          else value;

        finalValue = replaceOldIndicators value;
      in
      callPackage
        ({
          stdenvNoCC
        , hocon-generator
        , hocon-validator
        , writeText
        }:
        stdenvNoCC.mkDerivation rec {
          inherit name;

          dontUnpack = true;

          json = builtins.toJSON finalValue;
          passAsFile = [ "json" ];

          strictDeps = true;
          nativeBuildInputs = [ hocon-generator ];
          buildPhase = ''
            runHook preBuild
            hocon-generator < $jsonPath > output.conf
            runHook postBuild
          '';

          inherit doCheck;
          nativeCheckInputs = [ hocon-validator ];
          checkPhase = ''
            runHook preCheck
            hocon-validator output.conf
            runHook postCheck
          '';

          installPhase = ''
            runHook preInstall
            mv output.conf $out
            runHook postInstall
          '';

          passthru.json = writeText "${name}.json" json;
        })
        {
          hocon-generator = generator;
          hocon-validator = validator;
        };
  };
}