26dfad95d9
The use-xdg-base-directories Nix setting can be set globally in /etc/nix/nix.conf, in which case Home Manager doesn't know about it. Users could fix that by also setting it, redundantly, in `nix.settings`, but then Nix issues a lot of spurious warnings about use-xdg-base-directories being a restricted setting that untrusted users can't pass on to the daemon. As an alternative, users can now set `nix.assumeXdg`, which makes Home Manager assume that use-xdg-base-directories is in effect without adding it to the user's nix.conf file.
420 lines
12 KiB
Nix
420 lines
12 KiB
Nix
{
|
|
config,
|
|
lib,
|
|
osConfig,
|
|
pkgs,
|
|
...
|
|
}:
|
|
|
|
let
|
|
|
|
inherit (lib)
|
|
boolToString
|
|
concatStringsSep
|
|
escape
|
|
floatToString
|
|
getVersion
|
|
isBool
|
|
isConvertibleWithToString
|
|
isDerivation
|
|
isFloat
|
|
isInt
|
|
isList
|
|
isString
|
|
literalExpression
|
|
literalMD
|
|
mapAttrsToList
|
|
mkDefault
|
|
mkEnableOption
|
|
mkIf
|
|
mkMerge
|
|
mkOption
|
|
optionalString
|
|
toPretty
|
|
types
|
|
versionAtLeast
|
|
;
|
|
|
|
cfg = config.nix;
|
|
|
|
nixPackage = cfg.package;
|
|
|
|
isNixAtLeast = versionAtLeast (getVersion nixPackage);
|
|
|
|
nixPath = concatStringsSep ":" cfg.nixPath;
|
|
|
|
inherit (config.nix) useXdg;
|
|
defexprDir =
|
|
if useXdg then
|
|
"${config.xdg.stateHome}/nix/defexpr"
|
|
else
|
|
"${config.home.homeDirectory}/.nix-defexpr";
|
|
|
|
# The deploy path for declarative channels. The directory name is prefixed
|
|
# with a number to make it easier for files in defexprDir to control the order
|
|
# they'll be read relative to each other.
|
|
channelPath = "${defexprDir}/50-home-manager";
|
|
|
|
channelsDrv =
|
|
let
|
|
mkEntry = name: drv: {
|
|
inherit name;
|
|
path = toString drv;
|
|
};
|
|
in
|
|
pkgs.linkFarm "channels" (lib.mapAttrsToList mkEntry cfg.channels);
|
|
|
|
nixConf =
|
|
assert isNixAtLeast "2.2";
|
|
let
|
|
|
|
mkValueString =
|
|
v:
|
|
if v == null then
|
|
""
|
|
else if isInt v then
|
|
toString v
|
|
else if isBool v then
|
|
boolToString v
|
|
else if isFloat v then
|
|
floatToString v
|
|
else if isList v then
|
|
toString v
|
|
else if isDerivation v then
|
|
toString v
|
|
else if builtins.isPath v then
|
|
toString v
|
|
else if isString v then
|
|
v
|
|
else if isConvertibleWithToString v then
|
|
toString v
|
|
else
|
|
abort "The nix conf value: ${toPretty { } v} can not be encoded";
|
|
|
|
mkKeyValue = k: v: "${escape [ "=" ] k} = ${mkValueString v}";
|
|
|
|
mkKeyValuePairs = attrs: concatStringsSep "\n" (mapAttrsToList mkKeyValue attrs);
|
|
|
|
in
|
|
pkgs.writeTextFile {
|
|
name = "nix.conf";
|
|
text = ''
|
|
# WARNING: this file is generated from the nix.settings option in
|
|
# your Home Manager configuration at $XDG_CONFIG_HOME/nix/nix.conf.
|
|
# Do not edit it!
|
|
${mkKeyValuePairs cfg.settings}
|
|
${cfg.extraOptions}
|
|
'';
|
|
checkPhase =
|
|
if pkgs.stdenv.hostPlatform != pkgs.stdenv.buildPlatform then
|
|
''
|
|
echo "Ignoring validation for cross-compilation"
|
|
''
|
|
else
|
|
let
|
|
showCommand = if isNixAtLeast "2.20pre" then "config show" else "show-config";
|
|
in
|
|
''
|
|
echo "Validating generated nix.conf"
|
|
ln -s $out ./nix.conf
|
|
set -e
|
|
set +o pipefail
|
|
NIX_CONF_DIR=$PWD \
|
|
${cfg.package}/bin/nix ${showCommand} ${optionalString (isNixAtLeast "2.3pre") "--no-net --option experimental-features nix-command"} \
|
|
|& sed -e 's/^warning:/error:/' \
|
|
| (! grep '${if cfg.checkConfig then "^error:" else "^error: unknown setting"}')
|
|
set -o pipefail
|
|
'';
|
|
};
|
|
|
|
semanticConfType =
|
|
with types;
|
|
let
|
|
confAtom =
|
|
nullOr (oneOf [
|
|
bool
|
|
int
|
|
float
|
|
str
|
|
path
|
|
package
|
|
])
|
|
// {
|
|
description = "Nix config atom (null, bool, int, float, str, path or package)";
|
|
};
|
|
in
|
|
attrsOf (either confAtom (listOf confAtom));
|
|
|
|
jsonFormat = pkgs.formats.json { };
|
|
|
|
in
|
|
{
|
|
meta.maintainers = [ ];
|
|
|
|
options.nix = {
|
|
enable =
|
|
mkEnableOption ''
|
|
the Nix configuration module
|
|
''
|
|
// {
|
|
default = true;
|
|
visible = false;
|
|
};
|
|
|
|
package = lib.mkPackageOption pkgs "nix" {
|
|
default = null;
|
|
nullable = true;
|
|
};
|
|
|
|
nixPath = mkOption {
|
|
type = types.listOf types.str;
|
|
default = [ ];
|
|
example = [
|
|
"$HOME/.nix-defexpr/channels"
|
|
"darwin-config=$HOME/.config/nixpkgs/darwin-configuration.nix"
|
|
];
|
|
description = ''
|
|
Adds new directories to the Nix expression search path.
|
|
|
|
Used by Nix when looking up paths in angular brackets
|
|
(e.g. `<nixpkgs>`).
|
|
'';
|
|
};
|
|
|
|
keepOldNixPath = mkOption {
|
|
type = types.bool;
|
|
default = true;
|
|
example = false;
|
|
description = ''
|
|
Whether {option}`nix.nixPath` should keep the previously set values in
|
|
{env}`NIX_PATH`.
|
|
'';
|
|
};
|
|
|
|
channels = lib.mkOption {
|
|
type = with lib.types; attrsOf package;
|
|
default = { };
|
|
example = lib.literalExpression "{ inherit nixpkgs; }";
|
|
description = ''
|
|
A declarative alternative to Nix channels. Whereas with stock channels,
|
|
you would register URLs and fetch them into the Nix store with
|
|
{manpage}`nix-channel(1)`, this option allows you to register the store
|
|
path directly. One particularly useful example is registering flake
|
|
inputs as channels.
|
|
|
|
This option can coexist with stock Nix channels. If the same channel is
|
|
defined in both, this option takes precedence.
|
|
'';
|
|
};
|
|
|
|
registry = mkOption {
|
|
type = types.attrsOf (
|
|
types.submodule (
|
|
let
|
|
inputAttrs = types.attrsOf (
|
|
types.oneOf [
|
|
types.str
|
|
types.int
|
|
types.bool
|
|
types.package
|
|
]
|
|
);
|
|
in
|
|
{ config, name, ... }:
|
|
{
|
|
options = {
|
|
from = mkOption {
|
|
type = inputAttrs;
|
|
example = {
|
|
type = "indirect";
|
|
id = "nixpkgs";
|
|
};
|
|
description = "The flake reference to be rewritten.";
|
|
};
|
|
to = mkOption {
|
|
type = inputAttrs;
|
|
example = {
|
|
type = "github";
|
|
owner = "my-org";
|
|
repo = "my-nixpkgs";
|
|
};
|
|
description = "The flake reference to which {option}`from>` is to be rewritten.";
|
|
};
|
|
flake = mkOption {
|
|
type = types.nullOr types.attrs;
|
|
default = null;
|
|
example = literalExpression "nixpkgs";
|
|
description = ''
|
|
The flake input to which {option}`from>` is to be rewritten.
|
|
'';
|
|
};
|
|
exact = mkOption {
|
|
type = types.bool;
|
|
default = true;
|
|
description = ''
|
|
Whether the {option}`from` reference needs to match exactly. If set,
|
|
a {option}`from` reference like `nixpkgs` does not
|
|
match with a reference like `nixpkgs/nixos-20.03`.
|
|
'';
|
|
};
|
|
};
|
|
config = {
|
|
from = mkDefault {
|
|
type = "indirect";
|
|
id = name;
|
|
};
|
|
to = mkIf (config.flake != null) (
|
|
{
|
|
type = "path";
|
|
path = config.flake.outPath;
|
|
}
|
|
// lib.filterAttrs (
|
|
n: v: n == "lastModified" || n == "rev" || n == "revCount" || n == "narHash"
|
|
) config.flake
|
|
);
|
|
};
|
|
}
|
|
)
|
|
);
|
|
default = { };
|
|
description = ''
|
|
User level flake registry.
|
|
'';
|
|
};
|
|
|
|
registryVersion = mkOption {
|
|
type = types.int;
|
|
default = 2;
|
|
internal = true;
|
|
description = "The flake registry format version.";
|
|
};
|
|
|
|
checkConfig = mkOption {
|
|
type = types.bool;
|
|
default = true;
|
|
description = ''
|
|
If enabled (the default), checks for data type mismatches and that Nix
|
|
can parse the generated nix.conf.
|
|
'';
|
|
};
|
|
|
|
assumeXdg = mkOption {
|
|
type = types.bool;
|
|
default = false;
|
|
description = ''
|
|
Whether Home Manager should assume that Nix is configured to use XDG
|
|
base directories. Note that this doesn't change the behavior of Nix. To
|
|
do that, set nix.settings.use-xdg-base-directories instead. This option
|
|
is intended for settings in which use-xdg-base-directories is set
|
|
globally or nix.conf is unmanaged by Home Manager.
|
|
'';
|
|
};
|
|
|
|
useXdg = mkOption {
|
|
type = types.bool;
|
|
visible = false;
|
|
readOnly = true;
|
|
defaultText = literalMD ''
|
|
In descending priority:
|
|
* `true` if `nix.assumeXdg` is `true`
|
|
* `nix.settings.use-xdg-base-directories` if it is set and `nix.enable` is `true`
|
|
* `osConfig.nix.settings.use-xdg-base-directories` if it is set and `osConfig.nix.enable` is `true`
|
|
'';
|
|
};
|
|
|
|
extraOptions = mkOption {
|
|
type = types.lines;
|
|
default = "";
|
|
example = ''
|
|
keep-outputs = true
|
|
keep-derivations = true
|
|
'';
|
|
description = "Additional text appended to {file}`nix.conf`.";
|
|
};
|
|
|
|
settings = mkOption {
|
|
type = types.submodule { freeformType = semanticConfType; };
|
|
default = { };
|
|
example = literalExpression ''
|
|
{
|
|
sandbox = true;
|
|
show-trace = true;
|
|
system-features = [ "big-parallel" "kvm" "recursive-nix" ];
|
|
}
|
|
'';
|
|
description = ''
|
|
Configuration for Nix; see {manpage}`nix.conf(5)` for available options.
|
|
The value declared here will be translated directly to the key-value pairs Nix expects.
|
|
|
|
Configuration specified in [](#opt-nix.extraOptions) will be appended
|
|
verbatim to the resulting config file.
|
|
'';
|
|
};
|
|
};
|
|
|
|
config = mkMerge [
|
|
{
|
|
nix.useXdg =
|
|
let
|
|
# Helper that checks if use-xdg-base-directories is in effect for the
|
|
# given Nix configuration, falling back to a given default value if
|
|
# it is undefined or the configuration is not enabled.
|
|
checkNixXdg = def: cfg: if cfg.enable then cfg.settings.use-xdg-base-directories or def else def;
|
|
|
|
# Whether the OS configuration indicates that XDG directories should
|
|
# be used.
|
|
osUseXdg = checkNixXdg false osConfig.nix or { enable = false; };
|
|
|
|
# Whether the user configuration indicates that XDG directories
|
|
# should be used, falling back to the OS configuration if not
|
|
# specified.
|
|
hmUseXdg = checkNixXdg osUseXdg cfg;
|
|
in
|
|
cfg.assumeXdg || hmUseXdg;
|
|
|
|
assertions = [
|
|
{
|
|
assertion = !(cfg.assumeXdg && cfg.enable && cfg.settings ? use-xdg-base-directories);
|
|
message = ''
|
|
`nix.assumeXdg` should not be set if `nix.settings.use-xdg-base-directories` is.
|
|
'';
|
|
}
|
|
];
|
|
}
|
|
(mkIf cfg.enable (mkMerge [
|
|
(mkIf (cfg.nixPath != [ ] && !cfg.keepOldNixPath) {
|
|
home.sessionVariables.NIX_PATH = "${nixPath}";
|
|
})
|
|
|
|
(mkIf (cfg.nixPath != [ ] && cfg.keepOldNixPath) {
|
|
home.sessionVariables.NIX_PATH = "${nixPath}\${NIX_PATH:+:$NIX_PATH}";
|
|
})
|
|
|
|
(lib.mkIf (cfg.channels != { }) {
|
|
nix.nixPath = [ channelPath ];
|
|
home.file."${channelPath}".source = channelsDrv;
|
|
})
|
|
|
|
(mkIf (cfg.registry != { }) {
|
|
xdg.configFile."nix/registry.json".source = jsonFormat.generate "registry.json" {
|
|
version = cfg.registryVersion;
|
|
flakes = mapAttrsToList (n: v: { inherit (v) from to exact; }) cfg.registry;
|
|
};
|
|
})
|
|
|
|
(mkIf (cfg.settings != { } || cfg.extraOptions != "") {
|
|
assertions = [
|
|
{
|
|
assertion = cfg.package != null;
|
|
message = ''
|
|
A corresponding Nix package must be specified via `nix.package` for generating
|
|
nix.conf.
|
|
'';
|
|
}
|
|
];
|
|
|
|
xdg.configFile."nix/nix.conf".source = nixConf;
|
|
})
|
|
]))
|
|
];
|
|
}
|