path: root/modules/common/user.nix

# The common module that contains Hjem's per-user options. To ensure Hjem remains
# somewhat compliant with cross-platform paradigms (e.g. NixOS or Darwin.) Platform
# specific options such as nixpkgs module system or nix-darwin module system should
# be avoided here.
{
  config,
  hjem-lib,
  lib,
  name,
  options,
  pkgs,
  ...
}: let
  inherit (hjem-lib) envVarType listOrSingletonOf toEnv;
  inherit (lib.attrsets) attrValues mapAttrs mapAttrsToList;
  inherit (lib.lists) any;
  inherit (lib.modules) mkIf;
  inherit (lib.options) literalExpression mkEnableOption mkOption;
  inherit (lib.strings) concatLines concatStringsSep;
  inherit (lib.trivial) id;
  inherit (lib.types) attrsOf attrsWith bool listOf package passwdEntry path str strMatching;

  cfg = config;
  fileTypeRelativeTo' = rootDir:
    attrsWith {
      elemType = hjem-lib.fileTypeRelativeTo {
        inherit rootDir;
        clobberDefault = cfg.clobberFiles;
        clobberDefaultText = literalExpression "config.hjem.users.${name}.clobberFiles";
      };
      placeholder = "path";
    };
in {
  _class = "hjem";

  imports = [
    # Makes "assertions" option available without having to duplicate the work
    # already done in the Nixpkgs module.
    (pkgs.path + "/nixos/modules/misc/assertions.nix")
  ];

  options = {
    enable =
      mkEnableOption "home management for this user"
      // {
        default = true;
        example = false;
      };

    user = mkOption {
      type = strMatching "[a-zA-Z0-9_.][a-zA-Z0-9_.-]*";
      description = "The owner of a given home directory.";
    };

    directory = mkOption {
      type = passwdEntry path;
      description = ''
        The home directory for the user, to which files configured in
        {option}`hjem.users.<username>.files` will be relative to by default.
      '';
    };

    clobberFiles = mkOption {
      type = bool;
      example = true;
      description = ''
        The default override behaviour for files managed by Hjem for a
        particular user.

        A top level option exists under the Hjem module option
        {option}`hjem.clobberByDefault`. Per-file behaviour can be modified
        with {option}`hjem.users.<username>.files.<path>.clobber`.
      '';
    };

    files = mkOption {
      default = {};
      type = fileTypeRelativeTo' cfg.directory;
      example = {".config/foo.txt".source = "Hello World";};
      description = "Hjem-managed files.";
    };

    xdg = {
      cache = {
        directory = mkOption {
          type = path;
          default = "${cfg.directory}/.cache";
          defaultText = "$HOME/.cache";
          description = ''
            The XDG cache directory for the user, to which files configured in
            {option}`hjem.users.<username>.xdg.cache.files` will be relative to by default.

            Adds {env}`XDG_CACHE_HOME` to {option}`environment.sessionVariables` for
            this user if changed.
          '';
        };
        files = mkOption {
          default = {};
          type = fileTypeRelativeTo' cfg.xdg.cache.directory;
          example = {"foo.txt".source = "Hello World";};
          description = "Hjem-managed cache files.";
        };
      };

      config = {
        directory = mkOption {
          type = path;
          default = "${cfg.directory}/.config";
          defaultText = "$HOME/.config";
          description = ''
            The XDG config directory for the user, to which files configured in
            {option}`hjem.users.<username>.xdg.config.files` will be relative to by default.

            Adds {env}`XDG_CONFIG_HOME` to {option}`environment.sessionVariables` for
            this user if changed.
          '';
        };
        files = mkOption {
          default = {};
          type = fileTypeRelativeTo' cfg.xdg.config.directory;
          example = {"foo.txt".source = "Hello World";};
          description = "Hjem-managed config files.";
        };
      };

      data = {
        directory = mkOption {
          type = path;
          default = "${cfg.directory}/.local/share";
          defaultText = "$HOME/.local/share";
          description = ''
            The XDG data directory for the user, to which files configured in
            {option}`hjem.users.<username>.xdg.data.files` will be relative to by default.

            Adds {env}`XDG_DATA_HOME` to {option}`environment.sessionVariables` for
            this user if changed.
          '';
        };
        files = mkOption {
          default = {};
          type = fileTypeRelativeTo' cfg.xdg.data.directory;
          example = {"foo.txt".source = "Hello World";};
          description = "Hjem-managed data files.";
        };
      };

      state = {
        directory = mkOption {
          type = path;
          default = "${cfg.directory}/.local/state";
          defaultText = "$HOME/.local/state";
          description = ''
            The XDG state directory for the user, to which files configured in
            {option}`hjem.users.<username>.xdg.state.files` will be relative to by default.

            Adds {env}`XDG_STATE_HOME` to {option}`environment.sessionVariables` for
            this user if changed.
          '';
        };
        files = mkOption {
          default = {};
          type = fileTypeRelativeTo' cfg.xdg.state.directory;
          example = {"foo.txt".source = "Hello World";};
          description = "Hjem-managed state files.";
        };
      };

      mime-apps = {
        added-associations = mkOption {
          type = attrsOf (listOrSingletonOf str);
          default = {};
          example = {
            mimetype1 = ["foo1.desktop" "foo2.desktop" "foo3.desktop"];
            mimetype2 = "foo4.desktop";
          };
          description = ''
            Defines additional [associations] of applications with mimetypes, as
            if the `.desktop` file was listing this mimetype in the first place.

            [associations]: https://specifications.freedesktop.org/mime-apps/latest/associations.html
          '';
        };

        removed-associations = mkOption {
          type = attrsOf (listOrSingletonOf str);
          default = {};
          example = {
            mimetype1 = "foo5.desktop";
          };
          description = ''
            Removes [associations] of applications with mimetypes, as if the
            `.desktop` file was NOT listing this mimetype in the first place.

            [associations]: https://specifications.freedesktop.org/mime-apps/latest/associations.html
          '';
        };

        default-applications = mkOption {
          type = attrsOf (listOrSingletonOf str);
          default = {};
          example = {
            mimetype1 = ["default1.desktop" "default2.desktop"];
          };
          description = ''
            Indicates the [default application] to be used for a given mimetype.

            [default application]: https://specifications.freedesktop.org/mime-apps/latest/default.html
          '';
        };
      };
    };

    packages = mkOption {
      type = listOf package;
      default = [];
      example = literalExpression "[pkgs.hello]";
      description = "Packages to install for this user.";
    };

    extraDependencies = mkOption {
      type = listOf package;
      default = [];
      description = ''
        A list of paths/packages that should be included in the system closure
        but generally not visible to users.

        On NixOS these paths are forwarded to {option}`system.extraDependencies`.
        On nix-darwin, which has no equivalent host option, the paths are pinned
        to the system closure by listing them in `/etc/hjem/extra-dependencies`.
      '';
    };

    environment = {
      loadEnv = mkOption {
        type = path;
        readOnly = true;
        description = ''
          A POSIX compliant shell script containing the user session variables needed to bootstrap the session.

          As there is no reliable and agnostic way of setting session variables, Hjem's
          environment module does nothing by itself. Rather, it provides a POSIX compliant shell script
          that needs to be sourced where needed.
        '';
      };
      sessionVariables = mkOption {
        type = envVarType;
        default = {};
        example = {
          EDITOR = "nvim";
          VISUAL = "nvim";
        };
        description = ''
          A set of environment variables used in the user environment.
          If a list of strings is used, they will be concatenated with colon
          characters.
        '';
      };
    };
  };

  config = {
    # for docs
    _module.args.name = lib.mkDefault "‹username›";

    environment = {
      sessionVariables = {
        XDG_CACHE_HOME = mkIf (cfg.xdg.cache.directory != options.xdg.cache.directory.default) cfg.xdg.cache.directory;
        XDG_CONFIG_HOME = mkIf (cfg.xdg.config.directory != options.xdg.config.directory.default) cfg.xdg.config.directory;
        XDG_DATA_HOME = mkIf (cfg.xdg.data.directory != options.xdg.data.directory.default) cfg.xdg.data.directory;
        XDG_STATE_HOME = mkIf (cfg.xdg.state.directory != options.xdg.state.directory.default) cfg.xdg.state.directory;
      };
      loadEnv = lib.pipe cfg.environment.sessionVariables [
        (mapAttrsToList (name: value: "export ${name}=\"${toEnv value}\""))
        concatLines
        (pkgs.writeShellScript "load-env")
      ];
    };

    xdg.config.files."mimeapps.list" = let
      nonDefault = {
        added = cfg.xdg.mime-apps.added-associations != options.xdg.mime-apps.added-associations.default;
        removed = cfg.xdg.mime-apps.removed-associations != options.xdg.mime-apps.removed-associations.default;
        default = cfg.xdg.mime-apps.default-applications != options.xdg.mime-apps.default-applications.default;
      };
    in
      mkIf (any id (attrValues nonDefault)) {
        generator = (pkgs.formats.ini {listToValue = concatStringsSep ";";}).generate "mimeapps.list";
        value = {
          "Added Associations" = mkIf nonDefault.added cfg.xdg.mime-apps.added-associations;
          "Removed Associations" = mkIf nonDefault.removed cfg.xdg.mime-apps.removed-associations;
          "Default Applications" = mkIf nonDefault.default cfg.xdg.mime-apps.default-applications;
        };
      };
  };
}