mirror of
https://github.com/nix-community/home-manager
synced 2024-12-24 18:59:47 +01:00
747 lines
23 KiB
Nix
747 lines
23 KiB
Nix
{ config, lib, pkgs, ... }:
|
||
|
||
with lib;
|
||
|
||
let
|
||
|
||
inherit (config.home) stateVersion;
|
||
|
||
cfg = config.home;
|
||
|
||
languageSubModule = types.submodule {
|
||
options = {
|
||
base = mkOption {
|
||
default = null;
|
||
type = types.nullOr types.str;
|
||
description = ''
|
||
The language to use unless overridden by a more specific option.
|
||
'';
|
||
};
|
||
|
||
ctype = mkOption {
|
||
default = null;
|
||
type = types.nullOr types.str;
|
||
description = ''
|
||
Character classification category.
|
||
'';
|
||
};
|
||
|
||
numeric = mkOption {
|
||
default = null;
|
||
type = types.nullOr types.str;
|
||
description = ''
|
||
The language to use for numerical values.
|
||
'';
|
||
};
|
||
|
||
time = mkOption {
|
||
default = null;
|
||
type = types.nullOr types.str;
|
||
description = ''
|
||
The language to use for formatting times.
|
||
'';
|
||
};
|
||
|
||
collate = mkOption {
|
||
default = null;
|
||
type = types.nullOr types.str;
|
||
description = ''
|
||
The language to use for collation (alphabetical ordering).
|
||
'';
|
||
};
|
||
|
||
monetary = mkOption {
|
||
default = null;
|
||
type = types.nullOr types.str;
|
||
description = ''
|
||
The language to use for formatting currencies and money amounts.
|
||
'';
|
||
};
|
||
|
||
messages = mkOption {
|
||
default = null;
|
||
type = types.nullOr types.str;
|
||
description = ''
|
||
The language to use for messages, application UI languages, etc.
|
||
'';
|
||
};
|
||
|
||
paper = mkOption {
|
||
default = null;
|
||
type = types.nullOr types.str;
|
||
description = ''
|
||
The language to use for paper sizes.
|
||
'';
|
||
};
|
||
|
||
name = mkOption {
|
||
default = null;
|
||
type = types.nullOr types.str;
|
||
description = ''
|
||
The language to use for personal names.
|
||
'';
|
||
};
|
||
|
||
address = mkOption {
|
||
default = null;
|
||
type = types.nullOr types.str;
|
||
description = ''
|
||
The language to use for addresses.
|
||
'';
|
||
};
|
||
|
||
telephone = mkOption {
|
||
default = null;
|
||
type = types.nullOr types.str;
|
||
description = ''
|
||
The language to use for telephone numbers.
|
||
'';
|
||
};
|
||
|
||
measurement = mkOption {
|
||
default = null;
|
||
type = types.nullOr types.str;
|
||
description = ''
|
||
The language to use for measurement values.
|
||
'';
|
||
};
|
||
|
||
};
|
||
};
|
||
|
||
keyboardSubModule = types.submodule {
|
||
options = {
|
||
layout = mkOption {
|
||
type = with types; nullOr str;
|
||
default =
|
||
if versionAtLeast config.home.stateVersion "19.09"
|
||
then null
|
||
else "us";
|
||
defaultText = literalExpression "null";
|
||
description = ''
|
||
Keyboard layout. If <literal>null</literal>, then the system
|
||
configuration will be used.
|
||
</para><para>
|
||
This defaults to <literal>null</literal> for state
|
||
version ≥ 19.09 and <literal>"us"</literal> otherwise.
|
||
'';
|
||
};
|
||
|
||
model = mkOption {
|
||
type = with types; nullOr str;
|
||
default = null;
|
||
example = "presario";
|
||
description = ''
|
||
Keyboard model.
|
||
'';
|
||
};
|
||
|
||
options = mkOption {
|
||
type = types.listOf types.str;
|
||
default = [];
|
||
example = ["grp:caps_toggle" "grp_led:scroll"];
|
||
description = ''
|
||
X keyboard options; layout switching goes here.
|
||
'';
|
||
};
|
||
|
||
variant = mkOption {
|
||
type = with types; nullOr str;
|
||
default =
|
||
if versionAtLeast config.home.stateVersion "19.09"
|
||
then null
|
||
else "";
|
||
defaultText = literalExpression "null";
|
||
example = "colemak";
|
||
description = ''
|
||
X keyboard variant. If <literal>null</literal>, then the
|
||
system configuration will be used.
|
||
</para><para>
|
||
This defaults to <literal>null</literal> for state
|
||
version ≥ 19.09 and <literal>""</literal> otherwise.
|
||
'';
|
||
};
|
||
};
|
||
};
|
||
|
||
in
|
||
|
||
{
|
||
meta.maintainers = [ maintainers.rycee ];
|
||
|
||
imports = [
|
||
(mkRemovedOptionModule [ "home" "sessionVariableSetter" ] ''
|
||
Session variables are now always set through the shell. This is
|
||
done automatically if the shell configuration is managed by Home
|
||
Manager. If not, then you must source the
|
||
|
||
~/.nix-profile/etc/profile.d/hm-session-vars.sh
|
||
|
||
file yourself.
|
||
'')
|
||
];
|
||
|
||
options = {
|
||
home.username = mkOption {
|
||
type = types.str;
|
||
defaultText = literalExpression ''
|
||
"$USER" for state version < 20.09,
|
||
undefined for state version ≥ 20.09
|
||
'';
|
||
example = "jane.doe";
|
||
description = "The user's username.";
|
||
};
|
||
|
||
home.homeDirectory = mkOption {
|
||
type = types.path;
|
||
defaultText = literalExpression ''
|
||
"$HOME" for state version < 20.09,
|
||
undefined for state version ≥ 20.09
|
||
'';
|
||
apply = toString;
|
||
example = "/home/jane.doe";
|
||
description = "The user's home directory. Must be an absolute path.";
|
||
};
|
||
|
||
home.profileDirectory = mkOption {
|
||
type = types.path;
|
||
defaultText = literalExpression ''
|
||
"''${home.homeDirectory}/.nix-profile" or
|
||
"/etc/profiles/per-user/''${home.username}"
|
||
'';
|
||
readOnly = true;
|
||
description = ''
|
||
The profile directory where Home Manager generations are installed.
|
||
'';
|
||
};
|
||
|
||
home.language = mkOption {
|
||
type = languageSubModule;
|
||
default = {};
|
||
description = "Language configuration.";
|
||
};
|
||
|
||
home.keyboard = mkOption {
|
||
type = types.nullOr keyboardSubModule;
|
||
default = if versionAtLeast stateVersion "21.11" then null else { };
|
||
defaultText = literalExpression ''
|
||
"{ }" for state version < 21.11,
|
||
"null" for state version ≥ 21.11
|
||
'';
|
||
description = ''
|
||
Keyboard configuration. Set to <literal>null</literal> to
|
||
disable Home Manager keyboard management.
|
||
'';
|
||
};
|
||
|
||
home.shellAliases = mkOption {
|
||
type = with types; attrsOf str;
|
||
default = { };
|
||
example = literalExpression ''
|
||
{
|
||
g = "git";
|
||
"..." = "cd ../..";
|
||
}
|
||
'';
|
||
description = ''
|
||
An attribute set that maps aliases (the top level attribute names
|
||
in this option) to command strings or directly to build outputs.
|
||
</para><para>
|
||
This option should only be used to manage simple aliases that are
|
||
compatible across all shells. If you need to use a shell specific
|
||
feature then make sure to use a shell specific option, for example
|
||
<xref linkend="opt-programs.bash.shellAliases"/> for Bash.
|
||
'';
|
||
};
|
||
|
||
home.sessionVariables = mkOption {
|
||
default = {};
|
||
type = with types; lazyAttrsOf (oneOf [ str path int float ]);
|
||
example = { EDITOR = "emacs"; GS_OPTIONS = "-sPAPERSIZE=a4"; };
|
||
description = ''
|
||
Environment variables to always set at login.
|
||
</para><para>
|
||
The values may refer to other environment variables using
|
||
POSIX.2 style variable references. For example, a variable
|
||
<varname>parameter</varname> may be referenced as
|
||
<code>$parameter</code> or <code>''${parameter}</code>. A
|
||
default value <literal>foo</literal> may be given as per
|
||
<code>''${parameter:-foo}</code> and, similarly, an alternate
|
||
value <literal>bar</literal> can be given as per
|
||
<code>''${parameter:+bar}</code>.
|
||
</para><para>
|
||
Note, these variables may be set in any order so no session
|
||
variable may have a runtime dependency on another session
|
||
variable. In particular code like
|
||
<programlisting language="nix">
|
||
home.sessionVariables = {
|
||
FOO = "Hello";
|
||
BAR = "$FOO World!";
|
||
};
|
||
</programlisting>
|
||
may not work as expected. If you need to reference another
|
||
session variable, then do so inside Nix instead. The above
|
||
example then becomes
|
||
<programlisting language="nix">
|
||
home.sessionVariables = {
|
||
FOO = "Hello";
|
||
BAR = "''${config.home.sessionVariables.FOO} World!";
|
||
};
|
||
</programlisting>
|
||
'';
|
||
};
|
||
|
||
home.sessionPath = mkOption {
|
||
type = with types; listOf str;
|
||
default = [ ];
|
||
example = [
|
||
"$HOME/.local/bin"
|
||
"\${xdg.configHome}/emacs/bin"
|
||
".git/safe/../../bin"
|
||
];
|
||
description = ''
|
||
Extra directories to add to <envar>PATH</envar>.
|
||
|
||
</para><para>
|
||
|
||
These directories are added to the <envar>PATH</envar> variable in a
|
||
double-quoted context, so expressions like <code>$HOME</code> are
|
||
expanded by the shell. However, since expressions like <code>~</code> or
|
||
<code>*</code> are escaped, they will end up in the <envar>PATH</envar>
|
||
verbatim.
|
||
'';
|
||
};
|
||
|
||
home.sessionVariablesExtra = mkOption {
|
||
type = types.lines;
|
||
default = "";
|
||
internal = true;
|
||
description = ''
|
||
Extra configuration to add to the
|
||
<filename>hm-session-vars.sh</filename> file.
|
||
'';
|
||
};
|
||
|
||
home.packages = mkOption {
|
||
type = types.listOf types.package;
|
||
default = [];
|
||
description = "The set of packages to appear in the user environment.";
|
||
};
|
||
|
||
home.extraOutputsToInstall = mkOption {
|
||
type = types.listOf types.str;
|
||
default = [];
|
||
example = [ "doc" "info" "devdoc" ];
|
||
description = ''
|
||
List of additional package outputs of the packages
|
||
<varname>home.packages</varname> that should be installed into
|
||
the user environment.
|
||
'';
|
||
};
|
||
|
||
home.path = mkOption {
|
||
internal = true;
|
||
description = "The derivation installing the user packages.";
|
||
};
|
||
|
||
home.emptyActivationPath = mkOption {
|
||
internal = true;
|
||
type = types.bool;
|
||
default = versionAtLeast stateVersion "22.11";
|
||
defaultText = literalExpression ''
|
||
false for state version < 22.11,
|
||
true for state version ≥ 22.11
|
||
'';
|
||
description = ''
|
||
Whether the activation script should start with an empty
|
||
<envar>PATH</envar> variable. When <literal>false</literal> then the
|
||
user's <envar>PATH</envar> will be accessible in the script. It is
|
||
recommended to keep this at <literal>true</literal> to avoid
|
||
uncontrolled use of tools found in PATH.
|
||
'';
|
||
};
|
||
|
||
home.activation = mkOption {
|
||
type = hm.types.dagOf types.str;
|
||
default = {};
|
||
example = literalExpression ''
|
||
{
|
||
myActivationAction = lib.hm.dag.entryAfter ["writeBoundary"] '''
|
||
$DRY_RUN_CMD ln -s $VERBOSE_ARG \
|
||
''${builtins.toPath ./link-me-directly} $HOME
|
||
''';
|
||
}
|
||
'';
|
||
description = ''
|
||
The activation scripts blocks to run when activating a Home
|
||
Manager generation. Any entry here should be idempotent,
|
||
meaning running twice or more times produces the same result
|
||
as running it once.
|
||
|
||
</para><para>
|
||
|
||
If the script block produces any observable side effect, such
|
||
as writing or deleting files, then it
|
||
<emphasis>must</emphasis> be placed after the special
|
||
<literal>writeBoundary</literal> script block. Prior to the
|
||
write boundary one can place script blocks that verifies, but
|
||
does not modify, the state of the system and exits if an
|
||
unexpected state is found. For example, the
|
||
<literal>checkLinkTargets</literal> script block checks for
|
||
collisions between non-managed files and files defined in
|
||
<xref linkend="opt-home.file"/>.
|
||
|
||
</para><para>
|
||
|
||
A script block should respect the <varname>DRY_RUN</varname>
|
||
variable, if it is set then the actions taken by the script
|
||
should be logged to standard out and not actually performed.
|
||
The variable <varname>DRY_RUN_CMD</varname> is set to
|
||
<command>echo</command> if dry run is enabled.
|
||
|
||
</para><para>
|
||
|
||
A script block should also respect the
|
||
<varname>VERBOSE</varname> variable, and if set print
|
||
information on standard out that may be useful for debugging
|
||
any issue that may arise. The variable
|
||
<varname>VERBOSE_ARG</varname> is set to
|
||
<option>--verbose</option> if verbose output is enabled.
|
||
'';
|
||
};
|
||
|
||
home.activationPackage = mkOption {
|
||
internal = true;
|
||
type = types.package;
|
||
description = "The package containing the complete activation script.";
|
||
};
|
||
|
||
home.extraActivationPath = mkOption {
|
||
internal = true;
|
||
type = types.listOf types.package;
|
||
default = [ ];
|
||
description = ''
|
||
Extra packages to add to <envar>PATH</envar> within the activation
|
||
script.
|
||
'';
|
||
};
|
||
|
||
home.extraBuilderCommands = mkOption {
|
||
type = types.lines;
|
||
default = "";
|
||
internal = true;
|
||
description = ''
|
||
Extra commands to run in the Home Manager generation builder.
|
||
'';
|
||
};
|
||
|
||
home.extraProfileCommands = mkOption {
|
||
type = types.lines;
|
||
default = "";
|
||
internal = true;
|
||
description = ''
|
||
Extra commands to run in the Home Manager profile builder.
|
||
'';
|
||
};
|
||
|
||
home.enableNixpkgsReleaseCheck = mkOption {
|
||
type = types.bool;
|
||
default = false; # Temporarily disabled until release stabilizes.
|
||
description = ''
|
||
Determines whether to check for release version mismatch between Home
|
||
Manager and Nixpkgs. Using mismatched versions is likely to cause errors
|
||
and unexpected behavior. It is therefore highly recommended to use a
|
||
release of Home Manager than corresponds with your chosen release of
|
||
Nixpkgs.
|
||
</para><para>
|
||
When this option is enabled and a mismatch is detected then a warning
|
||
will be printed when the user configuration is being built.
|
||
'';
|
||
};
|
||
};
|
||
|
||
config = {
|
||
assertions = [
|
||
{
|
||
assertion = config.home.username != "";
|
||
message = "Username could not be determined";
|
||
}
|
||
{
|
||
assertion = config.home.homeDirectory != "";
|
||
message = "Home directory could not be determined";
|
||
}
|
||
];
|
||
|
||
warnings =
|
||
let
|
||
hmRelease = fileContents ../.release;
|
||
nixpkgsRelease = pkgs.lib.trivial.release;
|
||
releaseMismatch =
|
||
config.home.enableNixpkgsReleaseCheck
|
||
&& hmRelease != nixpkgsRelease;
|
||
in
|
||
optional releaseMismatch ''
|
||
You are using
|
||
|
||
Home Manager version ${hmRelease} and
|
||
Nixpkgs version ${nixpkgsRelease}.
|
||
|
||
Using mismatched versions is likely to cause errors and unexpected
|
||
behavior. It is therefore highly recommended to use a release of Home
|
||
Manager than corresponds with your chosen release of Nixpkgs.
|
||
|
||
If you insist then you can disable this warning by adding
|
||
|
||
home.enableNixpkgsReleaseCheck = false;
|
||
|
||
to your configuration.
|
||
'';
|
||
|
||
home.username =
|
||
mkIf (versionOlder config.home.stateVersion "20.09")
|
||
(mkDefault (builtins.getEnv "USER"));
|
||
home.homeDirectory =
|
||
mkIf (versionOlder config.home.stateVersion "20.09")
|
||
(mkDefault (builtins.getEnv "HOME"));
|
||
|
||
home.profileDirectory =
|
||
if config.submoduleSupport.enable
|
||
&& config.submoduleSupport.externalPackageInstall
|
||
then "/etc/profiles/per-user/${cfg.username}"
|
||
else if config.nix.enable && (config.nix.settings.use-xdg-base-directories or false)
|
||
then "${config.xdg.stateHome}/nix/profile"
|
||
else cfg.homeDirectory + "/.nix-profile";
|
||
|
||
programs.bash.shellAliases = cfg.shellAliases;
|
||
programs.zsh.shellAliases = cfg.shellAliases;
|
||
programs.fish.shellAliases = cfg.shellAliases;
|
||
|
||
home.sessionVariables =
|
||
let
|
||
maybeSet = n: v: optionalAttrs (v != null) { ${n} = v; };
|
||
in
|
||
(maybeSet "LANG" cfg.language.base)
|
||
//
|
||
(maybeSet "LC_CTYPE" cfg.language.ctype)
|
||
//
|
||
(maybeSet "LC_NUMERIC" cfg.language.numeric)
|
||
//
|
||
(maybeSet "LC_TIME" cfg.language.time)
|
||
//
|
||
(maybeSet "LC_COLLATE" cfg.language.collate)
|
||
//
|
||
(maybeSet "LC_MONETARY" cfg.language.monetary)
|
||
//
|
||
(maybeSet "LC_MESSAGES" cfg.language.messages)
|
||
//
|
||
(maybeSet "LC_PAPER" cfg.language.paper)
|
||
//
|
||
(maybeSet "LC_NAME" cfg.language.name)
|
||
//
|
||
(maybeSet "LC_ADDRESS" cfg.language.address)
|
||
//
|
||
(maybeSet "LC_TELEPHONE" cfg.language.telephone)
|
||
//
|
||
(maybeSet "LC_MEASUREMENT" cfg.language.measurement);
|
||
|
||
home.packages = [
|
||
# Provide a file holding all session variables.
|
||
(
|
||
pkgs.writeTextFile {
|
||
name = "hm-session-vars.sh";
|
||
destination = "/etc/profile.d/hm-session-vars.sh";
|
||
text = ''
|
||
# Only source this once.
|
||
if [ -n "$__HM_SESS_VARS_SOURCED" ]; then return; fi
|
||
export __HM_SESS_VARS_SOURCED=1
|
||
|
||
${config.lib.shell.exportAll cfg.sessionVariables}
|
||
'' + lib.optionalString (cfg.sessionPath != [ ]) ''
|
||
export PATH="$PATH''${PATH:+:}${concatStringsSep ":" cfg.sessionPath}"
|
||
'' + cfg.sessionVariablesExtra;
|
||
}
|
||
)
|
||
];
|
||
|
||
# A dummy entry acting as a boundary between the activation
|
||
# script's "check" and the "write" phases.
|
||
home.activation.writeBoundary = hm.dag.entryAnywhere "";
|
||
|
||
# Install packages to the user environment.
|
||
#
|
||
# Note, sometimes our target may not allow modification of the Nix
|
||
# store and then we cannot rely on `nix-env -i`. This is the case,
|
||
# for example, if we are running as a NixOS module and building a
|
||
# virtual machine. Then we must instead rely on an external
|
||
# mechanism for installing packages, which in NixOS is provided by
|
||
# the `users.users.<name?>.packages` option. The activation
|
||
# command is still needed since some modules need to run their
|
||
# activation commands after the packages are guaranteed to be
|
||
# installed.
|
||
#
|
||
# In case the user has moved from a user-install of Home Manager
|
||
# to a submodule managed one we attempt to uninstall the
|
||
# `home-manager-path` package if it is installed.
|
||
home.activation.installPackages = hm.dag.entryAfter ["writeBoundary"] (
|
||
if config.submoduleSupport.externalPackageInstall
|
||
then
|
||
''
|
||
if [[ -e $HOME/.nix-profile/manifest.json ]] ; then
|
||
nix profile list \
|
||
| { grep 'home-manager-path$' || test $? = 1; } \
|
||
| cut -d ' ' -f 4 \
|
||
| xargs -t $DRY_RUN_CMD nix profile remove $VERBOSE_ARG
|
||
else
|
||
if nix-env -q | grep '^home-manager-path$'; then
|
||
$DRY_RUN_CMD nix-env -e home-manager-path
|
||
fi
|
||
fi
|
||
''
|
||
else
|
||
''
|
||
function nixReplaceProfile() {
|
||
local oldNix="$(command -v nix)"
|
||
|
||
nix profile list \
|
||
| { grep 'home-manager-path$' || test $? = 1; } \
|
||
| cut -d ' ' -f 4 \
|
||
| xargs -t $DRY_RUN_CMD nix profile remove $VERBOSE_ARG
|
||
|
||
$DRY_RUN_CMD $oldNix profile install $1
|
||
}
|
||
|
||
if [[ -e $HOME/.nix-profile/manifest.json ]] ; then
|
||
INSTALL_CMD="nix profile install"
|
||
INSTALL_CMD_ACTUAL="nixReplaceProfile"
|
||
LIST_CMD="nix profile list"
|
||
REMOVE_CMD_SYNTAX='nix profile remove {number | store path}'
|
||
else
|
||
INSTALL_CMD="nix-env -i"
|
||
INSTALL_CMD_ACTUAL="$DRY_RUN_CMD nix-env -i"
|
||
LIST_CMD="nix-env -q"
|
||
REMOVE_CMD_SYNTAX='nix-env -e {package name}'
|
||
fi
|
||
|
||
if ! $INSTALL_CMD_ACTUAL ${cfg.path} ; then
|
||
echo
|
||
_iError $'Oops, Nix failed to install your new Home Manager profile!\n\nPerhaps there is a conflict with a package that was installed using\n"%s"? Try running\n\n %s\n\nand if there is a conflicting package you can remove it with\n\n %s\n\nThen try activating your Home Manager configuration again.' "$INSTALL_CMD" "$LIST_CMD" "$REMOVE_CMD_SYNTAX"
|
||
exit 1
|
||
fi
|
||
unset -f nixReplaceProfile
|
||
unset INSTALL_CMD INSTALL_CMD_ACTUAL LIST_CMD REMOVE_CMD_SYNTAX
|
||
''
|
||
);
|
||
|
||
# Text containing Bash commands that will initialize the Home Manager Bash
|
||
# library. Most importantly, this will prepare for using translated strings
|
||
# in the `hm-modules` text domain.
|
||
lib.bash.initHomeManagerLib =
|
||
let
|
||
domainDir = pkgs.runCommand "hm-modules-messages" {
|
||
nativeBuildInputs = [ pkgs.buildPackages.gettext ];
|
||
} ''
|
||
for path in ${./po}/*.po; do
|
||
lang="''${path##*/}"
|
||
lang="''${lang%%.*}"
|
||
mkdir -p "$out/$lang/LC_MESSAGES"
|
||
msgfmt -o "$out/$lang/LC_MESSAGES/hm-modules.mo" "$path"
|
||
done
|
||
'';
|
||
in
|
||
''
|
||
export TEXTDOMAIN=hm-modules
|
||
export TEXTDOMAINDIR=${domainDir}
|
||
source ${../lib/bash/home-manager.sh}
|
||
'';
|
||
|
||
home.activationPackage =
|
||
let
|
||
mkCmd = res: ''
|
||
_iNote "Activating %s" "${res.name}"
|
||
${res.data}
|
||
'';
|
||
sortedCommands = hm.dag.topoSort cfg.activation;
|
||
activationCmds =
|
||
if sortedCommands ? result then
|
||
concatStringsSep "\n" (map mkCmd sortedCommands.result)
|
||
else
|
||
abort ("Dependency cycle in activation script: "
|
||
+ builtins.toJSON sortedCommands);
|
||
|
||
# Programs that always should be available on the activation
|
||
# script's PATH.
|
||
activationBinPaths = lib.makeBinPath (
|
||
with pkgs; [
|
||
bash
|
||
coreutils
|
||
diffutils # For `cmp` and `diff`.
|
||
findutils
|
||
gettext
|
||
gnugrep
|
||
gnused
|
||
ncurses # For `tput`.
|
||
]
|
||
++ config.home.extraActivationPath
|
||
)
|
||
+ (
|
||
# Add path of the Nix binaries, if a Nix package is configured, then
|
||
# use that one, otherwise grab the path of the nix-env tool.
|
||
if config.nix.enable && config.nix.package != null then
|
||
":${config.nix.package}/bin"
|
||
else
|
||
":$(${pkgs.coreutils}/bin/dirname $(${pkgs.coreutils}/bin/readlink -m $(type -p nix-env)))"
|
||
)
|
||
+ optionalString (!cfg.emptyActivationPath) "\${PATH:+:}$PATH";
|
||
|
||
activationScript = pkgs.writeShellScript "activation-script" ''
|
||
set -eu
|
||
set -o pipefail
|
||
|
||
cd $HOME
|
||
|
||
export PATH="${activationBinPaths}"
|
||
${config.lib.bash.initHomeManagerLib}
|
||
|
||
${builtins.readFile ./lib-bash/activation-init.sh}
|
||
|
||
${activationCmds}
|
||
'';
|
||
in
|
||
pkgs.runCommand
|
||
"home-manager-generation"
|
||
{
|
||
preferLocalBuild = true;
|
||
}
|
||
''
|
||
mkdir -p $out
|
||
|
||
echo "${config.home.version.full}" > $out/hm-version
|
||
|
||
cp ${activationScript} $out/activate
|
||
|
||
mkdir $out/bin
|
||
ln -s $out/activate $out/bin/home-manager-generation
|
||
|
||
substituteInPlace $out/activate \
|
||
--subst-var-by GENERATION_DIR $out
|
||
|
||
ln -s ${config.home-files} $out/home-files
|
||
ln -s ${cfg.path} $out/home-path
|
||
|
||
${cfg.extraBuilderCommands}
|
||
'';
|
||
|
||
home.path = pkgs.buildEnv {
|
||
name = "home-manager-path";
|
||
|
||
paths = cfg.packages;
|
||
inherit (cfg) extraOutputsToInstall;
|
||
|
||
postBuild = cfg.extraProfileCommands;
|
||
|
||
meta = {
|
||
description = "Environment of packages installed through home-manager";
|
||
};
|
||
};
|
||
};
|
||
}
|