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;
          };
    };
}