commit 4433bbfd2a22dedc0372b3eb7d90b57631c9fbed · pyrox.dev/nixpkgs

+7 -9

nixos/modules/programs/_1password-gui.nix

···

       1
       1
        
       { config, pkgs, lib, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
       

     

       7
       5
        
         cfg = config.programs._1password-gui;

     
···

       9
       7
        
       in

     

       10
       8
        
       {

     

       11
       9
        
         imports = [

     

       12
       12
       -
           (mkRemovedOptionModule [ "programs" "_1password-gui" "gid" ] ''

     

       10
       10
       +
           (lib.mkRemovedOptionModule [ "programs" "_1password-gui" "gid" ] ''

     

       13
       11
        
             A preallocated GID will be used instead.

     

       14
       12
        
           '')

     

       15
       13
        
         ];

     

       16
       14
        
       

     

       17
       15
        
         options = {

     

       18
       16
        
           programs._1password-gui = {

     

       19
       19
       -
             enable = mkEnableOption "the 1Password GUI application";

     

       17
       17
       +
             enable = lib.mkEnableOption "the 1Password GUI application";

     

       20
       18
        
       

     

       21
       21
       -
             polkitPolicyOwners = mkOption {

     

       22
       22
       -
               type = types.listOf types.str;

     

       19
       19
       +
             polkitPolicyOwners = lib.mkOption {

     

       20
       20
       +
               type = lib.types.listOf lib.types.str;

     

       23
       21
        
               default = [ ];

     

       24
       24
       -
               example = literalExpression ''["user1" "user2" "user3"]'';

     

       22
       22
       +
               example = lib.literalExpression ''["user1" "user2" "user3"]'';

     

       25
       23
        
               description = ''

     

       26
       24
        
                 A list of users who should be able to integrate 1Password with polkit-based authentication mechanisms.

     

       27
       25
        
               '';

     

       28
       26
        
             };

     

       29
       27
        
       

     

       30
       30
       -
             package = mkPackageOption pkgs "1Password GUI" {

     

       28
       28
       +
             package = lib.mkPackageOption pkgs "1Password GUI" {

     

       31
       29
        
               default = [ "_1password-gui" ];

     

       32
       30
        
             };

     

       33
       31
        
           };

     
···

       39
       37
        
               polkitPolicyOwners = cfg.polkitPolicyOwners;

     

       40
       38
        
             };

     

       41
       39
        
           in

     

       42
       42
       -
           mkIf cfg.enable {

     

       40
       40
       +
           lib.mkIf cfg.enable {

     

       43
       41
        
             environment.systemPackages = [ package ];

     

       44
       42
        
             users.groups.onepassword.gid = config.ids.gids.onepassword;

     

       45
       43

+4 -6

nixos/modules/programs/_1password.nix

···

       1
       1
        
       { config, pkgs, lib, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
       

     

       7
       5
        
         cfg = config.programs._1password;

     
···

       9
       7
        
       in

     

       10
       8
        
       {

     

       11
       9
        
         imports = [

     

       12
       12
       -
           (mkRemovedOptionModule [ "programs" "_1password" "gid" ] ''

     

       10
       10
       +
           (lib.mkRemovedOptionModule [ "programs" "_1password" "gid" ] ''

     

       13
       11
        
             A preallocated GID will be used instead.

     

       14
       12
        
           '')

     

       15
       13
        
         ];

     

       16
       14
        
       

     

       17
       15
        
         options = {

     

       18
       16
        
           programs._1password = {

     

       19
       19
       -
             enable = mkEnableOption "the 1Password CLI tool";

     

       17
       17
       +
             enable = lib.mkEnableOption "the 1Password CLI tool";

     

       20
       18
        
       

     

       21
       21
       -
             package = mkPackageOption pkgs "1Password CLI" {

     

       19
       19
       +
             package = lib.mkPackageOption pkgs "1Password CLI" {

     

       22
       20
        
               default = [ "_1password" ];

     

       23
       21
        
             };

     

       24
       22
        
           };

     

       25
       23
        
         };

     

       26
       24
        
       

     

       27
       27
       -
         config = mkIf cfg.enable {

     

       25
       25
       +
         config = lib.mkIf cfg.enable {

     

       28
       26
        
           environment.systemPackages = [ cfg.package ];

     

       29
       27
        
           users.groups.onepassword-cli.gid = config.ids.gids.onepassword-cli;

     

       30
       28

+4 -6

nixos/modules/programs/adb.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       {

     

       6
       6
       -
         meta.maintainers = [ maintainers.mic92 ];

     

       4
       4
       +
         meta.maintainers = [ lib.maintainers.mic92 ];

     

       7
       5
        
       

     

       8
       6
        
         ###### interface

     

       9
       7
        
         options = {

     

       10
       8
        
           programs.adb = {

     

       11
       11
       -
             enable = mkOption {

     

       9
       9
       +
             enable = lib.mkOption {

     

       12
       10
        
               default = false;

     

       13
       13
       -
               type = types.bool;

     

       11
       11
       +
               type = lib.types.bool;

     

       14
       12
        
               description = ''

     

       15
       13
        
                 Whether to configure system to use Android Debug Bridge (adb).

     

       16
       14
        
                 To grant access to a user, it must be part of adbusers group:

     
···

       21
       19
        
         };

     

       22
       20
        
       

     

       23
       21
        
         ###### implementation

     

       24
       24
       -
         config = mkIf config.programs.adb.enable {

     

       22
       22
       +
         config = lib.mkIf config.programs.adb.enable {

     

       25
       23
        
           services.udev.packages = [ pkgs.android-udev-rules ];

     

       26
       24
        
           environment.systemPackages = [ pkgs.android-tools ];

     

       27
       25
        
           users.groups.adbusers = {};

+7 -9

nixos/modules/programs/alvr.nix

···

       1
       1
        
       { config, pkgs, lib, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.alvr;

     

       7
       5
        
       in

     

       8
       6
        
       {

     

       9
       7
        
         options = {

     

       10
       8
        
           programs.alvr = {

     

       11
       11
       -
             enable = mkEnableOption "ALVR, the VR desktop streamer";

     

       9
       9
       +
             enable = lib.mkEnableOption "ALVR, the VR desktop streamer";

     

       12
       10
        
       

     

       13
       13
       -
             package = mkPackageOption pkgs "alvr" { };

     

       11
       11
       +
             package = lib.mkPackageOption pkgs "alvr" { };

     

       14
       12
        
       

     

       15
       15
       -
             openFirewall = mkOption {

     

       16
       16
       -
               type = types.bool;

     

       13
       13
       +
             openFirewall = lib.mkOption {

     

       14
       14
       +
               type = lib.types.bool;

     

       17
       15
        
               default = false;

     

       18
       16
        
               description = ''

     

       19
       17
        
                 Whether to open the default ports in the firewall for the ALVR server.

     
···

       22
       20
        
           };

     

       23
       21
        
         };

     

       24
       22
        
       

     

       25
       25
       -
         config = mkIf cfg.enable {

     

       23
       23
       +
         config = lib.mkIf cfg.enable {

     

       26
       24
        
           environment.systemPackages = [ cfg.package ];

     

       27
       25
        
       

     

       28
       28
       -
           networking.firewall = mkIf cfg.openFirewall {

     

       26
       26
       +
           networking.firewall = lib.mkIf cfg.openFirewall {

     

       29
       27
        
             allowedTCPPorts = [ 9943 9944 ];

     

       30
       28
        
             allowedUDPPorts = [ 9943 9944 ];

     

       31
       29
        
           };

     

       32
       30
        
         };

     

       33
       31
        
       

     

       34
       34
       -
         meta.maintainers = with maintainers; [ passivelemon ];

     

       32
       32
       +
         meta.maintainers = with lib.maintainers; [ passivelemon ];

     

       35
       33
        
       }

+2 -4

nixos/modules/programs/appgate-sdp.nix

···

       1
       1
        
       { config, pkgs, lib, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       {

     

       6
       4
        
         options = {

     

       7
       5
        
           programs.appgate-sdp = {

     

       8
       8
       -
             enable = mkEnableOption "the AppGate SDP VPN client";

     

       6
       6
       +
             enable = lib.mkEnableOption "the AppGate SDP VPN client";

     

       9
       7
        
           };

     

       10
       8
        
         };

     

       11
       9
        
       

     

       12
       12
       -
         config = mkIf config.programs.appgate-sdp.enable {

     

       10
       10
       +
         config = lib.mkIf config.programs.appgate-sdp.enable {

     

       13
       11
        
           boot.kernelModules = [ "tun" ];

     

       14
       12
        
           environment.systemPackages = [ pkgs.appgate-sdp ];

     

       15
       13
        
           services.dbus.packages = [ pkgs.appgate-sdp ];

+26 -28

nixos/modules/programs/atop.nix

···

       2
       2
        
       

     

       3
       3
        
       { config, lib, pkgs, ... }:

     

       4
       4
        
       

     

       5
       5
       -
       with lib;

     

       6
       6
       -
       

     

       7
       5
        
       let cfg = config.programs.atop;

     

       8
       6
        
       

     

       9
       7
        
       in

     
···

       14
       12
        
       

     

       15
       13
        
           programs.atop = rec {

     

       16
       14
        
       

     

       17
       17
       -
             enable = mkEnableOption "Atop, a tool for monitoring system resources";

     

       15
       15
       +
             enable = lib.mkEnableOption "Atop, a tool for monitoring system resources";

     

       18
       16
        
       

     

       19
       19
       -
             package = mkPackageOption pkgs "atop" { };

     

       17
       17
       +
             package = lib.mkPackageOption pkgs "atop" { };

     

       20
       18
        
       

     

       21
       19
        
             netatop = {

     

       22
       22
       -
               enable = mkOption {

     

       23
       23
       -
                 type = types.bool;

     

       20
       20
       +
               enable = lib.mkOption {

     

       21
       21
       +
                 type = lib.types.bool;

     

       24
       22
        
                 default = false;

     

       25
       23
        
                 description = ''

     

       26
       24
        
                   Whether to install and enable the netatop kernel module.

     

       27
       25
        
                   Note: this sets the kernel taint flag "O" for loading out-of-tree modules.

     

       28
       26
        
                 '';

     

       29
       27
        
               };

     

       30
       30
       -
               package = mkOption {

     

       31
       31
       -
                 type = types.package;

     

       28
       28
       +
               package = lib.mkOption {

     

       29
       29
       +
                 type = lib.types.package;

     

       32
       30
        
                 default = config.boot.kernelPackages.netatop;

     

       33
       33
       -
                 defaultText = literalExpression "config.boot.kernelPackages.netatop";

     

       31
       31
       +
                 defaultText = lib.literalExpression "config.boot.kernelPackages.netatop";

     

       34
       32
        
                 description = ''

     

       35
       33
        
                   Which package to use for netatop.

     

       36
       34
        
                 '';

     

       37
       35
        
               };

     

       38
       36
        
             };

     

       39
       37
        
       

     

       40
       40
       -
             atopgpu.enable = mkOption {

     

       41
       41
       -
               type = types.bool;

     

       38
       38
       +
             atopgpu.enable = lib.mkOption {

     

       39
       39
       +
               type = lib.types.bool;

     

       42
       40
        
               default = false;

     

       43
       41
        
               description = ''

     

       44
       42
        
                 Whether to install and enable the atopgpud daemon to get information about

     
···

       46
       44
        
               '';

     

       47
       45
        
             };

     

       48
       46
        
       

     

       49
       49
       -
             setuidWrapper.enable = mkOption {

     

       50
       50
       -
               type = types.bool;

     

       47
       47
       +
             setuidWrapper.enable = lib.mkOption {

     

       48
       48
       +
               type = lib.types.bool;

     

       51
       49
        
               default = false;

     

       52
       50
        
               description = ''

     

       53
       51
        
                 Whether to install a setuid wrapper for Atop. This is required to use some of

     
···

       56
       54
        
               '';

     

       57
       55
        
             };

     

       58
       56
        
       

     

       59
       59
       -
             atopService.enable = mkOption {

     

       60
       60
       -
               type = types.bool;

     

       57
       57
       +
             atopService.enable = lib.mkOption {

     

       58
       58
       +
               type = lib.types.bool;

     

       61
       59
        
               default = true;

     

       62
       60
        
               description = ''

     

       63
       61
        
                 Whether to enable the atop service responsible for storing statistics for

     

       64
       62
        
                 long-term analysis.

     

       65
       63
        
               '';

     

       66
       64
        
             };

     

       67
       67
       -
             atopRotateTimer.enable = mkOption {

     

       68
       68
       -
               type = types.bool;

     

       65
       65
       +
             atopRotateTimer.enable = lib.mkOption {

     

       66
       66
       +
               type = lib.types.bool;

     

       69
       67
        
               default = true;

     

       70
       68
        
               description = ''

     

       71
       69
        
                 Whether to enable the atop-rotate timer, which restarts the atop service

     

       72
       70
        
                 daily to make sure the data files are rotate.

     

       73
       71
        
               '';

     

       74
       72
        
             };

     

       75
       75
       -
             atopacctService.enable = mkOption {

     

       76
       76
       -
               type = types.bool;

     

       73
       73
       +
             atopacctService.enable = lib.mkOption {

     

       74
       74
       +
               type = lib.types.bool;

     

       77
       75
        
               default = true;

     

       78
       76
        
               description = ''

     

       79
       77
        
                 Whether to enable the atopacct service which manages process accounting.

     
···

       81
       79
        
                 two refresh intervals.

     

       82
       80
        
               '';

     

       83
       81
        
             };

     

       84
       84
       -
             settings = mkOption {

     

       85
       85
       -
               type = types.attrs;

     

       82
       82
       +
             settings = lib.mkOption {

     

       83
       83
       +
               type = lib.types.attrs;

     

       86
       84
        
               default = { };

     

       87
       85
        
               example = {

     

       88
       86
        
                 flags = "a1f";

     
···

       95
       93
        
           };

     

       96
       94
        
         };

     

       97
       95
        
       

     

       98
       98
       -
         config = mkIf cfg.enable (

     

       96
       96
       +
         config = lib.mkIf cfg.enable (

     

       99
       97
        
           let

     

       100
       98
        
             atop =

     

       101
       99
        
               if cfg.atopgpu.enable then

     
···

       104
       102
        
                 cfg.package;

     

       105
       103
        
           in

     

       106
       104
        
           {

     

       107
       107
       -
             environment.etc = mkIf (cfg.settings != { }) {

     

       108
       108
       -
               atoprc.text = concatStrings

     

       109
       109
       -
                 (mapAttrsToList

     

       105
       105
       +
             environment.etc = lib.mkIf (cfg.settings != { }) {

     

       106
       106
       +
               atoprc.text = lib.concatStrings

     

       107
       107
       +
                 (lib.mapAttrsToList

     

       110
       108
        
                   (n: v: ''

     

       111
       111
       -
                     ${n} ${toString v}

     

       109
       109
       +
                     ${n} ${builtins.toString v}

     

       112
       110
        
                   '')

     

       113
       111
        
                   cfg.settings);

     

       114
       112
        
             };

     
···

       122
       120
        
                     wantedBy = [ (if type == "services" then "multi-user.target" else if type == "timers" then "timers.target" else null) ];

     

       123
       121
        
                   };

     

       124
       122
        
                 };

     

       125
       125
       -
                 mkService = mkSystemd "services";

     

       126
       126
       -
                 mkTimer = mkSystemd "timers";

     

       123
       123
       +
                 mkService = lib.mkSystemd "services";

     

       124
       124
       +
                 mkTimer = lib.mkSystemd "timers";

     

       127
       125
        
               in

     

       128
       126
        
               {

     

       129
       127
        
                 packages = [ atop (lib.mkIf cfg.netatop.enable cfg.netatop.package) ];

+3 -5

nixos/modules/programs/ausweisapp.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg  = config.programs.ausweisapp;

     

       7
       5
        
       in

     

       8
       6
        
       {

     

       9
       7
        
         options.programs.ausweisapp = {

     

       10
       10
       -
           enable = mkEnableOption "AusweisApp";

     

       8
       8
       +
           enable = lib.mkEnableOption "AusweisApp";

     

       11
       9
        
       

     

       12
       12
       -
           openFirewall = mkOption {

     

       10
       10
       +
           openFirewall = lib.mkOption {

     

       13
       11
        
             description = ''

     

       14
       12
        
               Whether to open the required firewall ports for the Smartphone as Card Reader (SaC) functionality of AusweisApp.

     

       15
       13
        
             '';

     
···

       18
       16
        
           };

     

       19
       17
        
         };

     

       20
       18
        
       

     

       21
       21
       -
         config = mkIf cfg.enable {

     

       19
       19
       +
         config = lib.mkIf cfg.enable {

     

       22
       20
        
           environment.systemPackages = with pkgs; [ ausweisapp ];

     

       23
       21
        
           networking.firewall.allowedUDPPorts = lib.optionals cfg.openFirewall [ 24727 ];

     

       24
       22
        
         };

+5 -7

nixos/modules/programs/autojump.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.autojump;

     

       7
       5
        
         prg = config.programs;

     
···

       10
       8
        
         options = {

     

       11
       9
        
           programs.autojump = {

     

       12
       10
        
       

     

       13
       13
       -
             enable = mkOption {

     

       14
       14
       -
               type = types.bool;

     

       11
       11
       +
             enable = lib.mkOption {

     

       12
       12
       +
               type = lib.types.bool;

     

       15
       13
        
               default = false;

     

       16
       14
        
               description = ''

     

       17
       15
        
                 Whether to enable autojump.

     
···

       22
       20
        
       

     

       23
       21
        
         ###### implementation

     

       24
       22
        
       

     

       25
       25
       -
         config = mkIf cfg.enable {

     

       23
       23
       +
         config = lib.mkIf cfg.enable {

     

       26
       24
        
           environment.pathsToLink = [ "/share/autojump" ];

     

       27
       25
        
           environment.systemPackages = [ pkgs.autojump ];

     

       28
       26
        
       

     

       29
       27
        
           programs.bash.interactiveShellInit = "source ${pkgs.autojump}/share/autojump/autojump.bash";

     

       30
       30
       -
           programs.zsh.interactiveShellInit = mkIf prg.zsh.enable "source ${pkgs.autojump}/share/autojump/autojump.zsh";

     

       31
       31
       -
           programs.fish.interactiveShellInit = mkIf prg.fish.enable "source ${pkgs.autojump}/share/autojump/autojump.fish";

     

       28
       28
       +
           programs.zsh.interactiveShellInit = lib.mkIf prg.zsh.enable "source ${pkgs.autojump}/share/autojump/autojump.zsh";

     

       29
       29
       +
           programs.fish.interactiveShellInit = lib.mkIf prg.fish.enable "source ${pkgs.autojump}/share/autojump/autojump.fish";

     

       32
       30
        
         };

     

       33
       31
        
       }

+4 -6

nixos/modules/programs/bandwhich.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let cfg = config.programs.bandwhich;

     

       6
       4
        
       in {

     

       7
       7
       -
         meta.maintainers = with maintainers; [ Br1ght0ne ];

     

       5
       5
       +
         meta.maintainers = with lib.maintainers; [ Br1ght0ne ];

     

       8
       6
        
       

     

       9
       7
        
         options = {

     

       10
       8
        
           programs.bandwhich = {

     

       11
       11
       -
             enable = mkOption {

     

       12
       12
       -
               type = types.bool;

     

       9
       9
       +
             enable = lib.mkOption {

     

       10
       10
       +
               type = lib.types.bool;

     

       13
       11
        
               default = false;

     

       14
       12
        
               description = ''

     

       15
       13
        
                 Whether to add bandwhich to the global environment and configure a

     
···

       19
       17
        
           };

     

       20
       18
        
         };

     

       21
       19
        
       

     

       22
       22
       -
         config = mkIf cfg.enable {

     

       20
       20
       +
         config = lib.mkIf cfg.enable {

     

       23
       21
        
           environment.systemPackages = with pkgs; [ bandwhich ];

     

       24
       22
        
           security.wrappers.bandwhich = {

     

       25
       23
        
             owner = "root";

+2 -4

nixos/modules/programs/bash-my-aws.nix

···

       1
       1
        
       { config, pkgs, lib, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         prg = config.programs;

     

       7
       5
        
         cfg = prg.bash-my-aws;

     
···

       13
       11
        
         {

     

       14
       12
        
           options = {

     

       15
       13
        
             programs.bash-my-aws = {

     

       16
       16
       -
               enable = mkEnableOption "bash-my-aws";

     

       14
       14
       +
               enable = lib.mkEnableOption "bash-my-aws";

     

       17
       15
        
             };

     

       18
       16
        
           };

     

       19
       17
        
       

     

       20
       20
       -
           config = mkIf cfg.enable {

     

       18
       18
       +
           config = lib.mkIf cfg.enable {

     

       21
       19
        
             environment.systemPackages = with pkgs; [ bash-my-aws ];

     

       22
       20
        
       

     

       23
       21
        
             programs.bash.interactiveShellInit = initScript;

+2 -4

nixos/modules/programs/bash/bash-completion.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         enable = config.programs.bash.enableCompletion;

     

       7
       5
        
       in

     

       8
       6
        
       {

     

       9
       7
        
         options = {

     

       10
       10
       -
           programs.bash.enableCompletion = mkEnableOption "Bash completion for all interactive bash shells" // {

     

       8
       8
       +
           programs.bash.enableCompletion = lib.mkEnableOption "Bash completion for all interactive bash shells" // {

     

       11
       9
        
             default = true;

     

       12
       10
        
           };

     

       13
       11
        
         };

     

       14
       12
        
       

     

       15
       15
       -
         config = mkIf enable {

     

       13
       13
       +
         config = lib.mkIf enable {

     

       16
       14
        
           programs.bash.promptPluginInit = ''

     

       17
       15
        
             # Check whether we're running a version of Bash that has support for

     

       18
       16
        
             # programmable completion. If we do, enable all modules installed in

+23 -25

nixos/modules/programs/bash/bash.nix

···

       3
       3
        
       

     

       4
       4
        
       { config, lib, pkgs, ... }:

     

       5
       5
        
       

     

       6
       6
       -
       with lib;

     

       7
       7
       -
       

     

       8
       6
        
       let

     

       9
       7
        
       

     

       10
       8
        
         cfge = config.environment;

     

       11
       9
        
       

     

       12
       10
        
         cfg = config.programs.bash;

     

       13
       11
        
       

     

       14
       14
       -
         bashAliases = concatStringsSep "\n" (

     

       15
       15
       -
           mapAttrsFlatten (k: v: "alias -- ${k}=${escapeShellArg v}")

     

       16
       16
       -
             (filterAttrs (k: v: v != null) cfg.shellAliases)

     

       12
       12
       +
         bashAliases = builtins.concatStringsSep "\n" (

     

       13
       13
       +
           lib.mapAttrsFlatten (k: v: "alias -- ${k}=${lib.escapeShellArg v}")

     

       14
       14
       +
             (lib.filterAttrs (k: v: v != null) cfg.shellAliases)

     

       17
       15
        
         );

     

       18
       16
        
       

     

       19
       17
        
       in

     

       20
       18
        
       

     

       21
       19
        
       {

     

       22
       20
        
         imports = [

     

       23
       23
       -
           (mkRemovedOptionModule [ "programs" "bash" "enable" ] "")

     

       21
       21
       +
           (lib.mkRemovedOptionModule [ "programs" "bash" "enable" ] "")

     

       24
       22
        
         ];

     

       25
       23
        
       

     

       26
       24
        
         options = {

     
···

       28
       26
        
           programs.bash = {

     

       29
       27
        
       

     

       30
       28
        
             /*

     

       31
       31
       -
             enable = mkOption {

     

       29
       29
       +
             enable = lib.mkOption {

     

       32
       30
        
               default = true;

     

       33
       31
        
               description = ''

     

       34
       32
        
                 Whenever to configure Bash as an interactive shell.

     
···

       38
       36
        
                 set this variable if you have another shell configured

     

       39
       37
        
                 with NixOS.

     

       40
       38
        
               '';

     

       41
       41
       -
               type = types.bool;

     

       39
       39
       +
               type = lib.types.bool;

     

       42
       40
        
             };

     

       43
       41
        
             */

     

       44
       42
        
       

     

       45
       45
       -
             shellAliases = mkOption {

     

       43
       43
       +
             shellAliases = lib.mkOption {

     

       46
       44
        
               default = {};

     

       47
       45
        
               description = ''

     

       48
       46
        
                 Set of aliases for bash shell, which overrides {option}`environment.shellAliases`.

     

       49
       47
        
                 See {option}`environment.shellAliases` for an option format description.

     

       50
       48
        
               '';

     

       51
       51
       -
               type = with types; attrsOf (nullOr (either str path));

     

       49
       49
       +
               type = with lib.types; attrsOf (nullOr (either str path));

     

       52
       50
        
             };

     

       53
       51
        
       

     

       54
       54
       -
             shellInit = mkOption {

     

       52
       52
       +
             shellInit = lib.mkOption {

     

       55
       53
        
               default = "";

     

       56
       54
        
               description = ''

     

       57
       55
        
                 Shell script code called during bash shell initialisation.

     

       58
       56
        
               '';

     

       59
       59
       -
               type = types.lines;

     

       57
       57
       +
               type = lib.types.lines;

     

       60
       58
        
             };

     

       61
       59
        
       

     

       62
       62
       -
             loginShellInit = mkOption {

     

       60
       60
       +
             loginShellInit = lib.mkOption {

     

       63
       61
        
               default = "";

     

       64
       62
        
               description = ''

     

       65
       63
        
                 Shell script code called during login bash shell initialisation.

     

       66
       64
        
               '';

     

       67
       67
       -
               type = types.lines;

     

       65
       65
       +
               type = lib.types.lines;

     

       68
       66
        
             };

     

       69
       67
        
       

     

       70
       70
       -
             interactiveShellInit = mkOption {

     

       68
       68
       +
             interactiveShellInit = lib.mkOption {

     

       71
       69
        
               default = "";

     

       72
       70
        
               description = ''

     

       73
       71
        
                 Shell script code called during interactive bash shell initialisation.

     

       74
       72
        
               '';

     

       75
       75
       -
               type = types.lines;

     

       73
       73
       +
               type = lib.types.lines;

     

       76
       74
        
             };

     

       77
       75
        
       

     

       78
       78
       -
             promptInit = mkOption {

     

       76
       76
       +
             promptInit = lib.mkOption {

     

       79
       77
        
               default = ''

     

       80
       78
        
                 # Provide a nice prompt if the terminal supports it.

     

       81
       79
        
                 if [ "$TERM" != "dumb" ] || [ -n "$INSIDE_EMACS" ]; then

     
···

       95
       93
        
               description = ''

     

       96
       94
        
                 Shell script code used to initialise the bash prompt.

     

       97
       95
        
               '';

     

       98
       98
       -
               type = types.lines;

     

       96
       96
       +
               type = lib.types.lines;

     

       99
       97
        
             };

     

       100
       98
        
       

     

       101
       101
       -
             promptPluginInit = mkOption {

     

       99
       99
       +
             promptPluginInit = lib.mkOption {

     

       102
       100
        
               default = "";

     

       103
       101
        
               description = ''

     

       104
       102
        
                 Shell script code used to initialise bash prompt plugins.

     

       105
       103
        
               '';

     

       106
       106
       -
               type = types.lines;

     

       104
       104
       +
               type = lib.types.lines;

     

       107
       105
        
               internal = true;

     

       108
       106
        
             };

     

       109
       107
        
       

     
···

       111
       109
        
       

     

       112
       110
        
         };

     

       113
       111
        
       

     

       114
       114
       -
         config = /* mkIf cfg.enable */ {

     

       112
       112
       +
         config = /* lib.mkIf cfg.enable */ {

     

       115
       113
        
       

     

       116
       114
        
           programs.bash = {

     

       117
       115
        
       

     

       118
       118
       -
             shellAliases = mapAttrs (name: mkDefault) cfge.shellAliases;

     

       116
       116
       +
             shellAliases = builtins.mapAttrs (name: lib.mkDefault) cfge.shellAliases;

     

       119
       117
        
       

     

       120
       118
        
             shellInit = ''

     

       121
       119
        
               if [ -z "$__NIXOS_SET_ENVIRONMENT_DONE" ]; then

     
···

       196
       194
        
       

     

       197
       195
        
           # Configuration for readline in bash. We use "option default"

     

       198
       196
        
           # priority to allow user override using both .text and .source.

     

       199
       199
       -
           environment.etc.inputrc.source = mkOptionDefault ./inputrc;

     

       197
       197
       +
           environment.etc.inputrc.source = lib.mkOptionDefault ./inputrc;

     

       200
       198
        
       

     

       201
       201
       -
           users.defaultUserShell = mkDefault pkgs.bashInteractive;

     

       199
       199
       +
           users.defaultUserShell = lib.mkDefault pkgs.bashInteractive;

     

       202
       200
        
       

     

       203
       203
       -
           environment.pathsToLink = optionals cfg.enableCompletion [

     

       201
       201
       +
           environment.pathsToLink = lib.optionals cfg.enableCompletion [

     

       204
       202
        
             "/etc/bash_completion.d"

     

       205
       203
        
             "/share/bash-completion"

     

       206
       204
        
           ];

+4 -5

nixos/modules/programs/bash/blesh.nix

···

       1
       1
        
       { lib, config, pkgs, ... }:

     

       2
       2
       -
       with lib;

     

       3
       2
        
       let

     

       4
       3
        
         cfg = config.programs.bash.blesh;

     

       5
       4
        
       in {

     

       6
       5
        
         options = {

     

       7
       7
       -
           programs.bash.blesh.enable = mkEnableOption "blesh, a full-featured line editor written in pure Bash";

     

       6
       6
       +
           programs.bash.blesh.enable = lib.mkEnableOption "blesh, a full-featured line editor written in pure Bash";

     

       8
       7
        
         };

     

       9
       8
        
       

     

       10
       10
       -
         config = mkIf cfg.enable {

     

       11
       11
       -
           programs.bash.interactiveShellInit = mkBefore ''

     

       9
       9
       +
         config = lib.mkIf cfg.enable {

     

       10
       10
       +
           programs.bash.interactiveShellInit = lib.mkBefore ''

     

       12
       11
        
             source ${pkgs.blesh}/share/blesh/ble.sh

     

       13
       12
        
           '';

     

       14
       13
        
         };

     

       15
       15
       -
         meta.maintainers = with maintainers; [ laalsaas ];

     

       14
       14
       +
         meta.maintainers = with lib.maintainers; [ laalsaas ];

     

       16
       15
        
       }

+2 -4

nixos/modules/programs/bash/ls-colors.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         enable = config.programs.bash.enableLsColors;

     

       7
       5
        
       in

     

       8
       6
        
       {

     

       9
       7
        
         options = {

     

       10
       10
       -
           programs.bash.enableLsColors = mkEnableOption "extra colors in directory listings" // {

     

       8
       8
       +
           programs.bash.enableLsColors = lib.mkEnableOption "extra colors in directory listings" // {

     

       11
       9
        
             default = true;

     

       12
       10
        
           };

     

       13
       11
        
         };

     

       14
       12
        
       

     

       15
       15
       -
         config = mkIf enable {

     

       13
       13
       +
         config = lib.mkIf enable {

     

       16
       14
        
           programs.bash.promptPluginInit = ''

     

       17
       15
        
             eval "$(${pkgs.coreutils}/bin/dircolors -b)"

     

       18
       16
        
           '';

+7 -9

nixos/modules/programs/bash/undistract-me.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.bash.undistractMe;

     

       7
       5
        
       in

     

       8
       6
        
       {

     

       9
       7
        
         options = {

     

       10
       8
        
           programs.bash.undistractMe = {

     

       11
       11
       -
             enable = mkEnableOption "notifications when long-running terminal commands complete";

     

       9
       9
       +
             enable = lib.mkEnableOption "notifications when long-running terminal commands complete";

     

       12
       10
        
       

     

       13
       13
       -
             playSound = mkEnableOption "notification sounds when long-running terminal commands complete";

     

       11
       11
       +
             playSound = lib.mkEnableOption "notification sounds when long-running terminal commands complete";

     

       14
       12
        
       

     

       15
       15
       -
             timeout = mkOption {

     

       13
       13
       +
             timeout = lib.mkOption {

     

       16
       14
        
               default = 10;

     

       17
       15
        
               description = ''

     

       18
       16
        
                 Number of seconds it would take for a command to be considered long-running.

     

       19
       17
        
               '';

     

       20
       20
       -
               type = types.int;

     

       18
       18
       +
               type = lib.types.int;

     

       21
       19
        
             };

     

       22
       20
        
           };

     

       23
       21
        
         };

     

       24
       22
        
       

     

       25
       25
       -
         config = mkIf cfg.enable {

     

       23
       23
       +
         config = lib.mkIf cfg.enable {

     

       26
       24
        
           programs.bash.promptPluginInit = ''

     

       27
       27
       -
             export LONG_RUNNING_COMMAND_TIMEOUT=${toString cfg.timeout}

     

       25
       25
       +
             export LONG_RUNNING_COMMAND_TIMEOUT=${builtins.toString cfg.timeout}

     

       28
       26
        
             export UDM_PLAY_SOUND=${if cfg.playSound then "1" else "0"}

     

       29
       27
        
             . "${pkgs.undistract-me}/etc/profile.d/undistract-me.sh"

     

       30
       28
        
           '';

     

       31
       29
        
         };

     

       32
       30
        
       

     

       33
       31
        
         meta = {

     

       34
       34
       -
           maintainers = with maintainers; [ kira-bruneau ];

     

       32
       32
       +
           maintainers = with lib.maintainers; [ kira-bruneau ];

     

       35
       33
        
         };

     

       36
       34
        
       }

+2 -4

nixos/modules/programs/browserpass.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       {

     

       6
       4
        
       

     

       7
       7
       -
         options.programs.browserpass.enable = mkEnableOption "Browserpass native messaging host";

     

       5
       5
       +
         options.programs.browserpass.enable = lib.mkEnableOption "Browserpass native messaging host";

     

       8
       6
        
       

     

       9
       9
       -
         config = mkIf config.programs.browserpass.enable {

     

       7
       7
       +
         config = lib.mkIf config.programs.browserpass.enable {

     

       10
       8
        
           environment.etc = let

     

       11
       9
        
             appId = "com.github.browserpass.native.json";

     

       12
       10
        
             source = part: "${pkgs.browserpass}/lib/browserpass/${part}/${appId}";

+2 -4

nixos/modules/programs/calls.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.calls;

     

       7
       5
        
       in {

     

       8
       6
        
         options = {

     

       9
       7
        
           programs.calls = {

     

       10
       10
       -
             enable = mkEnableOption ''

     

       8
       8
       +
             enable = lib.mkEnableOption ''

     

       11
       9
        
               GNOME calls: a phone dialer and call handler

     

       12
       10
        
             '';

     

       13
       11
        
           };

     

       14
       12
        
         };

     

       15
       13
        
       

     

       16
       16
       -
         config = mkIf cfg.enable {

     

       14
       14
       +
         config = lib.mkIf cfg.enable {

     

       17
       15
        
           programs.dconf.enable = true;

     

       18
       16
        
       

     

       19
       17
        
           environment.systemPackages = [

+11 -13

nixos/modules/programs/cdemu.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let cfg = config.programs.cdemu;

     

       6
       4
        
       in {

     

       7
       5
        
       

     

       8
       6
        
         options = {

     

       9
       7
        
           programs.cdemu = {

     

       10
       10
       -
             enable = mkOption {

     

       11
       11
       -
               type = types.bool;

     

       8
       8
       +
             enable = lib.mkOption {

     

       9
       9
       +
               type = lib.types.bool;

     

       12
       10
        
               default = false;

     

       13
       11
        
               description = ''

     

       14
       12
        
                 {command}`cdemu` for members of

     

       15
       13
        
                 {option}`programs.cdemu.group`.

     

       16
       14
        
               '';

     

       17
       15
        
             };

     

       18
       18
       -
             group = mkOption {

     

       19
       19
       -
               type = types.str;

     

       16
       16
       +
             group = lib.mkOption {

     

       17
       17
       +
               type = lib.types.str;

     

       20
       18
        
               default = "cdrom";

     

       21
       19
        
               description = ''

     

       22
       20
        
                 Group that users must be in to use {command}`cdemu`.

     

       23
       21
        
               '';

     

       24
       22
        
             };

     

       25
       25
       -
             gui = mkOption {

     

       26
       26
       -
               type = types.bool;

     

       23
       23
       +
             gui = lib.mkOption {

     

       24
       24
       +
               type = lib.types.bool;

     

       27
       25
        
               default = true;

     

       28
       26
        
               description = ''

     

       29
       27
        
                 Whether to install the {command}`cdemu` GUI (gCDEmu).

     

       30
       28
        
               '';

     

       31
       29
        
             };

     

       32
       32
       -
             image-analyzer = mkOption {

     

       33
       33
       -
               type = types.bool;

     

       30
       30
       +
             image-analyzer = lib.mkOption {

     

       31
       31
       +
               type = lib.types.bool;

     

       34
       32
        
               default = true;

     

       35
       33
        
               description = ''

     

       36
       34
        
                 Whether to install the image analyzer.

     
···

       39
       37
        
           };

     

       40
       38
        
         };

     

       41
       39
        
       

     

       42
       42
       -
         config = mkIf cfg.enable {

     

       40
       40
       +
         config = lib.mkIf cfg.enable {

     

       43
       41
        
       

     

       44
       42
        
           boot = {

     

       45
       43
        
             extraModulePackages = [ config.boot.kernelPackages.vhba ];

     
···

       68
       66
        
       

     

       69
       67
        
           environment.systemPackages =

     

       70
       68
        
             [ pkgs.cdemu-daemon pkgs.cdemu-client ]

     

       71
       71
       -
             ++ optional cfg.gui pkgs.gcdemu

     

       72
       72
       -
             ++ optional cfg.image-analyzer pkgs.image-analyzer;

     

       69
       69
       +
             ++ lib.optional cfg.gui pkgs.gcdemu

     

       70
       70
       +
             ++ lib.optional cfg.image-analyzer pkgs.image-analyzer;

     

       73
       71
        
         };

     

       74
       72
        
       

     

       75
       73
        
       }

+3 -5

nixos/modules/programs/cfs-zen-tweaks.nix

···

       2
       2
        
       

     

       3
       3
        
       { config, pkgs, lib, ... }:

     

       4
       4
        
       

     

       5
       5
       -
       with lib;

     

       6
       6
       -
       

     

       7
       5
        
       let

     

       8
       6
        
       

     

       9
       7
        
         cfg = config.programs.cfs-zen-tweaks;

     
···

       13
       11
        
       {

     

       14
       12
        
       

     

       15
       13
        
         meta = {

     

       16
       16
       -
           maintainers = with maintainers; [ mkg20001 ];

     

       14
       14
       +
           maintainers = with lib.maintainers; [ mkg20001 ];

     

       17
       15
        
         };

     

       18
       16
        
       

     

       19
       17
        
         options = {

     

       20
       20
       -
           programs.cfs-zen-tweaks.enable = mkEnableOption "CFS Zen Tweaks";

     

       18
       18
       +
           programs.cfs-zen-tweaks.enable = lib.mkEnableOption "CFS Zen Tweaks";

     

       21
       19
        
         };

     

       22
       20
        
       

     

       23
       23
       -
         config = mkIf cfg.enable {

     

       21
       21
       +
         config = lib.mkIf cfg.enable {

     

       24
       22
        
           systemd.packages = [ pkgs.cfs-zen-tweaks ];

     

       25
       23
        
       

     

       26
       24
        
           systemd.services.set-cfs-tweaks.wantedBy = [

+21 -23

nixos/modules/programs/chromium.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.chromium;

     

       7
       5
        
       

     

       8
       8
       -
         defaultProfile = filterAttrs (k: v: v != null) {

     

       6
       6
       +
         defaultProfile = lib.filterAttrs (k: v: v != null) {

     

       9
       7
        
           HomepageLocation = cfg.homepageLocation;

     

       10
       8
        
           DefaultSearchProviderEnabled = cfg.defaultSearchProviderEnabled;

     

       11
       9
        
           DefaultSearchProviderSearchURL = cfg.defaultSearchProviderSearchURL;

     
···

       19
       17
        
       

     

       20
       18
        
         options = {

     

       21
       19
        
           programs.chromium = {

     

       22
       22
       -
             enable = mkEnableOption "{command}`chromium` policies";

     

       20
       20
       +
             enable = lib.mkEnableOption "{command}`chromium` policies";

     

       23
       21
        
       

     

       24
       24
       -
             enablePlasmaBrowserIntegration = mkEnableOption "Native Messaging Host for Plasma Browser Integration";

     

       22
       22
       +
             enablePlasmaBrowserIntegration = lib.mkEnableOption "Native Messaging Host for Plasma Browser Integration";

     

       25
       23
        
       

     

       26
       26
       -
             plasmaBrowserIntegrationPackage = mkPackageOption pkgs [ "plasma5Packages" "plasma-browser-integration" ] { };

     

       24
       24
       +
             plasmaBrowserIntegrationPackage = lib.mkPackageOption pkgs [ "plasma5Packages" "plasma-browser-integration" ] { };

     

       27
       25
        
       

     

       28
       28
       -
             extensions = mkOption {

     

       29
       29
       -
               type = with types; nullOr (listOf str);

     

       26
       26
       +
             extensions = lib.mkOption {

     

       27
       27
       +
               type = with lib.types; nullOr (listOf str);

     

       30
       28
        
               description = ''

     

       31
       29
        
                 List of chromium extensions to install.

     

       32
       30
        
                 For list of plugins ids see id in url of extensions on

     
···

       38
       36
        
                 for additional details.

     

       39
       37
        
               '';

     

       40
       38
        
               default = null;

     

       41
       41
       -
               example = literalExpression ''

     

       39
       39
       +
               example = lib.literalExpression ''

     

       42
       40
        
                 [

     

       43
       41
        
                   "chlffgpmiacpedhhbkiomidkjlcfhogd" # pushbullet

     

       44
       42
        
                   "mbniclmhobmnbdlbpiphghaielnnpgdp" # lightshot

     
···

       48
       46
        
               '';

     

       49
       47
        
             };

     

       50
       48
        
       

     

       51
       51
       -
             homepageLocation = mkOption {

     

       52
       52
       -
               type = types.nullOr types.str;

     

       49
       49
       +
             homepageLocation = lib.mkOption {

     

       50
       50
       +
               type = lib.types.nullOr lib.types.str;

     

       53
       51
        
               description = "Chromium default homepage";

     

       54
       52
        
               default = null;

     

       55
       53
        
               example = "https://nixos.org";

     

       56
       54
        
             };

     

       57
       55
        
       

     

       58
       58
       -
             defaultSearchProviderEnabled = mkOption {

     

       59
       59
       -
               type = types.nullOr types.bool;

     

       56
       56
       +
             defaultSearchProviderEnabled = lib.mkOption {

     

       57
       57
       +
               type = lib.types.nullOr lib.types.bool;

     

       60
       58
        
               description = "Enable the default search provider.";

     

       61
       59
        
               default = null;

     

       62
       60
        
               example = true;

     

       63
       61
        
             };

     

       64
       62
        
       

     

       65
       65
       -
             defaultSearchProviderSearchURL = mkOption {

     

       66
       66
       -
               type = types.nullOr types.str;

     

       63
       63
       +
             defaultSearchProviderSearchURL = lib.mkOption {

     

       64
       64
       +
               type = lib.types.nullOr lib.types.str;

     

       67
       65
        
               description = "Chromium default search provider url.";

     

       68
       66
        
               default = null;

     

       69
       67
        
               example = "https://encrypted.google.com/search?q={searchTerms}&{google:RLZ}{google:originalQueryForSuggestion}{google:assistedQueryStats}{google:searchFieldtrialParameter}{google:searchClient}{google:sourceId}{google:instantExtendedEnabledParameter}ie={inputEncoding}";

     

       70
       68
        
             };

     

       71
       69
        
       

     

       72
       72
       -
             defaultSearchProviderSuggestURL = mkOption {

     

       73
       73
       -
               type = types.nullOr types.str;

     

       70
       70
       +
             defaultSearchProviderSuggestURL = lib.mkOption {

     

       71
       71
       +
               type = lib.types.nullOr lib.types.str;

     

       74
       72
        
               description = "Chromium default search provider url for suggestions.";

     

       75
       73
        
               default = null;

     

       76
       74
        
               example = "https://encrypted.google.com/complete/search?output=chrome&q={searchTerms}";

     

       77
       75
        
             };

     

       78
       76
        
       

     

       79
       79
       -
             extraOpts = mkOption {

     

       80
       80
       -
               type = types.attrs;

     

       77
       77
       +
             extraOpts = lib.mkOption {

     

       78
       78
       +
               type = lib.types.attrs;

     

       81
       79
        
               description = ''

     

       82
       80
        
                 Extra chromium policy options. A list of available policies

     

       83
       81
        
                 can be found in the Chrome Enterprise documentation:

     
···

       85
       83
        
                 Make sure the selected policy is supported on Linux and your browser version.

     

       86
       84
        
               '';

     

       87
       85
        
               default = {};

     

       88
       88
       -
               example = literalExpression ''

     

       86
       86
       +
               example = lib.literalExpression ''

     

       89
       87
        
                 {

     

       90
       88
        
                   "BrowserSignin" = 0;

     

       91
       89
        
                   "SyncDisabled" = true;

     
···

       99
       97
        
               '';

     

       100
       98
        
             };

     

       101
       99
        
       

     

       102
       102
       -
             initialPrefs = mkOption {

     

       103
       103
       -
               type = types.attrs;

     

       100
       100
       +
             initialPrefs = lib.mkOption {

     

       101
       101
       +
               type = lib.types.attrs;

     

       104
       102
        
               description = ''

     

       105
       103
        
                 Initial preferences are used to configure the browser for the first run.

     

       106
       104
        
                 Unlike {option}`programs.chromium.extraOpts`, initialPrefs can be changed by users in the browser settings.

     
···

       108
       106
        
                 <https://www.chromium.org/administrators/configuring-other-preferences/>

     

       109
       107
        
               '';

     

       110
       108
        
               default = {};

     

       111
       111
       -
               example = literalExpression ''

     

       109
       109
       +
               example = lib.literalExpression ''

     

       112
       110
        
                 {

     

       113
       111
        
                   "first_run_tabs" = [

     

       114
       112
        
                     "https://nixos.org/"

+2 -4

nixos/modules/programs/cnping.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.cnping;

     

       7
       5
        
       in

     

       8
       6
        
       {

     

       9
       7
        
         options = {

     

       10
       8
        
           programs.cnping = {

     

       11
       11
       -
             enable = mkEnableOption "a setcap wrapper for cnping";

     

       9
       9
       +
             enable = lib.mkEnableOption "a setcap wrapper for cnping";

     

       12
       10
        
           };

     

       13
       11
        
         };

     

       14
       12
        
       

     

       15
       15
       -
         config = mkIf cfg.enable {

     

       13
       13
       +
         config = lib.mkIf cfg.enable {

     

       16
       14
        
           security.wrappers.cnping = {

     

       17
       15
        
             source = "${pkgs.cnping}/bin/cnping";

     

       18
       16
        
             capabilities = "cap_net_raw+ep";

+5 -7

nixos/modules/programs/command-not-found/command-not-found.nix

···

       5
       5
        
       

     

       6
       6
        
       { config, lib, pkgs, ... }:

     

       7
       7
        
       

     

       8
       8
       -
       with lib;

     

       9
       9
       -
       

     

       10
       8
        
       let

     

       11
       9
        
         cfg = config.programs.command-not-found;

     

       12
       10
        
         commandNotFound = pkgs.substituteAll {

     
···

       23
       21
        
       {

     

       24
       22
        
         options.programs.command-not-found = {

     

       25
       23
        
       

     

       26
       26
       -
           enable = mkOption {

     

       27
       27
       -
             type = types.bool;

     

       24
       24
       +
           enable = lib.mkOption {

     

       25
       25
       +
             type = lib.types.bool;

     

       28
       26
        
             default = true;

     

       29
       27
        
             description = ''

     

       30
       28
        
               Whether interactive shells should show which Nix package (if

     
···

       32
       30
        
             '';

     

       33
       31
        
           };

     

       34
       32
        
       

     

       35
       35
       -
           dbPath = mkOption {

     

       33
       33
       +
           dbPath = lib.mkOption {

     

       36
       34
        
             default = "/nix/var/nix/profiles/per-user/root/channels/nixos/programs.sqlite" ;

     

       37
       35
        
             description = ''

     

       38
       36
        
               Absolute path to programs.sqlite.

     
···

       40
       38
        
               By default this file will be provided by your channel

     

       41
       39
        
               (nixexprs.tar.xz).

     

       42
       40
        
             '';

     

       43
       43
       -
             type = types.path;

     

       41
       41
       +
             type = lib.types.path;

     

       44
       42
        
           };

     

       45
       43
        
         };

     

       46
       44
        
       

     

       47
       47
       -
         config = mkIf cfg.enable {

     

       45
       45
       +
         config = lib.mkIf cfg.enable {

     

       48
       46
        
           programs.bash.interactiveShellInit =

     

       49
       47
        
             ''

     

       50
       48
        
               # This function is called whenever a command is not found.

+3 -5

nixos/modules/programs/criu.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let cfg = config.programs.criu;

     

       6
       4
        
       in {

     

       7
       5
        
       

     

       8
       6
        
         options = {

     

       9
       7
        
           programs.criu = {

     

       10
       10
       -
             enable = mkOption {

     

       11
       11
       -
               type = types.bool;

     

       8
       8
       +
             enable = lib.mkOption {

     

       9
       9
       +
               type = lib.types.bool;

     

       12
       10
        
               default = false;

     

       13
       11
        
               description = ''

     

       14
       12
        
                 Install {command}`criu` along with necessary kernel options.

     
···

       16
       14
        
             };

     

       17
       15
        
           };

     

       18
       16
        
         };

     

       19
       19
       -
         config = mkIf cfg.enable {

     

       17
       17
       +
         config = lib.mkIf cfg.enable {

     

       20
       18
        
           system.requiredKernelConfig = with config.lib.kernelConfig; [

     

       21
       19
        
             (isYes "CHECKPOINT_RESTORE")

     

       22
       20
        
           ];

+4 -6

nixos/modules/programs/digitalbitbox/default.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.digitalbitbox;

     

       7
       5
        
       in

     

       8
       6
        
       

     

       9
       7
        
       {

     

       10
       8
        
         options.programs.digitalbitbox = {

     

       11
       11
       -
           enable = mkOption {

     

       12
       12
       -
             type = types.bool;

     

       9
       9
       +
           enable = lib.mkOption {

     

       10
       10
       +
             type = lib.types.bool;

     

       13
       11
        
             default = false;

     

       14
       12
        
             description = ''

     

       15
       13
        
               Installs the Digital Bitbox application and enables the complementary hardware module.

     

       16
       14
        
             '';

     

       17
       15
        
           };

     

       18
       16
        
       

     

       19
       19
       -
           package = mkPackageOption pkgs "digitalbitbox" {

     

       17
       17
       +
           package = lib.mkPackageOption pkgs "digitalbitbox" {

     

       20
       18
        
             extraDescription = ''

     

       21
       19
        
               This can be used to install a package with udev rules that differ from the defaults.

     

       22
       20
        
             '';

     

       23
       21
        
           };

     

       24
       22
        
         };

     

       25
       23
        
       

     

       26
       26
       -
         config = mkIf cfg.enable {

     

       24
       24
       +
         config = lib.mkIf cfg.enable {

     

       27
       25
        
           environment.systemPackages = [ cfg.package ];

     

       28
       26
        
           hardware.digitalbitbox = {

     

       29
       27
        
             enable = true;

+5 -7

nixos/modules/programs/dmrconfig.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.dmrconfig;

     

       7
       5
        
       

     

       8
       6
        
       in {

     

       9
       9
       -
         meta.maintainers = with maintainers; [ ];

     

       7
       7
       +
         meta.maintainers = with lib.maintainers; [ ];

     

       10
       8
        
       

     

       11
       9
        
         ###### interface

     

       12
       10
        
         options = {

     

       13
       11
        
           programs.dmrconfig = {

     

       14
       14
       -
             enable = mkOption {

     

       12
       12
       +
             enable = lib.mkOption {

     

       15
       13
        
               default = false;

     

       16
       16
       -
               type = types.bool;

     

       14
       14
       +
               type = lib.types.bool;

     

       17
       15
        
               description = ''

     

       18
       16
        
                 Whether to configure system to enable use of dmrconfig. This

     

       19
       17
        
                 enables the required udev rules and installs the program.

     
···

       21
       19
        
               relatedPackages = [ "dmrconfig" ];

     

       22
       20
        
             };

     

       23
       21
        
       

     

       24
       24
       -
             package = mkPackageOption pkgs "dmrconfig" { };

     

       22
       22
       +
             package = lib.mkPackageOption pkgs "dmrconfig" { };

     

       25
       23
        
           };

     

       26
       24
        
         };

     

       27
       25
        
       

     

       28
       26
        
         ###### implementation

     

       29
       29
       -
         config = mkIf cfg.enable {

     

       27
       27
       +
         config = lib.mkIf cfg.enable {

     

       30
       28
        
           environment.systemPackages = [ cfg.package ];

     

       31
       29
        
           services.udev.packages = [ cfg.package ];

     

       32
       30
        
         };

+1 -3

nixos/modules/programs/droidcam.nix

···

       1
       1
        
       { lib, pkgs, config, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       {

     

       6
       4
        
         options.programs.droidcam = {

     

       7
       7
       -
           enable = mkEnableOption "DroidCam client";

     

       5
       5
       +
           enable = lib.mkEnableOption "DroidCam client";

     

       8
       6
        
         };

     

       9
       7
        
       

     

       10
       8
        
         config = lib.mkIf config.programs.droidcam.enable {

+4 -6

nixos/modules/programs/dublin-traceroute.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.dublin-traceroute;

     

       7
       5
        
       

     
···

       10
       8
        
       

     

       11
       9
        
         options = {

     

       12
       10
        
           programs.dublin-traceroute = {

     

       13
       13
       -
             enable = mkEnableOption ''

     

       11
       11
       +
             enable = lib.mkEnableOption ''

     

       14
       12
        
             dublin-traceroute, add it to the global environment and configure a setcap wrapper for it.

     

       15
       13
        
             '';

     

       16
       14
        
       

     

       17
       17
       -
             package = mkPackageOption pkgs "dublin-traceroute" { };

     

       15
       15
       +
             package = lib.mkPackageOption pkgs "dublin-traceroute" { };

     

       18
       16
        
           };

     

       19
       17
        
         };

     

       20
       18
        
       

     

       21
       21
       -
         config = mkIf cfg.enable {

     

       19
       19
       +
         config = lib.mkIf cfg.enable {

     

       22
       20
        
           environment.systemPackages = [ cfg.package ];

     

       23
       21
        
       

     

       24
       22
        
           security.wrappers.dublin-traceroute = {

     

       25
       23
        
             owner = "root";

     

       26
       24
        
             group = "root";

     

       27
       25
        
             capabilities = "cap_net_raw+p";

     

       28
       28
       -
             source = getExe cfg.package;

     

       26
       26
       +
             source = lib.getExe cfg.package;

     

       29
       27
        
           };

     

       30
       28
        
         };

     

       31
       29
        
       }

+2 -4

nixos/modules/programs/ecryptfs.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.ecryptfs;

     

       7
       5
        
       

     

       8
       6
        
       in {

     

       9
       7
        
         options.programs.ecryptfs = {

     

       10
       10
       -
           enable = mkEnableOption "ecryptfs setuid mount wrappers";

     

       8
       8
       +
           enable = lib.mkEnableOption "ecryptfs setuid mount wrappers";

     

       11
       9
        
         };

     

       12
       10
        
       

     

       13
       13
       -
         config = mkIf cfg.enable {

     

       11
       11
       +
         config = lib.mkIf cfg.enable {

     

       14
       12
        
           security.wrappers = {

     

       15
       13
        
       

     

       16
       14
        
             "mount.ecryptfs_private" = {

+4 -6

nixos/modules/programs/environment.nix

···

       4
       4
        
       

     

       5
       5
        
       { config, lib, ... }:

     

       6
       6
        
       

     

       7
       7
       -
       with lib;

     

       8
       8
       -
       

     

       9
       7
        
       let

     

       10
       8
        
       

     

       11
       9
        
         cfg = config.environment;

     
···

       20
       18
        
             { NIXPKGS_CONFIG = "/etc/nix/nixpkgs-config.nix";

     

       21
       19
        
               # note: many programs exec() this directly, so default options for less must not

     

       22
       20
        
               # be specified here; do so in the default value of programs.less.envVariables instead

     

       23
       23
       -
               PAGER = mkDefault "less";

     

       24
       24
       -
               EDITOR = mkDefault "nano";

     

       21
       21
       +
               PAGER = lib.mkDefault "less";

     

       22
       22
       +
               EDITOR = lib.mkDefault "nano";

     

       25
       23
        
             };

     

       26
       24
        
       

     

       27
       25
        
           # since we set PAGER to this above, make sure it's installed

     

       28
       26
        
           programs.less.enable = true;

     

       29
       27
        
       

     

       30
       30
       -
           environment.profiles = mkAfter

     

       28
       28
       +
           environment.profiles = lib.mkAfter

     

       31
       29
        
             [ "/nix/var/nix/profiles/default"

     

       32
       30
        
               "/run/current-system/sw"

     

       33
       31
        
             ];

     
···

       53
       51
        
           environment.extraInit =

     

       54
       52
        
             ''

     

       55
       53
        
                export NIX_USER_PROFILE_DIR="/nix/var/nix/profiles/per-user/$USER"

     

       56
       56
       -
                export NIX_PROFILES="${concatStringsSep " " (reverseList cfg.profiles)}"

     

       54
       54
       +
                export NIX_PROFILES="${builtins.concatStringsSep " " (lib.reverseList cfg.profiles)}"

     

       57
       55
        
             '';

     

       58
       56
        
       

     

       59
       57
        
         };

+2 -3

nixos/modules/programs/extra-container.nix

···

       1
       1
        
       { config, pkgs, lib, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       3
        
       let

     

       5
       4
        
         cfg = config.programs.extra-container;

     

       6
       5
        
       in {

     

       7
       6
        
         options = {

     

       8
       8
       -
           programs.extra-container.enable = mkEnableOption ''

     

       7
       7
       +
           programs.extra-container.enable = lib.mkEnableOption ''

     

       9
       8
        
             extra-container, a tool for running declarative NixOS containers

     

       10
       9
        
             without host system rebuilds

     

       11
       10
        
           '';

     

       12
       11
        
         };

     

       13
       13
       -
         config = mkIf cfg.enable {

     

       12
       12
       +
         config = lib.mkIf cfg.enable {

     

       14
       13
        
           environment.systemPackages = [ pkgs.extra-container ];

     

       15
       14
        
           boot.extraSystemdUnitPaths = [ "/etc/systemd-mutable/system" ];

     

       16
       15
        
         };

+3 -5

nixos/modules/programs/feedbackd.nix

···

       1
       1
        
       { pkgs, lib, config, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.feedbackd;

     

       7
       5
        
       in {

     

       8
       6
        
         options = {

     

       9
       7
        
           programs.feedbackd = {

     

       10
       10
       -
             enable = mkEnableOption ''

     

       8
       8
       +
             enable = lib.mkEnableOption ''

     

       11
       9
        
               the feedbackd D-BUS service and udev rules.

     

       12
       10
        
       

     

       13
       11
        
               Your user needs to be in the `feedbackd` group to trigger effects

     

       14
       12
        
             '';

     

       15
       15
       -
             package = mkPackageOption pkgs "feedbackd" { };

     

       13
       13
       +
             package = lib.mkPackageOption pkgs "feedbackd" { };

     

       16
       14
        
           };

     

       17
       15
        
         };

     

       18
       18
       -
         config = mkIf cfg.enable {

     

       16
       16
       +
         config = lib.mkIf cfg.enable {

     

       19
       17
        
           environment.systemPackages = [ cfg.package ];

     

       20
       18
        
       

     

       21
       19
        
           services.dbus.packages = [ cfg.package ];

+25 -27

nixos/modules/programs/firefox.nix

···

       1
       1
        
       { pkgs, config, lib, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.firefox;

     

       7
       5
        
       

     
···

       62
       60
        
       in

     

       63
       61
        
       {

     

       64
       62
        
         options.programs.firefox = {

     

       65
       65
       -
           enable = mkEnableOption "the Firefox web browser";

     

       63
       63
       +
           enable = lib.mkEnableOption "the Firefox web browser";

     

       66
       64
        
       

     

       67
       67
       -
           package = mkOption {

     

       68
       68
       -
             type = types.package;

     

       65
       65
       +
           package = lib.mkOption {

     

       66
       66
       +
             type = lib.types.package;

     

       69
       67
        
             default = pkgs.firefox;

     

       70
       68
        
             description = "Firefox package to use.";

     

       71
       71
       -
             defaultText = literalExpression "pkgs.firefox";

     

       69
       69
       +
             defaultText = lib.literalExpression "pkgs.firefox";

     

       72
       70
        
             relatedPackages = [

     

       73
       71
        
               "firefox"

     

       74
       72
        
               "firefox-beta-bin"

     
···

       78
       76
        
             ];

     

       79
       77
        
           };

     

       80
       78
        
       

     

       81
       81
       -
           wrapperConfig = mkOption {

     

       82
       82
       -
             type = types.attrs;

     

       79
       79
       +
           wrapperConfig = lib.mkOption {

     

       80
       80
       +
             type = lib.types.attrs;

     

       83
       81
        
             default = {};

     

       84
       82
        
             description = "Arguments to pass to Firefox wrapper";

     

       85
       83
        
           };

     

       86
       84
        
       

     

       87
       87
       -
           policies = mkOption {

     

       85
       85
       +
           policies = lib.mkOption {

     

       88
       86
        
             type = policyFormat.type;

     

       89
       87
        
             default = { };

     

       90
       88
        
             description = ''

     
···

       100
       98
        
             '';

     

       101
       99
        
           };

     

       102
       100
        
       

     

       103
       103
       -
           preferences = mkOption {

     

       104
       104
       -
             type = with types; attrsOf (oneOf [ bool int str ]);

     

       101
       101
       +
           preferences = lib.mkOption {

     

       102
       102
       +
             type = with lib.types; attrsOf (oneOf [ bool int str ]);

     

       105
       103
        
             default = { };

     

       106
       104
        
             description = ''

     

       107
       105
        
               Preferences to set from `about:config`.

     
···

       113
       111
        
             '';

     

       114
       112
        
           };

     

       115
       113
        
       

     

       116
       116
       -
           preferencesStatus = mkOption {

     

       117
       117
       -
             type = types.enum [ "default" "locked" "user" "clear" ];

     

       114
       114
       +
           preferencesStatus = lib.mkOption {

     

       115
       115
       +
             type = lib.types.enum [ "default" "locked" "user" "clear" ];

     

       118
       116
        
             default = "locked";

     

       119
       117
        
             description = ''

     

       120
       118
        
               The status of `firefox.preferences`.

     
···

       127
       125
        
             '';

     

       128
       126
        
           };

     

       129
       127
        
       

     

       130
       130
       -
           languagePacks = mkOption {

     

       128
       128
       +
           languagePacks = lib.mkOption {

     

       131
       129
        
             # Available languages can be found in https://releases.mozilla.org/pub/firefox/releases/${cfg.package.version}/linux-x86_64/xpi/

     

       132
       132
       -
             type = types.listOf (types.enum ([

     

       130
       130
       +
             type = lib.types.listOf (lib.types.enum ([

     

       133
       131
        
               "ach"

     

       134
       132
        
               "af"

     

       135
       133
        
               "an"

     
···

       235
       233
        
             '';

     

       236
       234
        
           };

     

       237
       235
        
       

     

       238
       238
       -
           autoConfig = mkOption {

     

       239
       239
       -
             type = types.lines;

     

       236
       236
       +
           autoConfig = lib.mkOption {

     

       237
       237
       +
             type = lib.types.lines;

     

       240
       238
        
             default = "";

     

       241
       239
        
             description = ''

     

       242
       240
        
               AutoConfig files can be used to set and lock preferences that are not covered

     
···

       247
       245
        
           };

     

       248
       246
        
       

     

       249
       247
        
           nativeMessagingHosts = ({

     

       250
       250
       -
             packages = mkOption {

     

       251
       251
       -
               type = types.listOf types.package;

     

       248
       248
       +
             packages = lib.mkOption {

     

       249
       249
       +
               type = lib.types.listOf lib.types.package;

     

       252
       250
        
               default = [];

     

       253
       251
        
               description = ''

     

       254
       252
        
                 Additional packages containing native messaging hosts that should be made available to Firefox extensions.

     

       255
       253
        
               '';

     

       256
       254
        
             };

     

       257
       257
       -
           }) // (mapAttrs (k: v: mkEnableOption "${v.name} support") nmhOptions);

     

       255
       255
       +
           }) // (builtins.mapAttrs (k: v: lib.mkEnableOption "${v.name} support") nmhOptions);

     

       258
       256
        
         };

     

       259
       257
        
       

     

       260
       258
        
         config = let

     

       261
       261
       -
           forEachEnabledNmh = fn: flatten (mapAttrsToList (k: v: lib.optional cfg.nativeMessagingHosts.${k} (fn k v)) nmhOptions);

     

       262
       262
       -
         in mkIf cfg.enable {

     

       259
       259
       +
           forEachEnabledNmh = fn: lib.flatten (lib.mapAttrsToList (k: v: lib.optional cfg.nativeMessagingHosts.${k} (fn k v)) nmhOptions);

     

       260
       260
       +
         in lib.mkIf cfg.enable {

     

       263
       261
        
           warnings = forEachEnabledNmh (k: v:

     

       264
       262
        
             "The `programs.firefox.nativeMessagingHosts.${k}` option is deprecated, " +

     

       265
       263
        
             "please add `${v.package.pname}` to `programs.firefox.nativeMessagingHosts.packages` instead."

     
···

       278
       276
        
             let

     

       279
       277
        
               policiesJSON = policyFormat.generate "firefox-policies.json" { inherit (cfg) policies; };

     

       280
       278
        
             in

     

       281
       281
       -
             mkIf (cfg.policies != { }) {

     

       279
       279
       +
             lib.mkIf (cfg.policies != { }) {

     

       282
       280
        
               "firefox/policies/policies.json".source = "${policiesJSON}";

     

       283
       281
        
             };

     

       284
       282
        
       

     

       285
       283
        
           # Preferences are converted into a policy

     

       286
       284
        
           programs.firefox.policies = {

     

       287
       285
        
             DisableAppUpdate = true;

     

       288
       288
       -
             Preferences = (mapAttrs

     

       286
       286
       +
             Preferences = (builtins.mapAttrs

     

       289
       287
        
               (_: value: { Value = value; Status = cfg.preferencesStatus; })

     

       290
       288
        
               cfg.preferences);

     

       291
       291
       -
             ExtensionSettings = listToAttrs (map

     

       292
       292
       -
               (lang: nameValuePair

     

       289
       289
       +
             ExtensionSettings = builtins.listToAttrs (builtins.map

     

       290
       290
       +
               (lang: builtins.nameValuePair

     

       293
       291
        
                 "langpack-${lang}@firefox.mozilla.org"

     

       294
       292
        
                 {

     

       295
       293
        
                   installation_mode = "normal_installed";

     
···

       300
       298
        
           };

     

       301
       299
        
         };

     

       302
       300
        
       

     

       303
       303
       -
         meta.maintainers = with maintainers; [ danth ];

     

       301
       301
       +
         meta.maintainers = with lib.maintainers; [ danth ];

     

       304
       302
        
       }

+19 -21

nixos/modules/programs/firejail.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.firejail;

     

       7
       5
        
       

     
···

       21
       19
        
               else { executable = value; desktop = null; profile = null; extraArgs = []; };

     

       22
       20
        
               args = lib.escapeShellArgs (

     

       23
       21
        
                 opts.extraArgs

     

       24
       24
       -
                 ++ (optional (opts.profile != null) "--profile=${toString opts.profile}")

     

       22
       22
       +
                 ++ (lib.optional (opts.profile != null) "--profile=${builtins.toString opts.profile}")

     

       25
       23
        
               );

     

       26
       24
        
             in

     

       27
       25
        
             ''

     

       28
       26
        
               cat <<_EOF >$out/bin/${command}

     

       29
       27
        
               #! ${pkgs.runtimeShell} -e

     

       30
       30
       -
               exec /run/wrappers/bin/firejail ${args} -- ${toString opts.executable} "\$@"

     

       28
       28
       +
               exec /run/wrappers/bin/firejail ${args} -- ${builtins.toString opts.executable} "\$@"

     

       31
       29
        
               _EOF

     

       32
       30
        
               chmod 0755 $out/bin/${command}

     

       33
       31
        
       

     
···

       40
       38
        
       

     

       41
       39
        
       in {

     

       42
       40
        
         options.programs.firejail = {

     

       43
       43
       -
           enable = mkEnableOption "firejail, a sandboxing tool for Linux";

     

       41
       41
       +
           enable = lib.mkEnableOption "firejail, a sandboxing tool for Linux";

     

       44
       42
        
       

     

       45
       45
       -
           wrappedBinaries = mkOption {

     

       46
       46
       -
             type = types.attrsOf (types.either types.path (types.submodule {

     

       43
       43
       +
           wrappedBinaries = lib.mkOption {

     

       44
       44
       +
             type = lib.types.attrsOf (lib.types.either lib.types.path (lib.types.submodule {

     

       47
       45
        
               options = {

     

       48
       48
       -
                 executable = mkOption {

     

       49
       49
       -
                   type = types.path;

     

       46
       46
       +
                 executable = lib.mkOption {

     

       47
       47
       +
                   type = lib.types.path;

     

       50
       48
        
                   description = "Executable to run sandboxed";

     

       51
       51
       -
                   example = literalExpression ''"''${lib.getBin pkgs.firefox}/bin/firefox"'';

     

       49
       49
       +
                   example = lib.literalExpression ''"''${lib.getBin pkgs.firefox}/bin/firefox"'';

     

       52
       50
        
                 };

     

       53
       53
       -
                 desktop = mkOption {

     

       54
       54
       -
                   type = types.nullOr types.path;

     

       51
       51
       +
                 desktop = lib.mkOption {

     

       52
       52
       +
                   type = lib.types.nullOr lib.types.path;

     

       55
       53
        
                   default = null;

     

       56
       54
        
                   description = ".desktop file to modify. Only necessary if it uses the absolute path to the executable.";

     

       57
       57
       -
                   example = literalExpression ''"''${pkgs.firefox}/share/applications/firefox.desktop"'';

     

       55
       55
       +
                   example = lib.literalExpression ''"''${pkgs.firefox}/share/applications/firefox.desktop"'';

     

       58
       56
        
                 };

     

       59
       59
       -
                 profile = mkOption {

     

       60
       60
       -
                   type = types.nullOr types.path;

     

       57
       57
       +
                 profile = lib.mkOption {

     

       58
       58
       +
                   type = lib.types.nullOr lib.types.path;

     

       61
       59
        
                   default = null;

     

       62
       60
        
                   description = "Profile to use";

     

       63
       63
       -
                   example = literalExpression ''"''${pkgs.firejail}/etc/firejail/firefox.profile"'';

     

       61
       61
       +
                   example = lib.literalExpression ''"''${pkgs.firejail}/etc/firejail/firefox.profile"'';

     

       64
       62
        
                 };

     

       65
       65
       -
                 extraArgs = mkOption {

     

       66
       66
       -
                   type = types.listOf types.str;

     

       63
       63
       +
                 extraArgs = lib.mkOption {

     

       64
       64
       +
                   type = lib.types.listOf lib.types.str;

     

       67
       65
        
                   default = [];

     

       68
       66
        
                   description = "Extra arguments to pass to firejail";

     

       69
       67
        
                   example = [ "--private=~/.firejail_home" ];

     
···

       71
       69
        
               };

     

       72
       70
        
             }));

     

       73
       71
        
             default = {};

     

       74
       74
       -
             example = literalExpression ''

     

       72
       72
       +
             example = lib.literalExpression ''

     

       75
       73
        
               {

     

       76
       74
        
                 firefox = {

     

       77
       75
        
                   executable = "''${lib.getBin pkgs.firefox}/bin/firefox";

     
···

       89
       87
        
           };

     

       90
       88
        
         };

     

       91
       89
        
       

     

       92
       92
       -
         config = mkIf cfg.enable {

     

       90
       90
       +
         config = lib.mkIf cfg.enable {

     

       93
       91
        
           security.wrappers.firejail =

     

       94
       92
        
             { setuid = true;

     

       95
       93
        
               owner = "root";

     
···

       100
       98
        
           environment.systemPackages = [ pkgs.firejail ] ++ [ wrappedBins ];

     

       101
       99
        
         };

     

       102
       100
        
       

     

       103
       103
       -
         meta.maintainers = with maintainers; [ peterhoeg ];

     

       101
       101
       +
         meta.maintainers = with lib.maintainers; [ peterhoeg ];

     

       104
       102
        
       }

+38 -40

nixos/modules/programs/fish.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
       

     

       7
       5
        
         cfge = config.environment;

     

       8
       6
        
       

     

       9
       7
        
         cfg = config.programs.fish;

     

       10
       8
        
       

     

       11
       11
       -
         fishAbbrs = concatStringsSep "\n" (

     

       12
       12
       -
           mapAttrsFlatten (k: v: "abbr -ag ${k} ${escapeShellArg v}")

     

       9
       9
       +
         fishAbbrs = builtins.concatStringsSep "\n" (

     

       10
       10
       +
           lib.mapAttrsFlatten (k: v: "abbr -ag ${k} ${builtins.escapeShellArg v}")

     

       13
       11
        
             cfg.shellAbbrs

     

       14
       12
        
         );

     

       15
       13
        
       

     

       16
       16
       -
         fishAliases = concatStringsSep "\n" (

     

       17
       17
       -
           mapAttrsFlatten (k: v: "alias ${k} ${escapeShellArg v}")

     

       18
       18
       -
             (filterAttrs (k: v: v != null) cfg.shellAliases)

     

       14
       14
       +
         fishAliases = builtins.concatStringsSep "\n" (

     

       15
       15
       +
           builtins.mapAttrsFlatten (k: v: "alias ${k} ${builtins.escapeShellArg v}")

     

       16
       16
       +
             (builtins.filterAttrs (k: v: v != null) cfg.shellAliases)

     

       19
       17
        
         );

     

       20
       18
        
       

     

       21
       19
        
         envShellInit = pkgs.writeText "shellInit" cfge.shellInit;

     
···

       47
       45
        
       

     

       48
       46
        
           programs.fish = {

     

       49
       47
        
       

     

       50
       50
       -
             enable = mkOption {

     

       48
       48
       +
             enable = lib.mkOption {

     

       51
       49
        
               default = false;

     

       52
       50
        
               description = ''

     

       53
       51
        
                 Whether to configure fish as an interactive shell.

     

       54
       52
        
               '';

     

       55
       55
       -
               type = types.bool;

     

       53
       53
       +
               type = lib.types.bool;

     

       56
       54
        
             };

     

       57
       55
        
       

     

       58
       58
       -
             package = mkPackageOption pkgs "fish" { };

     

       56
       56
       +
             package = lib.mkPackageOption pkgs "fish" { };

     

       59
       57
        
       

     

       60
       60
       -
             useBabelfish = mkOption {

     

       61
       61
       -
               type = types.bool;

     

       58
       58
       +
             useBabelfish = lib.mkOption {

     

       59
       59
       +
               type = lib.types.bool;

     

       62
       60
        
               default = false;

     

       63
       61
        
               description = ''

     

       64
       62
        
                 If enabled, the configured environment will be translated to native fish using [babelfish](https://github.com/bouk/babelfish).

     
···

       66
       64
        
               '';

     

       67
       65
        
             };

     

       68
       66
        
       

     

       69
       69
       -
             vendor.config.enable = mkOption {

     

       70
       70
       -
               type = types.bool;

     

       67
       67
       +
             vendor.config.enable = lib.mkOption {

     

       68
       68
       +
               type = lib.types.bool;

     

       71
       69
        
               default = true;

     

       72
       70
        
               description = ''

     

       73
       71
        
                 Whether fish should source configuration snippets provided by other packages.

     

       74
       72
        
               '';

     

       75
       73
        
             };

     

       76
       74
        
       

     

       77
       77
       -
             vendor.completions.enable = mkOption {

     

       78
       78
       -
               type = types.bool;

     

       75
       75
       +
             vendor.completions.enable = lib.mkOption {

     

       76
       76
       +
               type = lib.types.bool;

     

       79
       77
        
               default = true;

     

       80
       78
        
               description = ''

     

       81
       79
        
                 Whether fish should use completion files provided by other packages.

     

       82
       80
        
               '';

     

       83
       81
        
             };

     

       84
       82
        
       

     

       85
       85
       -
             vendor.functions.enable = mkOption {

     

       86
       86
       -
               type = types.bool;

     

       83
       83
       +
             vendor.functions.enable = lib.mkOption {

     

       84
       84
       +
               type = lib.types.bool;

     

       87
       85
        
               default = true;

     

       88
       86
        
               description = ''

     

       89
       87
        
                 Whether fish should autoload fish functions provided by other packages.

     

       90
       88
        
               '';

     

       91
       89
        
             };

     

       92
       90
        
       

     

       93
       93
       -
             shellAbbrs = mkOption {

     

       91
       91
       +
             shellAbbrs = lib.mkOption {

     

       94
       92
        
               default = {};

     

       95
       93
        
               example = {

     

       96
       94
        
                 gco = "git checkout";

     
···

       99
       97
        
               description = ''

     

       100
       98
        
                 Set of fish abbreviations.

     

       101
       99
        
               '';

     

       102
       102
       -
               type = with types; attrsOf str;

     

       100
       100
       +
               type = with lib.types; attrsOf str;

     

       103
       101
        
             };

     

       104
       102
        
       

     

       105
       105
       -
             shellAliases = mkOption {

     

       103
       103
       +
             shellAliases = lib.mkOption {

     

       106
       104
        
               default = {};

     

       107
       105
        
               description = ''

     

       108
       106
        
                 Set of aliases for fish shell, which overrides {option}`environment.shellAliases`.

     

       109
       107
        
                 See {option}`environment.shellAliases` for an option format description.

     

       110
       108
        
               '';

     

       111
       111
       -
               type = with types; attrsOf (nullOr (either str path));

     

       109
       109
       +
               type = with lib.types; attrsOf (nullOr (either str path));

     

       112
       110
        
             };

     

       113
       111
        
       

     

       114
       114
       -
             shellInit = mkOption {

     

       112
       112
       +
             shellInit = lib.mkOption {

     

       115
       113
        
               default = "";

     

       116
       114
        
               description = ''

     

       117
       115
        
                 Shell script code called during fish shell initialisation.

     

       118
       116
        
               '';

     

       119
       119
       -
               type = types.lines;

     

       117
       117
       +
               type = lib.types.lines;

     

       120
       118
        
             };

     

       121
       119
        
       

     

       122
       122
       -
             loginShellInit = mkOption {

     

       120
       120
       +
             loginShellInit = lib.mkOption {

     

       123
       121
        
               default = "";

     

       124
       122
        
               description = ''

     

       125
       123
        
                 Shell script code called during fish login shell initialisation.

     

       126
       124
        
               '';

     

       127
       127
       -
               type = types.lines;

     

       125
       125
       +
               type = lib.types.lines;

     

       128
       126
        
             };

     

       129
       127
        
       

     

       130
       130
       -
             interactiveShellInit = mkOption {

     

       128
       128
       +
             interactiveShellInit = lib.mkOption {

     

       131
       129
        
               default = "";

     

       132
       130
        
               description = ''

     

       133
       131
        
                 Shell script code called during interactive fish shell initialisation.

     

       134
       132
        
               '';

     

       135
       135
       -
               type = types.lines;

     

       133
       133
       +
               type = lib.types.lines;

     

       136
       134
        
             };

     

       137
       135
        
       

     

       138
       138
       -
             promptInit = mkOption {

     

       136
       136
       +
             promptInit = lib.mkOption {

     

       139
       137
        
               default = "";

     

       140
       138
        
               description = ''

     

       141
       139
        
                 Shell script code used to initialise fish prompt.

     

       142
       140
        
               '';

     

       143
       143
       -
               type = types.lines;

     

       141
       141
       +
               type = lib.types.lines;

     

       144
       142
        
             };

     

       145
       143
        
       

     

       146
       144
        
           };

     

       147
       145
        
       

     

       148
       146
        
         };

     

       149
       147
        
       

     

       150
       150
       -
         config = mkIf cfg.enable {

     

       148
       148
       +
         config = lib.mkIf cfg.enable {

     

       151
       149
        
       

     

       152
       152
       -
           programs.fish.shellAliases = mapAttrs (name: mkDefault) cfge.shellAliases;

     

       150
       150
       +
           programs.fish.shellAliases = builtins.mapAttrs (name: lib.mkDefault) cfge.shellAliases;

     

       153
       151
        
       

     

       154
       152
        
           # Required for man completions

     

       155
       153
        
           documentation.man.generateCaches = lib.mkDefault true;

     

       156
       154
        
       

     

       157
       157
       -
           environment = mkMerge [

     

       158
       158
       -
             (mkIf cfg.useBabelfish

     

       155
       155
       +
           environment = lib.mkMerge [

     

       156
       156
       +
             (lib.mkIf cfg.useBabelfish

     

       159
       157
        
             {

     

       160
       158
        
               etc."fish/setEnvironment.fish".source = babelfishTranslate config.system.build.setEnvironment "setEnvironment";

     

       161
       159
        
               etc."fish/shellInit.fish".source = babelfishTranslate envShellInit "shellInit";

     
···

       163
       161
        
               etc."fish/interactiveShellInit.fish".source = babelfishTranslate envInteractiveShellInit "interactiveShellInit";

     

       164
       162
        
            })

     

       165
       163
        
       

     

       166
       166
       -
             (mkIf (!cfg.useBabelfish)

     

       164
       164
       +
             (lib.mkIf (!cfg.useBabelfish)

     

       167
       165
        
             {

     

       168
       166
        
               etc."fish/foreign-env/shellInit".source = envShellInit;

     

       169
       167
        
               etc."fish/foreign-env/loginShellInit".source = envLoginShellInit;

     
···

       266
       264
        
                       pathName = substring storeLength (stringLength package - storeLength) package;

     

       267
       265
        
                     in (package.name or pathName) + "_fish-completions")

     

       268
       266
        
                   ( { inherit package; } //

     

       269
       269
       -
                     optionalAttrs (package ? meta.priority) { meta.priority = package.meta.priority; })

     

       267
       267
       +
                     lib.optionalAttrs (package ? meta.priority) { meta.priority = package.meta.priority; })

     

       270
       268
        
                   ''

     

       271
       269
        
                     mkdir -p $out

     

       272
       270
        
                     if [ -d $package/share/man ]; then

     
···

       277
       275
        
                 pkgs.buildEnv {

     

       278
       276
        
                   name = "system_fish-completions";

     

       279
       277
        
                   ignoreCollisions = true;

     

       280
       280
       -
                   paths = map generateCompletions config.environment.systemPackages;

     

       278
       278
       +
                   paths = builtins.map generateCompletions config.environment.systemPackages;

     

       281
       279
        
                 };

     

       282
       280
        
             }

     

       283
       281
        
       

     

       284
       282
        
             # include programs that bring their own completions

     

       285
       283
        
             {

     

       286
       284
        
               pathsToLink = []

     

       287
       287
       -
               ++ optional cfg.vendor.config.enable "/share/fish/vendor_conf.d"

     

       288
       288
       -
               ++ optional cfg.vendor.completions.enable "/share/fish/vendor_completions.d"

     

       289
       289
       -
               ++ optional cfg.vendor.functions.enable "/share/fish/vendor_functions.d";

     

       285
       285
       +
               ++ lib.optional cfg.vendor.config.enable "/share/fish/vendor_conf.d"

     

       286
       286
       +
               ++ lib.optional cfg.vendor.completions.enable "/share/fish/vendor_completions.d"

     

       287
       287
       +
               ++ lib.optional cfg.vendor.functions.enable "/share/fish/vendor_functions.d";

     

       290
       288
        
             }

     

       291
       289
        
       

     

       292
       290
        
             { systemPackages = [ cfg.package ]; }

+4 -6

nixos/modules/programs/flashrom.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.flashrom;

     

       7
       5
        
       in

     

       8
       6
        
       {

     

       9
       7
        
         options.programs.flashrom = {

     

       10
       10
       -
           enable = mkOption {

     

       11
       11
       -
             type = types.bool;

     

       8
       8
       +
           enable = lib.mkOption {

     

       9
       9
       +
             type = lib.types.bool;

     

       12
       10
        
             default = false;

     

       13
       11
        
             description = ''

     

       14
       12
        
               Installs flashrom and configures udev rules for programmers

     
···

       16
       14
        
               group.

     

       17
       15
        
             '';

     

       18
       16
        
           };

     

       19
       19
       -
           package = mkPackageOption pkgs "flashrom" { };

     

       17
       17
       +
           package = lib.mkPackageOption pkgs "flashrom" { };

     

       20
       18
        
         };

     

       21
       19
        
       

     

       22
       22
       -
         config = mkIf cfg.enable {

     

       20
       20
       +
         config = lib.mkIf cfg.enable {

     

       23
       21
        
           services.udev.packages = [ cfg.package ];

     

       24
       22
        
           environment.systemPackages = [ cfg.package ];

     

       25
       23
        
         };

+3 -5

nixos/modules/programs/flexoptix-app.nix

···

       1
       1
        
       { config, pkgs, lib, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.flexoptix-app;

     

       7
       5
        
       in {

     

       8
       6
        
         options = {

     

       9
       7
        
           programs.flexoptix-app = {

     

       10
       10
       -
             enable = mkEnableOption "FLEXOPTIX app + udev rules";

     

       8
       8
       +
             enable = lib.mkEnableOption "FLEXOPTIX app + udev rules";

     

       11
       9
        
       

     

       12
       12
       -
             package = mkPackageOption pkgs "flexoptix-app" { };

     

       10
       10
       +
             package = lib.mkPackageOption pkgs "flexoptix-app" { };

     

       13
       11
        
           };

     

       14
       12
        
         };

     

       15
       13
        
       

     

       16
       16
       -
         config = mkIf cfg.enable {

     

       14
       14
       +
         config = lib.mkIf cfg.enable {

     

       17
       15
        
           environment.systemPackages = [ cfg.package ];

     

       18
       16
        
           services.udev.packages = [ cfg.package ];

     

       19
       17
        
         };

+5 -7

nixos/modules/programs/freetds.nix

···

       2
       2
        
       

     

       3
       3
        
       { config, lib, pkgs, ... }:

     

       4
       4
        
       

     

       5
       5
       -
       with lib;

     

       6
       6
       -
       

     

       7
       5
        
       let

     

       8
       6
        
       

     

       9
       7
        
         cfg = config.environment.freetds;

     
···

       14
       12
        
       

     

       15
       13
        
         options = {

     

       16
       14
        
       

     

       17
       17
       -
           environment.freetds = mkOption {

     

       18
       18
       -
             type = types.attrsOf types.str;

     

       15
       15
       +
           environment.freetds = lib.mkOption {

     

       16
       16
       +
             type = lib.types.attrsOf lib.types.str;

     

       19
       17
        
             default = {};

     

       20
       20
       -
             example = literalExpression ''

     

       18
       18
       +
             example = lib.literalExpression ''

     

       21
       19
        
               { MYDATABASE = '''

     

       22
       20
        
                   host = 10.0.2.100

     

       23
       21
        
                   port = 1433

     
···

       40
       38
        
       

     

       41
       39
        
         ###### implementation

     

       42
       40
        
       

     

       43
       43
       -
         config = mkIf (length (attrNames cfg) > 0) {

     

       41
       41
       +
         config = lib.mkIf (builtins.length (builtins.attrNames cfg) > 0) {

     

       44
       42
        
       

     

       45
       43
        
           environment.variables.FREETDSCONF = "/etc/freetds.conf";

     

       46
       44
        
           environment.variables.FREETDS = "/etc/freetds.conf";

     

       47
       45
        
           environment.variables.SYBASE = "${pkgs.freetds}";

     

       48
       46
        
       

     

       49
       47
        
           environment.etc."freetds.conf" = { text =

     

       50
       50
       -
             (concatStrings (mapAttrsToList (name: value:

     

       48
       48
       +
             (lib.concatStrings (lib.mapAttrsToList (name: value:

     

       51
       49
        
               ''

     

       52
       50
        
               [${name}]

     

       53
       51
        
               ${value}

+7 -9

nixos/modules/programs/fuse.nix

···

       1
       1
        
       { config, lib, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.fuse;

     

       7
       5
        
       in {

     

       8
       8
       -
         meta.maintainers = with maintainers; [ primeos ];

     

       6
       6
       +
         meta.maintainers = with lib.maintainers; [ primeos ];

     

       9
       7
        
       

     

       10
       8
        
         options.programs.fuse = {

     

       11
       11
       -
           mountMax = mkOption {

     

       9
       9
       +
           mountMax = lib.mkOption {

     

       12
       10
        
             # In the C code it's an "int" (i.e. signed and at least 16 bit), but

     

       13
       11
        
             # negative numbers obviously make no sense:

     

       14
       14
       -
             type = types.ints.between 0 32767; # 2^15 - 1

     

       12
       12
       +
             type = lib.types.ints.between 0 32767; # 2^15 - 1

     

       15
       13
        
             default = 1000;

     

       16
       14
        
             description = ''

     

       17
       15
        
               Set the maximum number of FUSE mounts allowed to non-root users.

     

       18
       16
        
             '';

     

       19
       17
        
           };

     

       20
       18
        
       

     

       21
       21
       -
           userAllowOther = mkOption {

     

       22
       22
       -
             type = types.bool;

     

       19
       19
       +
           userAllowOther = lib.mkOption {

     

       20
       20
       +
             type = lib.types.bool;

     

       23
       21
        
             default = false;

     

       24
       22
        
             description = ''

     

       25
       23
        
               Allow non-root users to specify the allow_other or allow_root mount

     
···

       30
       28
        
       

     

       31
       29
        
         config =  {

     

       32
       30
        
           environment.etc."fuse.conf".text = ''

     

       33
       33
       -
             ${optionalString (!cfg.userAllowOther) "#"}user_allow_other

     

       34
       34
       -
             mount_max = ${toString cfg.mountMax}

     

       31
       31
       +
             ${lib.optionalString (!cfg.userAllowOther) "#"}user_allow_other

     

       32
       32
       +
             mount_max = ${builtins.toString cfg.mountMax}

     

       35
       33
        
           '';

     

       36
       34
        
         };

     

       37
       35
        
       }

+9 -11

nixos/modules/programs/gamemode.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.gamemode;

     

       7
       5
        
         settingsFormat = pkgs.formats.ini { };

     
···

       10
       8
        
       {

     

       11
       9
        
         options = {

     

       12
       10
        
           programs.gamemode = {

     

       13
       13
       -
             enable = mkEnableOption "GameMode to optimise system performance on demand";

     

       11
       11
       +
             enable = lib.mkEnableOption "GameMode to optimise system performance on demand";

     

       14
       12
        
       

     

       15
       15
       -
             enableRenice = mkEnableOption "CAP_SYS_NICE on gamemoded to support lowering process niceness" // {

     

       13
       13
       +
             enableRenice = lib.mkEnableOption "CAP_SYS_NICE on gamemoded to support lowering process niceness" // {

     

       16
       14
        
               default = true;

     

       17
       15
        
             };

     

       18
       16
        
       

     

       19
       19
       -
             settings = mkOption {

     

       17
       17
       +
             settings = lib.mkOption {

     

       20
       18
        
               type = settingsFormat.type;

     

       21
       19
        
               default = { };

     

       22
       20
        
               description = ''

     

       23
       21
        
                 System-wide configuration for GameMode (/etc/gamemode.ini).

     

       24
       22
        
                 See gamemoded(8) man page for available settings.

     

       25
       23
        
               '';

     

       26
       26
       -
               example = literalExpression ''

     

       24
       24
       +
               example = lib.literalExpression ''

     

       27
       25
        
                 {

     

       28
       26
        
                   general = {

     

       29
       27
        
                     renice = 10;

     
···

       46
       44
        
           };

     

       47
       45
        
         };

     

       48
       46
        
       

     

       49
       49
       -
         config = mkIf cfg.enable {

     

       47
       47
       +
         config = lib.mkIf cfg.enable {

     

       50
       48
        
           environment = {

     

       51
       49
        
             systemPackages = [ pkgs.gamemode ];

     

       52
       50
        
             etc."gamemode.ini".source = configFile;

     
···

       54
       52
        
       

     

       55
       53
        
           security = {

     

       56
       54
        
             polkit.enable = true;

     

       57
       57
       -
             wrappers = mkIf cfg.enableRenice {

     

       55
       55
       +
             wrappers = lib.mkIf cfg.enableRenice {

     

       58
       56
        
               gamemoded = {

     

       59
       57
        
                 owner = "root";

     

       60
       58
        
                 group = "root";

     
···

       77
       75
        
               #

     

       78
       76
        
               # This uses a link farm to make sure other wrapped executables

     

       79
       77
        
               # aren't included in PATH.

     

       80
       80
       -
               environment.PATH = mkForce (pkgs.linkFarm "pkexec" [

     

       78
       78
       +
               environment.PATH = lib.mkForce (pkgs.linkFarm "pkexec" [

     

       81
       79
        
                 {

     

       82
       80
        
                   name = "pkexec";

     

       83
       81
        
                   path = "${config.security.wrapperDir}/pkexec";

     

       84
       82
        
                 }

     

       85
       83
        
               ]);

     

       86
       84
        
       

     

       87
       87
       -
               serviceConfig.ExecStart = mkIf cfg.enableRenice [

     

       85
       85
       +
               serviceConfig.ExecStart = lib.mkIf cfg.enableRenice [

     

       88
       86
        
                 "" # Tell systemd to clear the existing ExecStart list, to prevent appending to it.

     

       89
       87
        
                 "${config.security.wrapperDir}/gamemoded"

     

       90
       88
        
               ];

     
···

       95
       93
        
         };

     

       96
       94
        
       

     

       97
       95
        
         meta = {

     

       98
       98
       -
           maintainers = with maintainers; [ kira-bruneau ];

     

       96
       96
       +
           maintainers = with lib.maintainers; [ kira-bruneau ];

     

       99
       97
        
         };

     

       100
       98
        
       }

+18 -18

nixos/modules/programs/gamescope.nix

···

       3
       3
        
       , pkgs

     

       4
       4
        
       , ...

     

       5
       5
        
       }:

     

       6
       6
       -
       with lib; let

     

       6
       6
       +
       let

     

       7
       7
        
         cfg = config.programs.gamescope;

     

       8
       8
        
       

     

       9
       9
        
         gamescope =

     

       10
       10
        
           let

     

       11
       11
        
             wrapperArgs =

     

       12
       12
       -
               optional (cfg.args != [ ])

     

       13
       13
       -
                 ''--add-flags "${toString cfg.args}"''

     

       14
       14
       -
               ++ builtins.attrValues (mapAttrs (var: val: "--set-default ${var} ${val}") cfg.env);

     

       12
       12
       +
               lib.optional (cfg.args != [ ])

     

       13
       13
       +
                 ''--add-flags "${builtins.toString cfg.args}"''

     

       14
       14
       +
               ++ builtins.attrValues (builtins.mapAttrs (var: val: "--set-default ${var} ${val}") cfg.env);

     

       15
       15
        
           in

     

       16
       16
        
           pkgs.runCommand "gamescope" { nativeBuildInputs = [ pkgs.makeBinaryWrapper ]; } ''

     

       17
       17
        
             mkdir -p $out/bin

     

       18
       18
        
             makeWrapper ${cfg.package}/bin/gamescope $out/bin/gamescope --inherit-argv0 \

     

       19
       19
       -
               ${toString wrapperArgs}

     

       19
       19
       +
               ${builtins.toString wrapperArgs}

     

       20
       20
        
           '';

     

       21
       21
        
       in

     

       22
       22
        
       {

     

       23
       23
        
         options.programs.gamescope = {

     

       24
       24
       -
           enable = mkEnableOption "gamescope, the SteamOS session compositing window manager";

     

       24
       24
       +
           enable = lib.mkEnableOption "gamescope, the SteamOS session compositing window manager";

     

       25
       25
        
       

     

       26
       26
       -
           package = mkPackageOption pkgs "gamescope" { };

     

       26
       26
       +
           package = lib.mkPackageOption pkgs "gamescope" { };

     

       27
       27
        
       

     

       28
       28
       -
           capSysNice = mkOption {

     

       29
       29
       -
             type = types.bool;

     

       28
       28
       +
           capSysNice = lib.mkOption {

     

       29
       29
       +
             type = lib.types.bool;

     

       30
       30
        
             default = false;

     

       31
       31
        
             description = ''

     

       32
       32
        
               Add cap_sys_nice capability to the GameScope

     
···

       34
       34
        
             '';

     

       35
       35
        
           };

     

       36
       36
        
       

     

       37
       37
       -
           args = mkOption {

     

       38
       38
       -
             type = types.listOf types.str;

     

       37
       37
       +
           args = lib.mkOption {

     

       38
       38
       +
             type = lib.types.listOf lib.types.str;

     

       39
       39
        
             default = [ ];

     

       40
       40
        
             example = [ "--rt" "--prefer-vk-device 8086:9bc4" ];

     

       41
       41
        
             description = ''

     
···

       43
       43
        
             '';

     

       44
       44
        
           };

     

       45
       45
        
       

     

       46
       46
       -
           env = mkOption {

     

       47
       47
       -
             type = types.attrsOf types.str;

     

       46
       46
       +
           env = lib.mkOption {

     

       47
       47
       +
             type = lib.types.attrsOf lib.types.str;

     

       48
       48
        
             default = { };

     

       49
       49
       -
             example = literalExpression ''

     

       49
       49
       +
             example = lib.literalExpression ''

     

       50
       50
        
               # for Prime render offload on Nvidia laptops.

     

       51
       51
        
               # Also requires `hardware.nvidia.prime.offload.enable`.

     

       52
       52
        
               {

     
···

       61
       61
        
           };

     

       62
       62
        
         };

     

       63
       63
        
       

     

       64
       64
       -
         config = mkIf cfg.enable {

     

       65
       65
       -
           security.wrappers = mkIf cfg.capSysNice {

     

       64
       64
       +
         config = lib.mkIf cfg.enable {

     

       65
       65
       +
           security.wrappers = lib.mkIf cfg.capSysNice {

     

       66
       66
        
             gamescope = {

     

       67
       67
        
               owner = "root";

     

       68
       68
        
               group = "root";

     
···

       71
       71
        
             };

     

       72
       72
        
           };

     

       73
       73
        
       

     

       74
       74
       -
           environment.systemPackages = mkIf (!cfg.capSysNice) [ gamescope ];

     

       74
       74
       +
           environment.systemPackages = lib.mkIf (!cfg.capSysNice) [ gamescope ];

     

       75
       75
        
         };

     

       76
       76
        
       

     

       77
       77
       -
         meta.maintainers = with maintainers; [ nrdxp ];

     

       77
       77
       +
         meta.maintainers = with lib.maintainers; [ nrdxp ];

     

       78
       78
        
       }

+3 -5

nixos/modules/programs/geary.nix

···

       1
       1
        
       { config, pkgs, lib, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.geary;

     

       7
       5
        
       

     

       8
       6
        
       in {

     

       9
       7
        
         meta = {

     

       10
       10
       -
           maintainers = teams.gnome.members;

     

       8
       8
       +
           maintainers = lib.teams.gnome.members;

     

       11
       9
        
         };

     

       12
       10
        
       

     

       13
       11
        
         options = {

     

       14
       14
       -
           programs.geary.enable = mkEnableOption "Geary, a Mail client for GNOME";

     

       12
       12
       +
           programs.geary.enable = lib.mkEnableOption "Geary, a Mail client for GNOME";

     

       15
       13
        
         };

     

       16
       14
        
       

     

       17
       17
       -
         config = mkIf cfg.enable {

     

       15
       15
       +
         config = lib.mkIf cfg.enable {

     

       18
       16
        
           environment.systemPackages = [ pkgs.gnome.geary ];

     

       19
       17
        
           programs.dconf.enable = true;

     

       20
       18
        
           services.gnome.gnome-keyring.enable = true;

+16 -18

nixos/modules/programs/git.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.git;

     

       7
       5
        
       in

     
···

       9
       7
        
       {

     

       10
       8
        
         options = {

     

       11
       9
        
           programs.git = {

     

       12
       12
       -
             enable = mkEnableOption "git, a distributed version control system";

     

       10
       10
       +
             enable = lib.mkEnableOption "git, a distributed version control system";

     

       13
       11
        
       

     

       14
       14
       -
             package = mkPackageOption pkgs "git" {

     

       12
       12
       +
             package = lib.mkPackageOption pkgs "git" {

     

       15
       13
        
               example = "gitFull";

     

       16
       14
        
             };

     

       17
       15
        
       

     

       18
       18
       -
             config = mkOption {

     

       16
       16
       +
             config = lib.mkOption {

     

       19
       17
        
               type =

     

       20
       20
       -
                 with types;

     

       18
       18
       +
                 with lib.types;

     

       21
       19
        
                 let

     

       22
       20
        
                   gitini = attrsOf (attrsOf anything);

     

       23
       21
        
                 in

     

       24
       22
        
                 either gitini (listOf gitini) // {

     

       25
       23
        
                   merge = loc: defs:

     

       26
       24
        
                     let

     

       27
       27
       -
                       config = foldl'

     

       28
       28
       -
                         (acc: { value, ... }@x: acc // (if isList value then {

     

       25
       25
       +
                       config = builtins.foldl'

     

       26
       26
       +
                         (acc: { value, ... }@x: acc // (if builtins.isList value then {

     

       29
       27
        
                           ordered = acc.ordered ++ value;

     

       30
       28
        
                         } else {

     

       31
       29
        
                           unordered = acc.unordered ++ [ x ];

     
···

       55
       53
        
             };

     

       56
       54
        
       

     

       57
       55
        
             prompt = {

     

       58
       58
       -
               enable = mkEnableOption "automatically sourcing git-prompt.sh. This does not change $PS1; it simply provides relevant utility functions";

     

       56
       56
       +
               enable = lib.mkEnableOption "automatically sourcing git-prompt.sh. This does not change $PS1; it simply provides relevant utility functions";

     

       59
       57
        
             };

     

       60
       58
        
       

     

       61
       59
        
             lfs = {

     

       62
       62
       -
               enable = mkEnableOption "git-lfs (Large File Storage)";

     

       60
       60
       +
               enable = lib.mkEnableOption "git-lfs (Large File Storage)";

     

       63
       61
        
       

     

       64
       64
       -
               package = mkPackageOption pkgs "git-lfs" { };

     

       62
       62
       +
               package = lib.mkPackageOption pkgs "git-lfs" { };

     

       65
       63
        
             };

     

       66
       64
        
           };

     

       67
       65
        
         };

     

       68
       66
        
       

     

       69
       69
       -
         config = mkMerge [

     

       70
       70
       -
           (mkIf cfg.enable {

     

       67
       67
       +
         config = lib.mkMerge [

     

       68
       68
       +
           (lib.mkIf cfg.enable {

     

       71
       69
        
             environment.systemPackages = [ cfg.package ];

     

       72
       72
       -
             environment.etc.gitconfig = mkIf (cfg.config != [ ]) {

     

       73
       73
       -
               text = concatMapStringsSep "\n" generators.toGitINI cfg.config;

     

       70
       70
       +
             environment.etc.gitconfig = lib.mkIf (cfg.config != [ ]) {

     

       71
       71
       +
               text = lib.concatMapStringsSep "\n" lib.generators.toGitINI cfg.config;

     

       74
       72
        
             };

     

       75
       73
        
           })

     

       76
       76
       -
           (mkIf (cfg.enable && cfg.lfs.enable) {

     

       74
       74
       +
           (lib.mkIf (cfg.enable && cfg.lfs.enable) {

     

       77
       75
        
             environment.systemPackages = [ cfg.lfs.package ];

     

       78
       76
        
             programs.git.config = {

     

       79
       77
        
               filter.lfs = {

     
···

       84
       82
        
               };

     

       85
       83
        
             };

     

       86
       84
        
           })

     

       87
       87
       -
           (mkIf (cfg.enable && cfg.prompt.enable) {

     

       85
       85
       +
           (lib.mkIf (cfg.enable && cfg.prompt.enable) {

     

       88
       86
        
             environment.interactiveShellInit = ''

     

       89
       87
        
               source ${cfg.package}/share/bash-completion/completions/git-prompt.sh

     

       90
       88
        
             '';

     

       91
       89
        
           })

     

       92
       90
        
         ];

     

       93
       91
        
       

     

       94
       94
       -
         meta.maintainers = with maintainers; [ figsoda ];

     

       92
       92
       +
         meta.maintainers = with lib.maintainers; [ figsoda ];

     

       95
       93
        
       }

+4 -6

nixos/modules/programs/gphoto2.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       {

     

       6
       6
       -
         meta.maintainers = [ maintainers.league ];

     

       4
       4
       +
         meta.maintainers = [ lib.maintainers.league ];

     

       7
       5
        
       

     

       8
       6
        
         ###### interface

     

       9
       7
        
         options = {

     

       10
       8
        
           programs.gphoto2 = {

     

       11
       11
       -
             enable = mkOption {

     

       9
       9
       +
             enable = lib.mkOption {

     

       12
       10
        
               default = false;

     

       13
       13
       -
               type = types.bool;

     

       11
       11
       +
               type = lib.types.bool;

     

       14
       12
        
               description = ''

     

       15
       13
        
                 Whether to configure system to use gphoto2.

     

       16
       14
        
                 To grant digital camera access to a user, the user must

     
···

       22
       20
        
         };

     

       23
       21
        
       

     

       24
       22
        
         ###### implementation

     

       25
       25
       -
         config = mkIf config.programs.gphoto2.enable {

     

       23
       23
       +
         config = lib.mkIf config.programs.gphoto2.enable {

     

       26
       24
        
           services.udev.packages = [ pkgs.libgphoto2 ];

     

       27
       25
        
           environment.systemPackages = [ pkgs.gphoto2 ];

     

       28
       26
        
           users.groups.camera = {};

+2 -4

nixos/modules/programs/haguichi.nix

···

       1
       1
        
       { lib, pkgs, config, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       {

     

       6
       4
        
         options.programs.haguichi = {

     

       7
       7
       -
           enable = mkEnableOption "Haguichi, a Linux GUI frontend to the proprietary LogMeIn Hamachi";

     

       5
       5
       +
           enable = lib.mkEnableOption "Haguichi, a Linux GUI frontend to the proprietary LogMeIn Hamachi";

     

       8
       6
        
         };

     

       9
       7
        
       

     

       10
       10
       -
         config = mkIf config.programs.haguichi.enable {

     

       8
       8
       +
         config = lib.mkIf config.programs.haguichi.enable {

     

       11
       9
        
           environment.systemPackages = with pkgs; [ haguichi ];

     

       12
       10
        
       

     

       13
       11
        
           services.logmein-hamachi.enable = true;

+1 -3

nixos/modules/programs/hamster.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       {

     

       6
       4
        
         meta.maintainers = pkgs.hamster.meta.maintainers;

     

       7
       5
        
       

     

       8
       6
        
         options.programs.hamster.enable =

     

       9
       9
       -
           mkEnableOption "hamster, a time tracking program";

     

       7
       7
       +
           lib.mkEnableOption "hamster, a time tracking program";

     

       10
       8
        
       

     

       11
       9
        
         config = lib.mkIf config.programs.hamster.enable {

     

       12
       10
        
           environment.systemPackages = [ pkgs.hamster ];

+11 -13

nixos/modules/programs/htop.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
       

     

       7
       5
        
         cfg = config.programs.htop;

     

       8
       6
        
       

     

       9
       7
        
         fmt = value:

     

       10
       10
       -
           if isList value then concatStringsSep " " (map fmt value) else

     

       11
       11
       -
           if isString value then value else

     

       12
       12
       -
           if isBool value then if value then "1" else "0" else

     

       13
       13
       -
           if isInt value then toString value else

     

       14
       14
       -
           throw "Unrecognized type ${typeOf value} in htop settings";

     

       8
       8
       +
           if builtins.isList value then builtins.concatStringsSep " " (builtins.map fmt value) else

     

       9
       9
       +
           if builtins.isString value then value else

     

       10
       10
       +
           if builtins.isBool value then if value then "1" else "0" else

     

       11
       11
       +
           if builtins.isInt value then builtins.toString value else

     

       12
       12
       +
           throw "Unrecognized type ${builtins.typeOf value} in htop settings";

     

       15
       13
        
       

     

       16
       14
        
       in

     

       17
       15
        
       

     

       18
       16
        
       {

     

       19
       17
        
       

     

       20
       18
        
         options.programs.htop = {

     

       21
       21
       -
           package = mkPackageOption pkgs "htop" { };

     

       19
       19
       +
           package = lib.mkPackageOption pkgs "htop" { };

     

       22
       20
        
       

     

       23
       23
       -
           enable = mkEnableOption "htop process monitor";

     

       21
       21
       +
           enable = lib.mkEnableOption "htop process monitor";

     

       24
       22
        
       

     

       25
       25
       -
           settings = mkOption {

     

       26
       26
       -
             type = with types; attrsOf (oneOf [ str int bool (listOf (oneOf [ str int bool ])) ]);

     

       23
       23
       +
           settings = lib.mkOption {

     

       24
       24
       +
             type = with lib.types; attrsOf (oneOf [ str int bool (listOf (oneOf [ str int bool ])) ]);

     

       27
       25
        
             default = {};

     

       28
       26
        
             example = {

     

       29
       27
        
               hide_kernel_threads = true;

     
···

       38
       36
        
           };

     

       39
       37
        
         };

     

       40
       38
        
       

     

       41
       41
       -
         config = mkIf cfg.enable {

     

       39
       39
       +
         config = lib.mkIf cfg.enable {

     

       42
       40
        
           environment.systemPackages = [

     

       43
       41
        
             cfg.package

     

       44
       42
        
           ];

     
···

       46
       44
        
           environment.etc."htoprc".text = ''

     

       47
       45
        
             # Global htop configuration

     

       48
       46
        
             # To change set: programs.htop.settings.KEY = VALUE;

     

       49
       49
       -
           '' + concatStringsSep "\n" (mapAttrsToList (key: value: "${key}=${fmt value}") cfg.settings);

     

       47
       47
       +
           '' + builtins.concatStringsSep "\n" (lib.mapAttrsToList (key: value: "${key}=${fmt value}") cfg.settings);

     

       50
       48
        
         };

     

       51
       49
        
       

     

       52
       50
        
       }

+6 -8

nixos/modules/programs/i3lock.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
       

     

       7
       5
        
         cfg = config.programs.i3lock;

     
···

       12
       10
        
       

     

       13
       11
        
         options = {

     

       14
       12
        
           programs.i3lock = {

     

       15
       15
       -
             enable = mkEnableOption "i3lock";

     

       16
       16
       -
             package = mkPackageOption pkgs "i3lock" {

     

       13
       13
       +
             enable = lib.mkEnableOption "i3lock";

     

       14
       14
       +
             package = lib.mkPackageOption pkgs "i3lock" {

     

       17
       15
        
               example = "i3lock-color";

     

       18
       16
        
               extraDescription = ''

     

       19
       17
        
                 ::: {.note}

     
···

       21
       19
        
                 :::

     

       22
       20
        
               '';

     

       23
       21
        
             };

     

       24
       24
       -
             u2fSupport = mkOption {

     

       25
       25
       -
               type        = types.bool;

     

       22
       22
       +
             u2fSupport = lib.mkOption {

     

       23
       23
       +
               type        = lib.types.bool;

     

       26
       24
        
               default     = false;

     

       27
       25
        
               example     = true;

     

       28
       26
        
               description = ''

     
···

       36
       34
        
       

     

       37
       35
        
         ###### implementation

     

       38
       36
        
       

     

       39
       39
       -
         config = mkIf cfg.enable {

     

       37
       37
       +
         config = lib.mkIf cfg.enable {

     

       40
       38
        
       

     

       41
       39
        
           environment.systemPackages = [ cfg.package ];

     

       42
       40
        
       

     

       43
       43
       -
           security.wrappers.i3lock = mkIf cfg.u2fSupport {

     

       41
       41
       +
           security.wrappers.i3lock = lib.mkIf cfg.u2fSupport {

     

       44
       42
        
             setuid = true;

     

       45
       43
        
             owner = "root";

     

       46
       44
        
             group = "root";

+2 -4

nixos/modules/programs/iftop.nix

···

       1
       1
        
       { config, pkgs, lib, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.iftop;

     

       7
       5
        
       in {

     

       8
       6
        
         options = {

     

       9
       9
       -
           programs.iftop.enable = mkEnableOption "iftop + setcap wrapper";

     

       7
       7
       +
           programs.iftop.enable = lib.mkEnableOption "iftop + setcap wrapper";

     

       10
       8
        
         };

     

       11
       11
       -
         config = mkIf cfg.enable {

     

       9
       9
       +
         config = lib.mkIf cfg.enable {

     

       12
       10
        
           environment.systemPackages = [ pkgs.iftop ];

     

       13
       11
        
           security.wrappers.iftop = {

     

       14
       12
        
             owner = "root";

+2 -4

nixos/modules/programs/iotop.nix

···

       1
       1
        
       { config, pkgs, lib, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.iotop;

     

       7
       5
        
       in {

     

       8
       6
        
         options = {

     

       9
       9
       -
           programs.iotop.enable = mkEnableOption "iotop + setcap wrapper";

     

       7
       7
       +
           programs.iotop.enable = lib.mkEnableOption "iotop + setcap wrapper";

     

       10
       8
        
         };

     

       11
       11
       -
         config = mkIf cfg.enable {

     

       9
       9
       +
         config = lib.mkIf cfg.enable {

     

       12
       10
        
           security.wrappers.iotop = {

     

       13
       11
        
             owner = "root";

     

       14
       12
        
             group = "root";

+5 -7

nixos/modules/programs/java.nix

···

       3
       3
        
       

     

       4
       4
        
       { config, lib, pkgs, ... }:

     

       5
       5
        
       

     

       6
       6
       -
       with lib;

     

       7
       7
       -
       

     

       8
       6
        
       let

     

       9
       7
        
         cfg = config.programs.java;

     

       10
       8
        
       in

     
···

       14
       12
        
       

     

       15
       13
        
           programs.java = {

     

       16
       14
        
       

     

       17
       17
       -
             enable = mkEnableOption "java" // {

     

       15
       15
       +
             enable = lib.mkEnableOption "java" // {

     

       18
       16
        
               description = ''

     

       19
       17
        
                 Install and setup the Java development kit.

     

       20
       18
        
       

     
···

       30
       28
        
               '';

     

       31
       29
        
             };

     

       32
       30
        
       

     

       33
       33
       -
             package = mkPackageOption pkgs "jdk" {

     

       31
       31
       +
             package = lib.mkPackageOption pkgs "jdk" {

     

       34
       32
        
               example = "jre";

     

       35
       33
        
             };

     

       36
       34
        
       

     

       37
       37
       -
             binfmt = mkEnableOption "binfmt to execute java jar's and classes";

     

       35
       35
       +
             binfmt = lib.mkEnableOption "binfmt to execute java jar's and classes";

     

       38
       36
        
       

     

       39
       37
        
           };

     

       40
       38
        
       

     

       41
       39
        
         };

     

       42
       40
        
       

     

       43
       43
       -
         config = mkIf cfg.enable {

     

       41
       41
       +
         config = lib.mkIf cfg.enable {

     

       44
       42
        
       

     

       45
       45
       -
           boot.binfmt.registrations = mkIf cfg.binfmt {

     

       43
       43
       +
           boot.binfmt.registrations = lib.mkIf cfg.binfmt {

     

       46
       44
        
             java-class = {

     

       47
       45
        
               recognitionType = "extension";

     

       48
       46
        
               magicOrExtension = "class";

+1 -2

nixos/modules/programs/joycond-cemuhook.nix

···

       1
       1
        
       { lib, pkgs, config, ... }:

     

       2
       2
       -
       with lib;

     

       3
       2
        
       {

     

       4
       3
        
         options.programs.joycond-cemuhook = {

     

       5
       5
       -
           enable = mkEnableOption "joycond-cemuhook, a program to enable support for cemuhook's UDP protocol for joycond devices.";

     

       4
       4
       +
           enable = lib.mkEnableOption "joycond-cemuhook, a program to enable support for cemuhook's UDP protocol for joycond devices.";

     

       6
       5
        
         };

     

       7
       6
        
       

     

       8
       7
        
         config = lib.mkIf config.programs.joycond-cemuhook.enable {

+3 -5

nixos/modules/programs/k3b.nix

···

       1
       1
        
       { config, pkgs, lib, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       {

     

       6
       4
        
         # interface

     

       7
       5
        
         options.programs.k3b = {

     

       8
       8
       -
           enable = mkOption {

     

       9
       9
       -
             type = types.bool;

     

       6
       6
       +
           enable = lib.mkOption {

     

       7
       7
       +
             type = lib.types.bool;

     

       10
       8
        
             default = false;

     

       11
       9
        
             description = ''

     

       12
       10
        
               Whether to enable k3b, the KDE disk burning application.

     
···

       22
       20
        
         };

     

       23
       21
        
       

     

       24
       22
        
         # implementation

     

       25
       25
       -
         config = mkIf config.programs.k3b.enable {

     

       23
       23
       +
         config = lib.mkIf config.programs.k3b.enable {

     

       26
       24
        
       

     

       27
       25
        
           environment.systemPackages = with pkgs; [

     

       28
       26
        
             k3b

+5 -7

nixos/modules/programs/k40-whisperer.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.k40-whisperer;

     

       7
       5
        
         pkg = cfg.package.override {

     
···

       10
       8
        
       in

     

       11
       9
        
       {

     

       12
       10
        
         options.programs.k40-whisperer = {

     

       13
       13
       -
           enable = mkEnableOption "K40-Whisperer";

     

       11
       11
       +
           enable = lib.mkEnableOption "K40-Whisperer";

     

       14
       12
        
       

     

       15
       15
       -
           group = mkOption {

     

       16
       16
       -
             type = types.str;

     

       13
       13
       +
           group = lib.mkOption {

     

       14
       14
       +
             type = lib.types.str;

     

       17
       15
        
             description = ''

     

       18
       16
        
               Group assigned to the device when connected.

     

       19
       17
        
             '';

     

       20
       18
        
             default = "k40";

     

       21
       19
        
           };

     

       22
       20
        
       

     

       23
       23
       -
           package = mkPackageOption pkgs "k40-whisperer" { };

     

       21
       21
       +
           package = lib.mkPackageOption pkgs "k40-whisperer" { };

     

       24
       22
        
         };

     

       25
       23
        
       

     

       26
       26
       -
         config = mkIf cfg.enable {

     

       24
       24
       +
         config = lib.mkIf cfg.enable {

     

       27
       25
        
           users.groups.${cfg.group} = {};

     

       28
       26
        
       

     

       29
       27
        
           environment.systemPackages = [ pkg ];

+2 -4

nixos/modules/programs/kbdlight.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.kbdlight;

     

       7
       5
        
       

     

       8
       6
        
       in

     

       9
       7
        
       {

     

       10
       10
       -
         options.programs.kbdlight.enable = mkEnableOption "kbdlight";

     

       8
       8
       +
         options.programs.kbdlight.enable = lib.mkEnableOption "kbdlight";

     

       11
       9
        
       

     

       12
       12
       -
         config = mkIf cfg.enable {

     

       10
       10
       +
         config = lib.mkIf cfg.enable {

     

       13
       11
        
           environment.systemPackages = [ pkgs.kbdlight ];

     

       14
       12
        
           security.wrappers.kbdlight =

     

       15
       13
        
             { setuid = true;

+2 -3

nixos/modules/programs/kclock.nix

···

       1
       1
        
       { lib, pkgs, config, ... }:

     

       2
       2
       -
       with lib;

     

       3
       2
        
       let

     

       4
       3
        
         cfg = config.programs.kclock;

     

       5
       4
        
         kclockPkg = pkgs.libsForQt5.kclock;

     

       6
       5
        
       in {

     

       7
       7
       -
         options.programs.kclock = { enable = mkEnableOption "KClock"; };

     

       6
       6
       +
         options.programs.kclock = { enable = lib.mkEnableOption "KClock"; };

     

       8
       7
        
       

     

       9
       9
       -
         config = mkIf cfg.enable {

     

       8
       8
       +
         config = lib.mkIf cfg.enable {

     

       10
       9
        
           services.dbus.packages = [ kclockPkg ];

     

       11
       10
        
           environment.systemPackages = [ kclockPkg ];

     

       12
       11
        
         };

+3 -4

nixos/modules/programs/kdeconnect.nix

···

       1
       1
        
       { config, pkgs, lib, ... }:

     

       2
       2
       -
       with lib;

     

       3
       2
        
       {

     

       4
       3
        
         options.programs.kdeconnect = {

     

       5
       5
       -
           enable = mkEnableOption ''

     

       4
       4
       +
           enable = lib.mkEnableOption ''

     

       6
       5
        
             kdeconnect.

     

       7
       6
        
       

     

       8
       7
        
             Note that it will open the TCP and UDP port from

     
···

       11
       10
        
             `gnomeExtensions.gsconnect` as an alternative

     

       12
       11
        
             implementation if you use Gnome

     

       13
       12
        
           '';

     

       14
       14
       -
           package = mkPackageOption pkgs [ "plasma5Packages" "kdeconnect-kde" ] {

     

       13
       13
       +
           package = lib.mkPackageOption pkgs [ "plasma5Packages" "kdeconnect-kde" ] {

     

       15
       14
        
             example = "gnomeExtensions.gsconnect";

     

       16
       15
        
           };

     

       17
       16
        
         };

     
···

       19
       18
        
           let

     

       20
       19
        
             cfg = config.programs.kdeconnect;

     

       21
       20
        
           in

     

       22
       22
       -
             mkIf cfg.enable {

     

       21
       21
       +
             lib.mkIf cfg.enable {

     

       23
       22
        
               environment.systemPackages = [

     

       24
       23
        
                 cfg.package

     

       25
       24
        
                 pkgs.sshfs

+31 -33

nixos/modules/programs/less.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
       

     

       7
       5
        
         cfg = config.programs.less;

     

       8
       6
        
       

     

       9
       7
        
         configText = if (cfg.configFile != null) then (builtins.readFile cfg.configFile) else ''

     

       10
       8
        
           #command

     

       11
       11
       -
           ${concatStringsSep "\n"

     

       12
       12
       -
             (mapAttrsToList (command: action: "${command} ${action}") cfg.commands)

     

       9
       9
       +
           ${builtins.concatStringsSep "\n"

     

       10
       10
       +
             (lib.mapAttrsToList (command: action: "${command} ${action}") cfg.commands)

     

       13
       11
        
           }

     

       14
       14
       -
           ${optionalString cfg.clearDefaultCommands "#stop"}

     

       12
       12
       +
           ${lib.optionalString cfg.clearDefaultCommands "#stop"}

     

       15
       13
        
       

     

       16
       14
        
           #line-edit

     

       17
       17
       -
           ${concatStringsSep "\n"

     

       18
       18
       -
             (mapAttrsToList (command: action: "${command} ${action}") cfg.lineEditingKeys)

     

       15
       15
       +
           ${builtins.concatStringsSep "\n"

     

       16
       16
       +
             (lib.mapAttrsToList (command: action: "${command} ${action}") cfg.lineEditingKeys)

     

       19
       17
        
           }

     

       20
       18
        
       

     

       21
       19
        
           #env

     

       22
       22
       -
           ${concatStringsSep "\n"

     

       23
       23
       -
             (mapAttrsToList (variable: values: "${variable}=${values}") cfg.envVariables)

     

       20
       20
       +
           ${builtins.concatStringsSep "\n"

     

       21
       21
       +
             (lib.mapAttrsToList (variable: values: "${variable}=${values}") cfg.envVariables)

     

       24
       22
        
           }

     

       25
       23
        
         '';

     

       26
       24
        
       

     
···

       35
       33
        
       

     

       36
       34
        
             # note that environment.nix sets PAGER=less, and

     

       37
       35
        
             # therefore also enables this module

     

       38
       38
       -
             enable = mkEnableOption "less, a file pager";

     

       36
       36
       +
             enable = lib.mkEnableOption "less, a file pager";

     

       39
       37
        
       

     

       40
       40
       -
             configFile = mkOption {

     

       41
       41
       -
               type = types.nullOr types.path;

     

       38
       38
       +
             configFile = lib.mkOption {

     

       39
       39
       +
               type = lib.types.nullOr lib.types.path;

     

       42
       40
        
               default = null;

     

       43
       43
       -
               example = literalExpression ''"''${pkgs.my-configs}/lesskey"'';

     

       41
       41
       +
               example = lib.literalExpression ''"''${pkgs.my-configs}/lesskey"'';

     

       44
       42
        
               description = ''

     

       45
       43
        
                 Path to lesskey configuration file.

     

       46
       44
        
       

     
···

       50
       48
        
               '';

     

       51
       49
        
             };

     

       52
       50
        
       

     

       53
       53
       -
             commands = mkOption {

     

       54
       54
       -
               type = types.attrsOf types.str;

     

       51
       51
       +
             commands = lib.mkOption {

     

       52
       52
       +
               type = lib.types.attrsOf lib.types.str;

     

       55
       53
        
               default = {};

     

       56
       54
        
               example = {

     

       57
       55
        
                 h = "noaction 5\\e(";

     
···

       60
       58
        
               description = "Defines new command keys.";

     

       61
       59
        
             };

     

       62
       60
        
       

     

       63
       63
       -
             clearDefaultCommands = mkOption {

     

       64
       64
       -
               type = types.bool;

     

       61
       61
       +
             clearDefaultCommands = lib.mkOption {

     

       62
       62
       +
               type = lib.types.bool;

     

       65
       63
        
               default = false;

     

       66
       64
        
               description = ''

     

       67
       65
        
                 Clear all default commands.

     
···

       70
       68
        
               '';

     

       71
       69
        
             };

     

       72
       70
        
       

     

       73
       73
       -
             lineEditingKeys = mkOption {

     

       74
       74
       -
               type = types.attrsOf types.str;

     

       71
       71
       +
             lineEditingKeys = lib.mkOption {

     

       72
       72
       +
               type = lib.types.attrsOf lib.types.str;

     

       75
       73
        
               default = {};

     

       76
       74
        
               example = {

     

       77
       75
        
                 e = "abort";

     
···

       79
       77
        
               description = "Defines new line-editing keys.";

     

       80
       78
        
             };

     

       81
       79
        
       

     

       82
       82
       -
             envVariables = mkOption {

     

       83
       83
       -
               type = types.attrsOf types.str;

     

       80
       80
       +
             envVariables = lib.mkOption {

     

       81
       81
       +
               type = lib.types.attrsOf lib.types.str;

     

       84
       82
        
               default = {

     

       85
       83
        
                 LESS = "-R";

     

       86
       84
        
               };

     
···

       90
       88
        
               description = "Defines environment variables.";

     

       91
       89
        
             };

     

       92
       90
        
       

     

       93
       93
       -
             lessopen = mkOption {

     

       94
       94
       -
               type = types.nullOr types.str;

     

       91
       91
       +
             lessopen = lib.mkOption {

     

       92
       92
       +
               type = lib.types.nullOr lib.types.str;

     

       95
       93
        
               default = "|${pkgs.lesspipe}/bin/lesspipe.sh %s";

     

       96
       96
       -
               defaultText = literalExpression ''"|''${pkgs.lesspipe}/bin/lesspipe.sh %s"'';

     

       94
       94
       +
               defaultText = lib.literalExpression ''"|''${pkgs.lesspipe}/bin/lesspipe.sh %s"'';

     

       97
       95
        
               description = ''

     

       98
       96
        
                 Before less opens a file, it first gives your input preprocessor a chance to modify the way the contents of the file are displayed.

     

       99
       97
        
               '';

     

       100
       98
        
             };

     

       101
       99
        
       

     

       102
       102
       -
             lessclose = mkOption {

     

       103
       103
       -
               type = types.nullOr types.str;

     

       100
       100
       +
             lessclose = lib.mkOption {

     

       101
       101
       +
               type = lib.types.nullOr lib.types.str;

     

       104
       102
        
               default = null;

     

       105
       103
        
               description = ''

     

       106
       104
        
                 When less closes a file opened in such a way, it will call another program, called the input postprocessor,

     
···

       110
       108
        
           };

     

       111
       109
        
         };

     

       112
       110
        
       

     

       113
       113
       -
         config = mkIf cfg.enable {

     

       111
       111
       +
         config = lib.mkIf cfg.enable {

     

       114
       112
        
       

     

       115
       113
        
           environment.systemPackages = [ pkgs.less ];

     

       116
       114
        
       

     

       117
       115
        
           environment.variables = {

     

       118
       118
       -
             LESSKEYIN_SYSTEM = toString lessKey;

     

       119
       119
       -
           } // optionalAttrs (cfg.lessopen != null) {

     

       116
       116
       +
             LESSKEYIN_SYSTEM = builtins.toString lessKey;

     

       117
       117
       +
           } // lib.optionalAttrs (cfg.lessopen != null) {

     

       120
       118
        
             LESSOPEN = cfg.lessopen;

     

       121
       121
       -
           } // optionalAttrs (cfg.lessclose != null) {

     

       119
       119
       +
           } // lib.optionalAttrs (cfg.lessclose != null) {

     

       122
       120
        
             LESSCLOSE = cfg.lessclose;

     

       123
       121
        
           };

     

       124
       122
        
       

     

       125
       125
       -
           warnings = optional (

     

       126
       126
       -
             cfg.clearDefaultCommands && (all (x: x != "quit") (attrValues cfg.commands))

     

       123
       123
       +
           warnings = lib.optional (

     

       124
       124
       +
             cfg.clearDefaultCommands && (builtins.all (x: x != "quit") (builtins.attrValues cfg.commands))

     

       127
       125
        
           ) ''

     

       128
       126
        
             config.programs.less.clearDefaultCommands clears all default commands of less but there is no alternative binding for exiting.

     

       129
       127
        
             Consider adding a binding for 'quit'.

     

       130
       128
        
           '';

     

       131
       129
        
         };

     

       132
       130
        
       

     

       133
       133
       -
         meta.maintainers = with maintainers; [ johnazoidberg ];

     

       131
       131
       +
         meta.maintainers = with lib.maintainers; [ johnazoidberg ];

     

       134
       132
        
       

     

       135
       133
        
       }

+3 -5

nixos/modules/programs/liboping.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.liboping;

     

       7
       5
        
       in {

     

       8
       6
        
         options.programs.liboping = {

     

       9
       9
       -
           enable = mkEnableOption "liboping";

     

       7
       7
       +
           enable = lib.mkEnableOption "liboping";

     

       10
       8
        
         };

     

       11
       11
       -
         config = mkIf cfg.enable {

     

       9
       9
       +
         config = lib.mkIf cfg.enable {

     

       12
       10
        
           environment.systemPackages = with pkgs; [ liboping ];

     

       13
       13
       -
           security.wrappers = mkMerge (map (

     

       11
       11
       +
           security.wrappers = lib.mkMerge (builtins.map (

     

       14
       12
        
             exec: {

     

       15
       13
        
               "${exec}" = {

     

       16
       14
        
                 owner = "root";

+9 -11

nixos/modules/programs/light.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.light;

     

       7
       5
        
       

     
···

       10
       8
        
         options = {

     

       11
       9
        
           programs.light = {

     

       12
       10
        
       

     

       13
       13
       -
             enable = mkOption {

     

       11
       11
       +
             enable = lib.mkOption {

     

       14
       12
        
               default = false;

     

       15
       15
       -
               type = types.bool;

     

       13
       13
       +
               type = lib.types.bool;

     

       16
       14
        
               description = ''

     

       17
       15
        
                 Whether to install Light backlight control command

     

       18
       16
        
                 and udev rules granting access to members of the "video" group.

     
···

       20
       18
        
             };

     

       21
       19
        
       

     

       22
       20
        
             brightnessKeys = {

     

       23
       23
       -
               enable = mkOption {

     

       24
       24
       -
                 type = types.bool;

     

       21
       21
       +
               enable = lib.mkOption {

     

       22
       22
       +
                 type = lib.types.bool;

     

       25
       23
        
                 default = false;

     

       26
       24
        
                 description = ''

     

       27
       25
        
                   Whether to enable brightness control with keyboard keys.

     
···

       38
       36
        
                 '';

     

       39
       37
        
               };

     

       40
       38
        
       

     

       41
       41
       -
               step = mkOption {

     

       42
       42
       -
                 type = types.int;

     

       39
       39
       +
               step = lib.mkOption {

     

       40
       40
       +
                 type = lib.types.int;

     

       43
       41
        
                 default = 10;

     

       44
       42
        
                 description = ''

     

       45
       43
        
                   The percentage value by which to increase/decrease brightness.

     
···

       51
       49
        
           };

     

       52
       50
        
         };

     

       53
       51
        
       

     

       54
       54
       -
         config = mkIf cfg.enable {

     

       52
       52
       +
         config = lib.mkIf cfg.enable {

     

       55
       53
        
           environment.systemPackages = [ pkgs.light ];

     

       56
       54
        
           services.udev.packages = [ pkgs.light ];

     

       57
       57
       -
           services.actkbd = mkIf cfg.brightnessKeys.enable {

     

       55
       55
       +
           services.actkbd = lib.mkIf cfg.brightnessKeys.enable {

     

       58
       56
        
             enable = true;

     

       59
       57
        
             bindings = let

     

       60
       58
        
               light = "${pkgs.light}/bin/light";

     

       61
       61
       -
               step = toString cfg.brightnessKeys.step;

     

       59
       59
       +
               step = builtins.toString cfg.brightnessKeys.step;

     

       62
       60
        
             in [

     

       63
       61
        
               {

     

       64
       62
        
                 keys = [ 224 ];

+2 -3

nixos/modules/programs/mdevctl.nix

···

       1
       1
        
       { config, pkgs, lib, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       3
        
       let

     

       5
       4
        
         cfg = config.programs.mdevctl;

     

       6
       5
        
       in {

     

       7
       6
        
         options.programs.mdevctl = {

     

       8
       8
       -
           enable = mkEnableOption "Mediated Device Management";

     

       7
       7
       +
           enable = lib.mkEnableOption "Mediated Device Management";

     

       9
       8
        
         };

     

       10
       9
        
       

     

       11
       11
       -
         config = mkIf cfg.enable {

     

       10
       10
       +
         config = lib.mkIf cfg.enable {

     

       12
       11
        
           environment.systemPackages = with pkgs; [ mdevctl ];

     

       13
       12
        
       

     

       14
       13
        
           environment.etc."mdevctl.d/scripts.d/notifiers/.keep".text = "";

+8 -9

nixos/modules/programs/mepo.nix

···

       1
       1
        
       { pkgs, config, lib, ...}:

     

       2
       2
       -
       with lib;

     

       3
       2
        
       let

     

       4
       3
        
         cfg = config.programs.mepo;

     

       5
       4
        
       in

     

       6
       5
        
       {

     

       7
       6
        
         options.programs.mepo = {

     

       8
       8
       -
           enable = mkEnableOption "Mepo, a fast, simple and hackable OSM map viewer";

     

       7
       7
       +
           enable = lib.mkEnableOption "Mepo, a fast, simple and hackable OSM map viewer";

     

       9
       8
        
       

     

       10
       9
        
           locationBackends = {

     

       11
       11
       -
             gpsd = mkOption {

     

       12
       12
       -
               type = types.bool;

     

       10
       10
       +
             gpsd = lib.mkOption {

     

       11
       11
       +
               type = lib.types.bool;

     

       13
       12
        
               default = false;

     

       14
       13
        
               description = ''

     

       15
       14
        
                 Whether to enable location detection via gpsd.

     
···

       17
       16
        
               '';

     

       18
       17
        
             };

     

       19
       18
        
       

     

       20
       20
       -
             geoclue = mkOption {

     

       21
       21
       -
               type = types.bool;

     

       19
       19
       +
             geoclue = lib.mkOption {

     

       20
       20
       +
               type = lib.types.bool;

     

       22
       21
        
               default = true;

     

       23
       22
        
               description = "Whether to enable location detection via geoclue";

     

       24
       23
        
             };

     

       25
       24
        
           };

     

       26
       25
        
         };

     

       27
       26
        
       

     

       28
       28
       -
         config = mkIf cfg.enable {

     

       27
       27
       +
         config = lib.mkIf cfg.enable {

     

       29
       28
        
           environment.systemPackages = with pkgs; [

     

       30
       29
        
             mepo

     

       31
       30
        
           ] ++ lib.optional cfg.locationBackends.geoclue geoclue2-with-demo-agent

     

       32
       31
        
           ++ lib.optional cfg.locationBackends.gpsd gpsd;

     

       33
       32
        
       

     

       34
       34
       -
           services.geoclue2 = mkIf cfg.locationBackends.geoclue {

     

       33
       33
       +
           services.geoclue2 = lib.mkIf cfg.locationBackends.geoclue {

     

       35
       34
        
             enable = true;

     

       36
       35
        
             appConfig.where-am-i = {

     

       37
       36
        
               isAllowed = true;

     
···

       42
       41
        
           services.gpsd.enable = cfg.locationBackends.gpsd;

     

       43
       42
        
         };

     

       44
       43
        
       

     

       45
       45
       -
         meta.maintainers = with maintainers; [ laalsaas ];

     

       44
       44
       +
         meta.maintainers = with lib.maintainers; [ laalsaas ];

     

       46
       45
        
       }

+2 -4

nixos/modules/programs/mininet.nix

···

       2
       2
        
       # kernel must have NETNS/VETH/SCHED

     

       3
       3
        
       { config, lib, pkgs, ... }:

     

       4
       4
        
       

     

       5
       5
       -
       with lib;

     

       6
       6
       -
       

     

       7
       5
        
       let

     

       8
       6
        
         cfg = config.programs.mininet;

     

       9
       7
        
       in

     

       10
       8
        
       {

     

       11
       11
       -
         options.programs.mininet.enable = mkEnableOption "Mininet, an emulator for rapid prototyping of Software Defined Networks";

     

       9
       9
       +
         options.programs.mininet.enable = lib.mkEnableOption "Mininet, an emulator for rapid prototyping of Software Defined Networks";

     

       12
       10
        
       

     

       13
       13
       -
         config = mkIf cfg.enable {

     

       11
       11
       +
         config = lib.mkIf cfg.enable {

     

       14
       12
        
       

     

       15
       13
        
           virtualisation.vswitch.enable = true;

     

       16
       14

+15 -17

nixos/modules/programs/msmtp.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.msmtp;

     

       7
       5
        
       

     

       8
       6
        
       in {

     

       9
       9
       -
         meta.maintainers = with maintainers; [ pacien ];

     

       7
       7
       +
         meta.maintainers = with lib.maintainers; [ pacien ];

     

       10
       8
        
       

     

       11
       9
        
         options = {

     

       12
       10
        
           programs.msmtp = {

     

       13
       13
       -
             enable = mkEnableOption "msmtp - an SMTP client";

     

       11
       11
       +
             enable = lib.mkEnableOption "msmtp - an SMTP client";

     

       14
       12
        
       

     

       15
       15
       -
             setSendmail = mkOption {

     

       16
       16
       -
               type = types.bool;

     

       13
       13
       +
             setSendmail = lib.mkOption {

     

       14
       14
       +
               type = lib.types.bool;

     

       17
       15
        
               default = true;

     

       18
       16
        
               description = ''

     

       19
       17
        
                 Whether to set the system sendmail to msmtp's.

     

       20
       18
        
               '';

     

       21
       19
        
             };

     

       22
       20
        
       

     

       23
       23
       -
             defaults = mkOption {

     

       24
       24
       -
               type = types.attrs;

     

       21
       21
       +
             defaults = lib.mkOption {

     

       22
       22
       +
               type = lib.types.attrs;

     

       25
       23
        
               default = {};

     

       26
       24
        
               example = {

     

       27
       25
        
                 aliases = "/etc/aliases";

     
···

       34
       32
        
               '';

     

       35
       33
        
             };

     

       36
       34
        
       

     

       37
       37
       -
             accounts = mkOption {

     

       38
       38
       -
               type = with types; attrsOf attrs;

     

       35
       35
       +
             accounts = lib.mkOption {

     

       36
       36
       +
               type = with lib.types; attrsOf attrs;

     

       39
       37
        
               default = {};

     

       40
       38
        
               example = {

     

       41
       39
        
                 "default" = {

     
···

       59
       57
        
               '';

     

       60
       58
        
             };

     

       61
       59
        
       

     

       62
       62
       -
             extraConfig = mkOption {

     

       63
       63
       -
               type = types.lines;

     

       60
       60
       +
             extraConfig = lib.mkOption {

     

       61
       61
       +
               type = lib.types.lines;

     

       64
       62
        
               default = "";

     

       65
       63
        
               description = ''

     

       66
       64
        
                 Extra lines to add to the msmtp configuration verbatim.

     
···

       70
       68
        
           };

     

       71
       69
        
         };

     

       72
       70
        
       

     

       73
       73
       -
         config = mkIf cfg.enable {

     

       71
       71
       +
         config = lib.mkIf cfg.enable {

     

       74
       72
        
           environment.systemPackages = [ pkgs.msmtp ];

     

       75
       73
        
       

     

       76
       76
       -
           services.mail.sendmailSetuidWrapper = mkIf cfg.setSendmail {

     

       74
       74
       +
           services.mail.sendmailSetuidWrapper = lib.mkIf cfg.setSendmail {

     

       77
       75
        
             program = "sendmail";

     

       78
       76
        
             source = "${pkgs.msmtp}/bin/sendmail";

     

       79
       77
        
             setuid = false;

     
···

       86
       84
        
             mkValueString = v:

     

       87
       85
        
               if v == true then "on"

     

       88
       86
        
               else if v == false then "off"

     

       89
       89
       -
               else generators.mkValueStringDefault {} v;

     

       87
       87
       +
               else lib.generators.mkValueStringDefault {} v;

     

       90
       88
        
             mkKeyValueString = k: v: "${k} ${mkValueString v}";

     

       91
       89
        
             mkInnerSectionString =

     

       92
       92
       -
               attrs: concatStringsSep "\n" (mapAttrsToList mkKeyValueString attrs);

     

       90
       90
       +
               attrs: builtins.concatStringsSep "\n" (lib.mapAttrsToList mkKeyValueString attrs);

     

       93
       91
        
             mkAccountString = name: attrs: ''

     

       94
       92
        
               account ${name}

     

       95
       93
        
               ${mkInnerSectionString attrs}

     
···

       98
       96
        
             defaults

     

       99
       97
        
             ${mkInnerSectionString cfg.defaults}

     

       100
       98
        
       

     

       101
       101
       -
             ${concatStringsSep "\n" (mapAttrsToList mkAccountString cfg.accounts)}

     

       99
       99
       +
             ${builtins.concatStringsSep "\n" (lib.mapAttrsToList mkAccountString cfg.accounts)}

     

       102
       100
        
       

     

       103
       101
        
             ${cfg.extraConfig}

     

       104
       102
        
           '';

+5 -7

nixos/modules/programs/mtr.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.mtr;

     

       7
       5
        
       

     

       8
       6
        
       in {

     

       9
       7
        
         options = {

     

       10
       8
        
           programs.mtr = {

     

       11
       11
       -
             enable = mkOption {

     

       12
       12
       -
               type = types.bool;

     

       9
       9
       +
             enable = lib.mkOption {

     

       10
       10
       +
               type = lib.types.bool;

     

       13
       11
        
               default = false;

     

       14
       12
        
               description = ''

     

       15
       13
        
                 Whether to add mtr to the global environment and configure a

     
···

       17
       15
        
               '';

     

       18
       16
        
             };

     

       19
       17
        
       

     

       20
       20
       -
             package = mkPackageOption pkgs "mtr" { };

     

       18
       18
       +
             package = lib.mkPackageOption pkgs "mtr" { };

     

       21
       19
        
           };

     

       22
       20
        
         };

     

       23
       21
        
       

     

       24
       24
       -
         config = mkIf cfg.enable {

     

       25
       25
       -
           environment.systemPackages = with pkgs; [ cfg.package ];

     

       22
       22
       +
         config = lib.mkIf cfg.enable {

     

       23
       23
       +
           environment.systemPackages = [ cfg.package ];

     

       26
       24
        
       

     

       27
       25
        
           security.wrappers.mtr-packet = {

     

       28
       26
        
             owner = "root";

+2 -4

nixos/modules/programs/nbd.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.nbd;

     

       7
       5
        
       in

     

       8
       6
        
       {

     

       9
       7
        
         options = {

     

       10
       8
        
           programs.nbd = {

     

       11
       11
       -
             enable = mkEnableOption "Network Block Device (nbd) support";

     

       9
       9
       +
             enable = lib.mkEnableOption "Network Block Device (nbd) support";

     

       12
       10
        
           };

     

       13
       11
        
         };

     

       14
       12
        
       

     

       15
       15
       -
         config = mkIf cfg.enable {

     

       13
       13
       +
         config = lib.mkIf cfg.enable {

     

       16
       14
        
           environment.systemPackages = with pkgs; [ nbd ];

     

       17
       15
        
           boot.kernelModules = [ "nbd" ];

     

       18
       16
        
         };

+37 -39

nixos/modules/programs/neovim.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.neovim;

     

       7
       5
        
       in

     

       8
       6
        
       {

     

       9
       7
        
         options.programs.neovim = {

     

       10
       10
       -
           enable = mkOption {

     

       11
       11
       -
             type = types.bool;

     

       8
       8
       +
           enable = lib.mkOption {

     

       9
       9
       +
             type = lib.types.bool;

     

       12
       10
        
             default = false;

     

       13
       11
        
             example = true;

     

       14
       12
        
             description = ''

     
···

       21
       19
        
             '';

     

       22
       20
        
           };

     

       23
       21
        
       

     

       24
       24
       -
           defaultEditor = mkOption {

     

       25
       25
       -
             type = types.bool;

     

       22
       22
       +
           defaultEditor = lib.mkOption {

     

       23
       23
       +
             type = lib.types.bool;

     

       26
       24
        
             default = false;

     

       27
       25
        
             description = ''

     

       28
       26
        
               When enabled, installs neovim and configures neovim to be the default editor

     
···

       30
       28
        
             '';

     

       31
       29
        
           };

     

       32
       30
        
       

     

       33
       33
       -
           viAlias = mkOption {

     

       34
       34
       -
             type = types.bool;

     

       31
       31
       +
           viAlias = lib.mkOption {

     

       32
       32
       +
             type = lib.types.bool;

     

       35
       33
        
             default = false;

     

       36
       34
        
             description = ''

     

       37
       35
        
               Symlink {command}`vi` to {command}`nvim` binary.

     

       38
       36
        
             '';

     

       39
       37
        
           };

     

       40
       38
        
       

     

       41
       41
       -
           vimAlias = mkOption {

     

       42
       42
       -
             type = types.bool;

     

       39
       39
       +
           vimAlias = lib.mkOption {

     

       40
       40
       +
             type = lib.types.bool;

     

       43
       41
        
             default = false;

     

       44
       42
        
             description = ''

     

       45
       43
        
               Symlink {command}`vim` to {command}`nvim` binary.

     

       46
       44
        
             '';

     

       47
       45
        
           };

     

       48
       46
        
       

     

       49
       49
       -
           withRuby = mkOption {

     

       50
       50
       -
             type = types.bool;

     

       47
       47
       +
           withRuby = lib.mkOption {

     

       48
       48
       +
             type = lib.types.bool;

     

       51
       49
        
             default = true;

     

       52
       50
        
             description = "Enable Ruby provider.";

     

       53
       51
        
           };

     

       54
       52
        
       

     

       55
       55
       -
           withPython3 = mkOption {

     

       56
       56
       -
             type = types.bool;

     

       53
       53
       +
           withPython3 = lib.mkOption {

     

       54
       54
       +
             type = lib.types.bool;

     

       57
       55
        
             default = true;

     

       58
       56
        
             description = "Enable Python 3 provider.";

     

       59
       57
        
           };

     

       60
       58
        
       

     

       61
       61
       -
           withNodeJs = mkOption {

     

       62
       62
       -
             type = types.bool;

     

       59
       59
       +
           withNodeJs = lib.mkOption {

     

       60
       60
       +
             type = lib.types.bool;

     

       63
       61
        
             default = false;

     

       64
       62
        
             description = "Enable Node provider.";

     

       65
       63
        
           };

     

       66
       64
        
       

     

       67
       67
       -
           configure = mkOption {

     

       68
       68
       -
             type = types.attrs;

     

       65
       65
       +
           configure = lib.mkOption {

     

       66
       66
       +
             type = lib.types.attrs;

     

       69
       67
        
             default = { };

     

       70
       70
       -
             example = literalExpression ''

     

       68
       68
       +
             example = lib.literalExpression ''

     

       71
       69
        
               {

     

       72
       70
        
                 customRC = '''

     

       73
       71
        
                   " here your custom configuration goes!

     
···

       86
       84
        
             '';

     

       87
       85
        
           };

     

       88
       86
        
       

     

       89
       89
       -
           package = mkPackageOption pkgs "neovim-unwrapped" { };

     

       87
       87
       +
           package = lib.mkPackageOption pkgs "neovim-unwrapped" { };

     

       90
       88
        
       

     

       91
       91
       -
           finalPackage = mkOption {

     

       92
       92
       -
             type = types.package;

     

       89
       89
       +
           finalPackage = lib.mkOption {

     

       90
       90
       +
             type = lib.types.package;

     

       93
       91
        
             visible = false;

     

       94
       92
        
             readOnly = true;

     

       95
       93
        
             description = "Resulting customized neovim package.";

     

       96
       94
        
           };

     

       97
       95
        
       

     

       98
       98
       -
           runtime = mkOption {

     

       96
       96
       +
           runtime = lib.mkOption {

     

       99
       97
        
             default = { };

     

       100
       100
       -
             example = literalExpression ''

     

       98
       98
       +
             example = lib.literalExpression ''

     

       101
       99
        
               { "ftplugin/c.vim".text = "setlocal omnifunc=v:lua.vim.lsp.omnifunc"; }

     

       102
       100
        
             '';

     

       103
       101
        
             description = ''

     

       104
       102
        
               Set of files that have to be linked in {file}`runtime`.

     

       105
       103
        
             '';

     

       106
       104
        
       

     

       107
       107
       -
             type = with types; attrsOf (submodule (

     

       105
       105
       +
             type = with lib.types; attrsOf (submodule (

     

       108
       106
        
               { name, config, ... }:

     

       109
       107
        
               {

     

       110
       108
        
                 options = {

     

       111
       109
        
       

     

       112
       112
       -
                   enable = mkOption {

     

       113
       113
       -
                     type = types.bool;

     

       110
       110
       +
                   enable = lib.mkOption {

     

       111
       111
       +
                     type = lib.types.bool;

     

       114
       112
        
                     default = true;

     

       115
       113
        
                     description = ''

     

       116
       114
        
                       Whether this runtime directory should be generated.  This

     
···

       118
       116
        
                     '';

     

       119
       117
        
                   };

     

       120
       118
        
       

     

       121
       121
       -
                   target = mkOption {

     

       122
       122
       -
                     type = types.str;

     

       119
       119
       +
                   target = lib.mkOption {

     

       120
       120
       +
                     type = lib.types.str;

     

       123
       121
        
                     description = ''

     

       124
       122
        
                       Name of symlink.  Defaults to the attribute

     

       125
       123
        
                       name.

     

       126
       124
        
                     '';

     

       127
       125
        
                   };

     

       128
       126
        
       

     

       129
       129
       -
                   text = mkOption {

     

       127
       127
       +
                   text = lib.mkOption {

     

       130
       128
        
                     default = null;

     

       131
       131
       -
                     type = types.nullOr types.lines;

     

       129
       129
       +
                     type = lib.types.nullOr lib.types.lines;

     

       132
       130
        
                     description = "Text of the file.";

     

       133
       131
        
                   };

     

       134
       132
        
       

     

       135
       135
       -
                   source = mkOption {

     

       133
       133
       +
                   source = lib.mkOption {

     

       136
       134
        
                     default = null;

     

       137
       137
       -
                     type = types.nullOr types.path;

     

       135
       135
       +
                     type = lib.types.nullOr lib.types.path;

     

       138
       136
        
                     description = "Path of the source file.";

     

       139
       137
        
                   };

     

       140
       138
        
       

     

       141
       139
        
                 };

     

       142
       140
        
       

     

       143
       143
       -
                 config.target = mkDefault name;

     

       141
       141
       +
                 config.target = lib.mkDefault name;

     

       144
       142
        
               }

     

       145
       143
        
             ));

     

       146
       144
        
       

     

       147
       145
        
           };

     

       148
       146
        
         };

     

       149
       147
        
       

     

       150
       150
       -
         config = mkIf cfg.enable {

     

       148
       148
       +
         config = lib.mkIf cfg.enable {

     

       151
       149
        
           environment.systemPackages = [

     

       152
       150
        
             cfg.finalPackage

     

       153
       151
        
           ];

     

       154
       154
       -
           environment.variables.EDITOR = mkIf cfg.defaultEditor (mkOverride 900 "nvim");

     

       152
       152
       +
           environment.variables.EDITOR = lib.mkIf cfg.defaultEditor (lib.mkOverride 900 "nvim");

     

       155
       153
        
       

     

       156
       156
       -
           environment.etc = listToAttrs (attrValues (mapAttrs

     

       154
       154
       +
           environment.etc = builtins.listToAttrs (builtins.attrValues (builtins.mapAttrs

     

       157
       155
        
             (name: value: {

     

       158
       156
        
               name = "xdg/nvim/${name}";

     

       159
       159
       -
               value = removeAttrs

     

       157
       157
       +
               value = builtins.removeAttrs

     

       160
       158
        
                 (value // {

     

       161
       159
        
                   target = "xdg/nvim/${value.target}";

     

       162
       160
        
                 })

     

       163
       163
       -
                 (optionals (isNull value.source) [ "source" ]);

     

       161
       161
       +
                 (lib.optionals (builtins.isNull value.source) [ "source" ]);

     

       164
       162
        
             })

     

       165
       163
        
             cfg.runtime));

     

       166
       164

+4 -6

nixos/modules/programs/nethoscope.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let cfg = config.programs.nethoscope;

     

       6
       4
        
       in

     

       7
       5
        
       {

     

       8
       8
       -
         meta.maintainers = with maintainers; [ _0x4A6F ];

     

       6
       6
       +
         meta.maintainers = with lib.maintainers; [ _0x4A6F ];

     

       9
       7
        
       

     

       10
       8
        
         options = {

     

       11
       9
        
           programs.nethoscope = {

     

       12
       12
       -
             enable = mkOption {

     

       13
       13
       -
               type = types.bool;

     

       10
       10
       +
             enable = lib.mkOption {

     

       11
       11
       +
               type = lib.types.bool;

     

       14
       12
        
               default = false;

     

       15
       13
        
               description = ''

     

       16
       14
        
                 Whether to add nethoscope to the global environment and configure a

     
···

       20
       18
        
           };

     

       21
       19
        
         };

     

       22
       20
        
       

     

       23
       23
       -
         config = mkIf cfg.enable {

     

       21
       21
       +
         config = lib.mkIf cfg.enable {

     

       24
       22
        
           environment.systemPackages = with pkgs; [ nethoscope ];

     

       25
       23
        
           security.wrappers.nethoscope = {

     

       26
       24
        
             source = "${pkgs.nethoscope}/bin/nethoscope";

+11 -12

nixos/modules/programs/nncp.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       3
        
       let

     

       5
       4
        
         nncpCfgFile = "/run/nncp.hjson";

     

       6
       5
        
         programCfg = config.programs.nncp;

     
···

       11
       10
        
         options.programs.nncp = {

     

       12
       11
        
       

     

       13
       12
        
           enable =

     

       14
       14
       -
             mkEnableOption "NNCP (Node to Node copy) utilities and configuration";

     

       13
       13
       +
             lib.mkEnableOption "NNCP (Node to Node copy) utilities and configuration";

     

       15
       14
        
       

     

       16
       16
       -
           group = mkOption {

     

       17
       17
       -
             type = types.str;

     

       15
       15
       +
           group = lib.mkOption {

     

       16
       16
       +
             type = lib.types.str;

     

       18
       17
        
             default = "uucp";

     

       19
       18
        
             description = ''

     

       20
       19
        
               The group under which NNCP files shall be owned.

     
···

       23
       22
        
             '';

     

       24
       23
        
           };

     

       25
       24
        
       

     

       26
       26
       -
           package = mkPackageOption pkgs "nncp" { };

     

       25
       25
       +
           package = lib.mkPackageOption pkgs "nncp" { };

     

       27
       26
        
       

     

       28
       28
       -
           secrets = mkOption {

     

       29
       29
       -
             type = with types; listOf str;

     

       27
       27
       +
           secrets = lib.mkOption {

     

       28
       28
       +
             type = with lib.types; listOf str;

     

       30
       29
        
             example = [ "/run/keys/nncp.hjson" ];

     

       31
       30
        
             description = ''

     

       32
       31
        
               A list of paths to NNCP configuration files that should not be

     
···

       35
       34
        
             '';

     

       36
       35
        
           };

     

       37
       36
        
       

     

       38
       38
       -
           settings = mkOption {

     

       37
       37
       +
           settings = lib.mkOption {

     

       39
       38
        
             type = settingsFormat.type;

     

       40
       39
        
             description = ''

     

       41
       40
        
               NNCP configuration, see

     
···

       52
       51
        
       

     

       53
       52
        
         };

     

       54
       53
        
       

     

       55
       55
       -
         config = mkIf programCfg.enable {

     

       54
       54
       +
         config = lib.mkIf programCfg.enable {

     

       56
       55
        
       

     

       57
       56
        
           environment = {

     

       58
       57
        
             systemPackages = [ pkg ];

     
···

       60
       59
        
           };

     

       61
       60
        
       

     

       62
       61
        
           programs.nncp.settings = {

     

       63
       63
       -
             spool = mkDefault "/var/spool/nncp";

     

       64
       64
       -
             log = mkDefault "/var/spool/nncp/log";

     

       62
       62
       +
             spool = lib.mkDefault "/var/spool/nncp";

     

       63
       63
       +
             log = lib.mkDefault "/var/spool/nncp/log";

     

       65
       64
        
           };

     

       66
       65
        
       

     

       67
       66
        
           systemd.tmpfiles.rules = [

     
···

       77
       76
        
             script = ''

     

       78
       77
        
               umask u=rw

     

       79
       78
        
               nncpCfgDir=$(mktemp --directory nncp.XXX)

     

       80
       80
       -
               for f in ${jsonCfgFile} ${toString config.programs.nncp.secrets}; do

     

       79
       79
       +
               for f in ${jsonCfgFile} ${builtins.toString config.programs.nncp.secrets}; do

     

       81
       80
        
                 tmpdir=$(mktemp --directory nncp.XXX)

     

       82
       81
        
                 nncp-cfgdir -cfg $f -dump $tmpdir

     

       83
       82
        
                 find $tmpdir -size 1c -delete

+3 -5

nixos/modules/programs/noisetorch.nix

···

       1
       1
        
       { config, pkgs, lib, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let cfg = config.programs.noisetorch;

     

       6
       4
        
       in

     

       7
       5
        
       {

     

       8
       6
        
         options.programs.noisetorch = {

     

       9
       9
       -
           enable = mkEnableOption "noisetorch (+ setcap wrapper), a virtual microphone device with noise suppression";

     

       7
       7
       +
           enable = lib.mkEnableOption "noisetorch (+ setcap wrapper), a virtual microphone device with noise suppression";

     

       10
       8
        
       

     

       11
       11
       -
           package = mkPackageOption pkgs "noisetorch" { };

     

       9
       9
       +
           package = lib.mkPackageOption pkgs "noisetorch" { };

     

       12
       10
        
         };

     

       13
       11
        
       

     

       14
       14
       -
         config = mkIf cfg.enable {

     

       12
       12
       +
         config = lib.mkIf cfg.enable {

     

       15
       13
        
           security.wrappers.noisetorch = {

     

       16
       14
        
             owner = "root";

     

       17
       15
        
             group = "root";

+3 -5

nixos/modules/programs/npm.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.npm;

     

       7
       5
        
       in

     
···

       11
       9
        
       

     

       12
       10
        
         options = {

     

       13
       11
        
           programs.npm = {

     

       14
       14
       -
             enable = mkEnableOption "{command}`npm` global config";

     

       12
       12
       +
             enable = lib.mkEnableOption "{command}`npm` global config";

     

       15
       13
        
       

     

       16
       16
       -
             package = mkPackageOption pkgs [ "nodePackages" "npm" ] {

     

       14
       14
       +
             package = lib.mkPackageOption pkgs [ "nodePackages" "npm" ] {

     

       17
       15
        
               example = "nodePackages_13_x.npm";

     

       18
       16
        
             };

     

       19
       17
        
       

     

       20
       20
       -
             npmrc = mkOption {

     

       18
       18
       +
             npmrc = lib.mkOption {

     

       21
       19
        
               type = lib.types.lines;

     

       22
       20
        
               description = ''

     

       23
       21
        
                 The system-wide npm configuration.

+1 -3

nixos/modules/programs/oblogout.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       {

     

       6
       4
        
       

     

       7
       5
        
         imports = [

     

       8
       8
       -
           (mkRemovedOptionModule [ "programs" "oblogout" ] "programs.oblogout has been removed from NixOS. This is because the oblogout repository has been archived upstream.")

     

       6
       6
       +
           (lib.mkRemovedOptionModule [ "programs" "oblogout" ] "programs.oblogout has been removed from NixOS. This is because the oblogout repository has been archived upstream.")

     

       9
       7
        
         ];

     

       10
       8
        
       

     

       11
       9
        
       }

+5 -7

nixos/modules/programs/openvpn3.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.openvpn3;

     

       7
       5
        
       in

     

       8
       6
        
       {

     

       9
       7
        
         options.programs.openvpn3 = {

     

       10
       10
       -
           enable = mkEnableOption "the openvpn3 client";

     

       11
       11
       -
           package = mkOption {

     

       12
       12
       -
             type = types.package;

     

       8
       8
       +
           enable = lib.mkEnableOption "the openvpn3 client";

     

       9
       9
       +
           package = lib.mkOption {

     

       10
       10
       +
             type = lib.types.package;

     

       13
       11
        
             default = pkgs.openvpn3.override {

     

       14
       12
        
               enableSystemdResolved = config.services.resolved.enable;

     

       15
       13
        
             };

     

       16
       16
       -
             defaultText = literalExpression ''pkgs.openvpn3.override {

     

       14
       14
       +
             defaultText = lib.literalExpression ''pkgs.openvpn3.override {

     

       17
       15
        
               enableSystemdResolved = config.services.resolved.enable;

     

       18
       16
        
             }'';

     

       19
       17
        
             description = ''

     
···

       22
       20
        
           };

     

       23
       21
        
         };

     

       24
       22
        
       

     

       25
       25
       -
         config = mkIf cfg.enable {

     

       23
       23
       +
         config = lib.mkIf cfg.enable {

     

       26
       24
        
           services.dbus.packages = [

     

       27
       25
        
             cfg.package

     

       28
       26
        
           ];

+3 -5

nixos/modules/programs/pantheon-tweaks.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       {

     

       6
       4
        
         meta = {

     

       7
       7
       -
           maintainers = teams.pantheon.members;

     

       5
       5
       +
           maintainers = lib.teams.pantheon.members;

     

       8
       6
        
         };

     

       9
       7
        
       

     

       10
       8
        
         ###### interface

     

       11
       9
        
         options = {

     

       12
       12
       -
           programs.pantheon-tweaks.enable = mkEnableOption "Pantheon Tweaks, an unofficial system settings panel for Pantheon";

     

       10
       10
       +
           programs.pantheon-tweaks.enable = lib.mkEnableOption "Pantheon Tweaks, an unofficial system settings panel for Pantheon";

     

       13
       11
        
         };

     

       14
       12
        
       

     

       15
       13
        
         ###### implementation

     

       16
       16
       -
         config = mkIf config.programs.pantheon-tweaks.enable {

     

       14
       14
       +
         config = lib.mkIf config.programs.pantheon-tweaks.enable {

     

       17
       15
        
           services.xserver.desktopManager.pantheon.extraSwitchboardPlugs = [ pkgs.pantheon-tweaks ];

     

       18
       16
        
         };

     

       19
       17
        
       }

+3 -5

nixos/modules/programs/plotinus.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.plotinus;

     

       7
       5
        
       in

     
···

       15
       13
        
       

     

       16
       14
        
         options = {

     

       17
       15
        
           programs.plotinus = {

     

       18
       18
       -
             enable = mkOption {

     

       16
       16
       +
             enable = lib.mkOption {

     

       19
       17
        
               default = false;

     

       20
       18
        
               description = ''

     

       21
       19
        
                 Whether to enable the Plotinus GTK 3 plugin. Plotinus provides a

     

       22
       20
        
                 popup (triggered by Ctrl-Shift-P) to search the menus of a

     

       23
       21
        
                 compatible application.

     

       24
       22
        
               '';

     

       25
       25
       -
               type = types.bool;

     

       23
       23
       +
               type = lib.types.bool;

     

       26
       24
        
             };

     

       27
       25
        
           };

     

       28
       26
        
         };

     

       29
       27
        
       

     

       30
       28
        
         ###### implementation

     

       31
       29
        
       

     

       32
       32
       -
         config = mkIf cfg.enable {

     

       30
       30
       +
         config = lib.mkIf cfg.enable {

     

       33
       31
        
           environment.sessionVariables.XDG_DATA_DIRS = [ "${pkgs.plotinus}/share/gsettings-schemas/${pkgs.plotinus.name}" ];

     

       34
       32
        
           environment.variables.GTK3_MODULES = [ "${pkgs.plotinus}/lib/libplotinus.so" ];

     

       35
       33
        
         };

+35 -36

nixos/modules/programs/proxychains.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
       -
       with lib;

     

       3
       2
        
       let

     

       4
       3
        
       

     

       5
       4
        
         cfg = config.programs.proxychains;

     

       6
       5
        
       

     

       7
       6
        
         configFile = ''

     

       8
       7
        
           ${cfg.chain.type}_chain

     

       9
       9
       -
           ${optionalString (cfg.chain.type == "random")

     

       8
       8
       +
           ${lib.optionalString (cfg.chain.type == "random")

     

       10
       9
        
           "chain_len = ${builtins.toString cfg.chain.length}"}

     

       11
       11
       -
           ${optionalString cfg.proxyDNS "proxy_dns"}

     

       12
       12
       -
           ${optionalString cfg.quietMode "quiet_mode"}

     

       10
       10
       +
           ${lib.optionalString cfg.proxyDNS "proxy_dns"}

     

       11
       11
       +
           ${lib.optionalString cfg.quietMode "quiet_mode"}

     

       13
       12
        
           remote_dns_subnet ${builtins.toString cfg.remoteDNSSubnet}

     

       14
       13
        
           tcp_read_time_out ${builtins.toString cfg.tcpReadTimeOut}

     

       15
       14
        
           tcp_connect_time_out ${builtins.toString cfg.tcpConnectTimeOut}

     
···

       22
       21
        
       

     

       23
       22
        
         proxyOptions = {

     

       24
       23
        
           options = {

     

       25
       25
       -
             enable = mkEnableOption "this proxy";

     

       24
       24
       +
             enable = lib.mkEnableOption "this proxy";

     

       26
       25
        
       

     

       27
       27
       -
             type = mkOption {

     

       28
       28
       -
               type = types.enum [ "http" "socks4" "socks5" ];

     

       26
       26
       +
             type = lib.mkOption {

     

       27
       27
       +
               type = lib.types.enum [ "http" "socks4" "socks5" ];

     

       29
       28
        
               description = "Proxy type.";

     

       30
       29
        
             };

     

       31
       30
        
       

     

       32
       32
       -
             host = mkOption {

     

       33
       33
       -
               type = types.str;

     

       31
       31
       +
             host = lib.mkOption {

     

       32
       32
       +
               type = lib.types.str;

     

       34
       33
        
               description = "Proxy host or IP address.";

     

       35
       34
        
             };

     

       36
       35
        
       

     

       37
       37
       -
             port = mkOption {

     

       38
       38
       -
               type = types.port;

     

       36
       36
       +
             port = lib.mkOption {

     

       37
       37
       +
               type = lib.types.port;

     

       39
       38
        
               description = "Proxy port";

     

       40
       39
        
             };

     

       41
       40
        
           };

     
···

       49
       48
        
       

     

       50
       49
        
           programs.proxychains = {

     

       51
       50
        
       

     

       52
       52
       -
             enable = mkEnableOption "proxychains configuration";

     

       51
       51
       +
             enable = lib.mkEnableOption "proxychains configuration";

     

       53
       52
        
       

     

       54
       54
       -
             package = mkPackageOption pkgs "proxychains" {

     

       53
       53
       +
             package = lib.mkPackageOption pkgs "proxychains" {

     

       55
       54
        
               example = "proxychains-ng";

     

       56
       55
        
             };

     

       57
       56
        
       

     

       58
       57
        
             chain = {

     

       59
       59
       -
               type = mkOption {

     

       60
       60
       -
                 type = types.enum [ "dynamic" "strict" "random" ];

     

       58
       58
       +
               type = lib.mkOption {

     

       59
       59
       +
                 type = lib.types.enum [ "dynamic" "strict" "random" ];

     

       61
       60
        
                 default = "strict";

     

       62
       61
        
                 description = ''

     

       63
       62
        
                   `dynamic` - Each connection will be done via chained proxies

     
···

       75
       74
        
                   (or proxy chain, see {option}`programs.proxychains.chain.length`) from the list.

     

       76
       75
        
                 '';

     

       77
       76
        
               };

     

       78
       78
       -
               length = mkOption {

     

       79
       79
       -
                 type = types.nullOr types.int;

     

       77
       77
       +
               length = lib.mkOption {

     

       78
       78
       +
                 type = lib.types.nullOr lib.types.int;

     

       80
       79
        
                 default = null;

     

       81
       80
        
                 description = ''

     

       82
       81
        
                   Chain length for random chain.

     
···

       84
       83
        
               };

     

       85
       84
        
             };

     

       86
       85
        
       

     

       87
       87
       -
             proxyDNS = mkOption {

     

       88
       88
       -
               type = types.bool;

     

       86
       86
       +
             proxyDNS = lib.mkOption {

     

       87
       87
       +
               type = lib.types.bool;

     

       89
       88
        
               default = true;

     

       90
       89
        
               description = "Proxy DNS requests - no leak for DNS data.";

     

       91
       90
        
             };

     

       92
       91
        
       

     

       93
       93
       -
             quietMode = mkEnableOption "Quiet mode (no output from the library)";

     

       92
       92
       +
             quietMode = lib.mkEnableOption "Quiet mode (no output from the library)";

     

       94
       93
        
       

     

       95
       95
       -
             remoteDNSSubnet = mkOption {

     

       96
       96
       -
               type = types.enum [ 10 127 224 ];

     

       94
       94
       +
             remoteDNSSubnet = lib.mkOption {

     

       95
       95
       +
               type = lib.types.enum [ 10 127 224 ];

     

       97
       96
        
               default = 224;

     

       98
       97
        
               description = ''

     

       99
       98
        
                 Set the class A subnet number to use for the internal remote DNS mapping, uses the reserved 224.x.x.x range by default.

     

       100
       99
        
               '';

     

       101
       100
        
             };

     

       102
       101
        
       

     

       103
       103
       -
             tcpReadTimeOut = mkOption {

     

       104
       104
       -
               type = types.int;

     

       102
       102
       +
             tcpReadTimeOut = lib.mkOption {

     

       103
       103
       +
               type = lib.types.int;

     

       105
       104
        
               default = 15000;

     

       106
       105
        
               description = "Connection read time-out in milliseconds.";

     

       107
       106
        
             };

     

       108
       107
        
       

     

       109
       109
       -
             tcpConnectTimeOut = mkOption {

     

       110
       110
       -
               type = types.int;

     

       108
       108
       +
             tcpConnectTimeOut = lib.mkOption {

     

       109
       109
       +
               type = lib.types.int;

     

       111
       110
        
               default = 8000;

     

       112
       111
        
               description = "Connection time-out in milliseconds.";

     

       113
       112
        
             };

     

       114
       113
        
       

     

       115
       115
       -
             localnet = mkOption {

     

       116
       116
       -
               type = types.str;

     

       114
       114
       +
             localnet = lib.mkOption {

     

       115
       115
       +
               type = lib.types.str;

     

       117
       116
        
               default = "127.0.0.0/255.0.0.0";

     

       118
       117
        
               description = "By default enable localnet for loopback address ranges.";

     

       119
       118
        
             };

     

       120
       119
        
       

     

       121
       121
       -
             proxies = mkOption {

     

       122
       122
       -
               type = types.attrsOf (types.submodule proxyOptions);

     

       120
       120
       +
             proxies = lib.mkOption {

     

       121
       121
       +
               type = lib.types.attrsOf (lib.types.submodule proxyOptions);

     

       123
       122
        
               description = ''

     

       124
       123
        
                 Proxies to be used by proxychains.

     

       125
       124
        
               '';

     

       126
       125
        
       

     

       127
       127
       -
               example = literalExpression ''

     

       126
       126
       +
               example = lib.literalExpression ''

     

       128
       127
        
                 { myproxy =

     

       129
       128
        
                   { type = "socks4";

     

       130
       129
        
                     host = "127.0.0.1";

     
···

       140
       139
        
       

     

       141
       140
        
         ###### implementation

     

       142
       141
        
       

     

       143
       143
       -
         meta.maintainers = with maintainers; [ sorki ];

     

       142
       142
       +
         meta.maintainers = with lib.maintainers; [ sorki ];

     

       144
       143
        
       

     

       145
       145
       -
         config = mkIf cfg.enable {

     

       144
       144
       +
         config = lib.mkIf cfg.enable {

     

       146
       145
        
       

     

       147
       147
       -
           assertions = singleton {

     

       146
       146
       +
           assertions = lib.singleton {

     

       148
       147
        
             assertion = cfg.chain.type != "random" && cfg.chain.length == null;

     

       149
       148
        
             message = ''

     

       150
       149
        
               Option `programs.proxychains.chain.length`

     
···

       152
       151
        
             '';

     

       153
       152
        
           };

     

       154
       153
        
       

     

       155
       155
       -
           programs.proxychains.proxies = mkIf config.services.tor.client.enable

     

       154
       154
       +
           programs.proxychains.proxies = lib.mkIf config.services.tor.client.enable

     

       156
       155
        
             {

     

       157
       157
       -
               torproxy = mkDefault {

     

       156
       156
       +
               torproxy = lib.mkDefault {

     

       158
       157
        
                 enable = true;

     

       159
       158
        
                 type = "socks4";

     

       160
       159
        
                 host = "127.0.0.1";

+1 -3

nixos/modules/programs/qt5ct.nix

···

       1
       1
        
       { lib, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       {

     

       6
       4
        
         imports = [

     

       7
       7
       -
           (mkRemovedOptionModule [ "programs" "qt5ct" "enable" ] "Use qt5.platformTheme = \"qt5ct\" instead.")

     

       5
       5
       +
           (lib.mkRemovedOptionModule [ "programs" "qt5ct" "enable" ] "Use qt5.platformTheme = \"qt5ct\" instead.")

     

       8
       6
        
         ];

     

       9
       7
        
       }

+16 -18

nixos/modules/programs/rust-motd.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.rust-motd;

     

       7
       5
        
         format = pkgs.formats.toml { };

     
···

       24
       22
        
           '';

     

       25
       23
        
       in {

     

       26
       24
        
         options.programs.rust-motd = {

     

       27
       27
       -
           enable = mkEnableOption "rust-motd, a Message Of The Day (MOTD) generator";

     

       28
       28
       -
           enableMotdInSSHD = mkOption {

     

       25
       25
       +
           enable = lib.mkEnableOption "rust-motd, a Message Of The Day (MOTD) generator";

     

       26
       26
       +
           enableMotdInSSHD = lib.mkOption {

     

       29
       27
        
             default = true;

     

       30
       30
       -
             type = types.bool;

     

       28
       28
       +
             type = lib.types.bool;

     

       31
       29
        
             description = ''

     

       32
       30
        
               Whether to let `openssh` print the

     

       33
       31
        
               result when entering a new `ssh`-session.

     
···

       36
       34
        
               the latter option is incompatible with this module.

     

       37
       35
        
             '';

     

       38
       36
        
           };

     

       39
       39
       -
           refreshInterval = mkOption {

     

       37
       37
       +
           refreshInterval = lib.mkOption {

     

       40
       38
        
             default = "*:0/5";

     

       41
       41
       -
             type = types.str;

     

       39
       39
       +
             type = lib.types.str;

     

       42
       40
        
             description = ''

     

       43
       41
        
               Interval in which the {manpage}`motd(5)` file is refreshed.

     

       44
       42
        
               For possible formats, please refer to {manpage}`systemd.time(7)`.

     

       45
       43
        
             '';

     

       46
       44
        
           };

     

       47
       47
       -
           order = mkOption {

     

       48
       48
       -
             type = types.listOf types.str;

     

       49
       49
       -
             default = attrNames cfg.settings;

     

       50
       50
       -
             defaultText = literalExpression "attrNames cfg.settings";

     

       45
       45
       +
           order = lib.mkOption {

     

       46
       46
       +
             type = lib.types.listOf lib.types.str;

     

       47
       47
       +
             default = builtins.attrNames cfg.settings;

     

       48
       48
       +
             defaultText = lib.literalExpression "attrNames cfg.settings";

     

       51
       49
        
             description = ''

     

       52
       50
        
               The order of the sections in [](#opt-programs.rust-motd.settings).

     

       53
       51
        
               By default they are ordered alphabetically.

     
···

       79
       77
        
               makes sure that `uptime` is placed before `banner` in the motd.

     

       80
       78
        
             '';

     

       81
       79
        
           };

     

       82
       82
       -
           settings = mkOption {

     

       83
       83
       -
             type = types.attrsOf format.type;

     

       80
       80
       +
           settings = lib.mkOption {

     

       81
       81
       +
             type = lib.types.attrsOf format.type;

     

       84
       82
        
             description = ''

     

       85
       83
        
               Settings on what to generate. Please read the

     

       86
       84
        
               [upstream documentation](https://github.com/rust-motd/rust-motd/blob/main/README.md#configuration)

     
···

       88
       86
        
             '';

     

       89
       87
        
           };

     

       90
       88
        
         };

     

       91
       91
       -
         config = mkIf cfg.enable {

     

       89
       89
       +
         config = lib.mkIf cfg.enable {

     

       92
       90
        
           assertions = [

     

       93
       91
        
             { assertion = config.users.motd == null;

     

       94
       92
        
               message = ''

     

       95
       93
        
                 `programs.rust-motd` is incompatible with `users.motd`!

     

       96
       94
        
               '';

     

       97
       95
        
             }

     

       98
       98
       -
             { assertion = sort (a: b: a < b) cfg.order == attrNames cfg.settings;

     

       96
       96
       +
             { assertion = builtins.sort (a: b: a < b) cfg.order == builtins.attrNames cfg.settings;

     

       99
       97
        
               message = ''

     

       100
       98
        
                 Please ensure that every section from `programs.rust-motd.settings` is present in

     

       101
       99
        
                 `programs.rust-motd.order`.

     
···

       138
       136
        
             wantedBy = [ "timers.target" ];

     

       139
       137
        
             timerConfig.OnCalendar = cfg.refreshInterval;

     

       140
       138
        
           };

     

       141
       141
       -
           security.pam.services.sshd.text = mkIf cfg.enableMotdInSSHD (mkDefault (mkAfter ''

     

       139
       139
       +
           security.pam.services.sshd.text = lib.mkIf cfg.enableMotdInSSHD (lib.mkDefault (lib.mkAfter ''

     

       142
       140
        
             session optional ${pkgs.pam}/lib/security/pam_motd.so motd=/var/lib/rust-motd/motd

     

       143
       141
        
           ''));

     

       144
       144
       -
           services.openssh.extraConfig = mkIf (cfg.settings ? last_login && cfg.settings.last_login != {}) ''

     

       142
       142
       +
           services.openssh.extraConfig = lib.mkIf (cfg.settings ? last_login && cfg.settings.last_login != {}) ''

     

       145
       143
        
             PrintLastLog no

     

       146
       144
        
           '';

     

       147
       145
        
         };

     

       148
       148
       -
         meta.maintainers = with maintainers; [ ma27 ];

     

       146
       146
       +
         meta.maintainers = with lib.maintainers; [ ma27 ];

     

       149
       147
        
       }

+2 -4

nixos/modules/programs/sedutil.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.sedutil;

     

       7
       5
        
       

     

       8
       6
        
       in {

     

       9
       9
       -
         options.programs.sedutil.enable = mkEnableOption "sedutil, to manage self encrypting drives that conform to the Trusted Computing Group OPAL 2.0 SSC specification";

     

       7
       7
       +
         options.programs.sedutil.enable = lib.mkEnableOption "sedutil, to manage self encrypting drives that conform to the Trusted Computing Group OPAL 2.0 SSC specification";

     

       10
       8
        
       

     

       11
       11
       -
         config = mkIf cfg.enable {

     

       9
       9
       +
         config = lib.mkIf cfg.enable {

     

       12
       10
        
           boot.kernelParams = [

     

       13
       11
        
             "libata.allow_tpm=1"

     

       14
       12
        
           ];

+26 -27

nixos/modules/programs/shadow.nix

···

       1
       1
        
       # Configuration for the pwdutils suite of tools: passwd, useradd, etc.

     

       2
       2
        
       { config, lib, utils, pkgs, ... }:

     

       3
       3
       -
       with lib;

     

       4
       3
        
       let

     

       5
       4
        
         cfg = config.security.loginDefs;

     

       6
       5
        
       in

     

       7
       6
        
       {

     

       8
       8
       -
         options = with types; {

     

       7
       7
       +
         options = with lib.types; {

     

       9
       8
        
           security.loginDefs = {

     

       10
       10
       -
             package = mkPackageOption pkgs "shadow" { };

     

       9
       9
       +
             package = lib.mkPackageOption pkgs "shadow" { };

     

       11
       10
        
       

     

       12
       12
       -
             chfnRestrict = mkOption {

     

       11
       11
       +
             chfnRestrict = lib.mkOption {

     

       13
       12
        
               description = ''

     

       14
       13
        
                 Use chfn SUID to allow non-root users to change their account GECOS information.

     

       15
       14
        
               '';

     
···

       17
       16
        
               default = null;

     

       18
       17
        
             };

     

       19
       18
        
       

     

       20
       20
       -
             settings = mkOption {

     

       19
       19
       +
             settings = lib.mkOption {

     

       21
       20
        
               description = ''

     

       22
       21
        
                 Config options for the /etc/login.defs file, that defines

     

       23
       22
        
                 the site-specific configuration for the shadow password suite.

     
···

       35
       34
        
                      by systemd for features like ConditionUser=@system and systemd-sysusers

     

       36
       35
        
                     */

     

       37
       36
        
                 options = {

     

       38
       38
       -
                   DEFAULT_HOME = mkOption {

     

       37
       37
       +
                   DEFAULT_HOME = lib.mkOption {

     

       39
       38
        
                     description = "Indicate if login is allowed if we can't cd to the home directory.";

     

       40
       39
        
                     default = "yes";

     

       41
       40
        
                     type = enum [ "yes" "no" ];

     

       42
       41
        
                   };

     

       43
       42
        
       

     

       44
       44
       -
                   ENCRYPT_METHOD = mkOption {

     

       43
       43
       +
                   ENCRYPT_METHOD = lib.mkOption {

     

       45
       44
        
                     description = "This defines the system default encryption algorithm for encrypting passwords.";

     

       46
       45
        
                     # The default crypt() method, keep in sync with the PAM default

     

       47
       46
        
                     default = "YESCRYPT";

     

       48
       47
        
                     type = enum [ "YESCRYPT" "SHA512" "SHA256" "MD5" "DES"];

     

       49
       48
        
                   };

     

       50
       49
        
       

     

       51
       51
       -
                   SYS_UID_MIN = mkOption {

     

       50
       50
       +
                   SYS_UID_MIN = lib.mkOption {

     

       52
       51
        
                     description = "Range of user IDs used for the creation of system users by useradd or newusers.";

     

       53
       52
        
                     default = 400;

     

       54
       53
        
                     type = int;

     

       55
       54
        
                   };

     

       56
       55
        
       

     

       57
       57
       -
                   SYS_UID_MAX = mkOption {

     

       56
       56
       +
                   SYS_UID_MAX = lib.mkOption {

     

       58
       57
        
                     description = "Range of user IDs used for the creation of system users by useradd or newusers.";

     

       59
       58
        
                     default = 999;

     

       60
       59
        
                     type = int;

     

       61
       60
        
                   };

     

       62
       61
        
       

     

       63
       63
       -
                   UID_MIN = mkOption {

     

       62
       62
       +
                   UID_MIN = lib.mkOption {

     

       64
       63
        
                     description = "Range of user IDs used for the creation of regular users by useradd or newusers.";

     

       65
       64
        
                     default = 1000;

     

       66
       65
        
                     type = int;

     

       67
       66
        
                   };

     

       68
       67
        
       

     

       69
       69
       -
                   UID_MAX = mkOption {

     

       68
       68
       +
                   UID_MAX = lib.mkOption {

     

       70
       69
        
                     description = "Range of user IDs used for the creation of regular users by useradd or newusers.";

     

       71
       70
        
                     default = 29999;

     

       72
       71
        
                     type = int;

     

       73
       72
        
                   };

     

       74
       73
        
       

     

       75
       75
       -
                   SYS_GID_MIN = mkOption {

     

       74
       74
       +
                   SYS_GID_MIN = lib.mkOption {

     

       76
       75
        
                     description = "Range of group IDs used for the creation of system groups by useradd, groupadd, or newusers";

     

       77
       76
        
                     default = 400;

     

       78
       77
        
                     type = int;

     

       79
       78
        
                   };

     

       80
       79
        
       

     

       81
       81
       -
                   SYS_GID_MAX = mkOption {

     

       80
       80
       +
                   SYS_GID_MAX = lib.mkOption {

     

       82
       81
        
                     description = "Range of group IDs used for the creation of system groups by useradd, groupadd, or newusers";

     

       83
       82
        
                     default = 999;

     

       84
       83
        
                     type = int;

     

       85
       84
        
                   };

     

       86
       85
        
       

     

       87
       87
       -
                   GID_MIN = mkOption {

     

       86
       86
       +
                   GID_MIN = lib.mkOption {

     

       88
       87
        
                     description = "Range of group IDs used for the creation of regular groups by useradd, groupadd, or newusers.";

     

       89
       88
        
                     default = 1000;

     

       90
       89
        
                     type = int;

     

       91
       90
        
                   };

     

       92
       91
        
       

     

       93
       93
       -
                   GID_MAX = mkOption {

     

       92
       92
       +
                   GID_MAX = lib.mkOption {

     

       94
       93
        
                     description = "Range of group IDs used for the creation of regular groups by useradd, groupadd, or newusers.";

     

       95
       94
        
                     default = 29999;

     

       96
       95
        
                     type = int;

     

       97
       96
        
                   };

     

       98
       97
        
       

     

       99
       99
       -
                   TTYGROUP = mkOption {

     

       98
       98
       +
                   TTYGROUP = lib.mkOption {

     

       100
       99
        
                     description = ''

     

       101
       100
        
                       The terminal permissions: the login tty will be owned by the TTYGROUP group,

     

       102
       101
        
                       and the permissions will be set to TTYPERM'';

     
···

       104
       103
        
                     type = str;

     

       105
       104
        
                   };

     

       106
       105
        
       

     

       107
       107
       -
                   TTYPERM = mkOption {

     

       106
       106
       +
                   TTYPERM = lib.mkOption {

     

       108
       107
        
                     description = ''

     

       109
       108
        
                       The terminal permissions: the login tty will be owned by the TTYGROUP group,

     

       110
       109
        
                       and the permissions will be set to TTYPERM'';

     
···

       113
       112
        
                   };

     

       114
       113
        
       

     

       115
       114
        
                   # Ensure privacy for newly created home directories.

     

       116
       116
       -
                   UMASK = mkOption {

     

       115
       115
       +
                   UMASK = lib.mkOption {

     

       117
       116
        
                     description = "The file mode creation mask is initialized to this value.";

     

       118
       117
        
                     default = "077";

     

       119
       118
        
                     type = str;

     
···

       124
       123
        
             };

     

       125
       124
        
           };

     

       126
       125
        
       

     

       127
       127
       -
           users.defaultUserShell = mkOption {

     

       126
       126
       +
           users.defaultUserShell = lib.mkOption {

     

       128
       127
        
             description = ''

     

       129
       128
        
               This option defines the default shell assigned to user

     

       130
       129
        
               accounts. This can be either a full system path or a shell package.

     
···

       132
       131
        
               This must not be a store path, since the path is

     

       133
       132
        
               used outside the store (in particular in /etc/passwd).

     

       134
       133
        
             '';

     

       135
       135
       -
             example = literalExpression "pkgs.zsh";

     

       134
       134
       +
             example = lib.literalExpression "pkgs.zsh";

     

       136
       135
        
             type = either path shellPackage;

     

       137
       136
        
           };

     

       138
       137
        
         };

     
···

       160
       159
        
           ];

     

       161
       160
        
       

     

       162
       161
        
           security.loginDefs.settings.CHFN_RESTRICT =

     

       163
       163
       -
             mkIf (cfg.chfnRestrict != null) cfg.chfnRestrict;

     

       162
       162
       +
             lib.mkIf (cfg.chfnRestrict != null) cfg.chfnRestrict;

     

       164
       163
        
       

     

       165
       165
       -
           environment.systemPackages = optional config.users.mutableUsers cfg.package

     

       166
       166
       -
             ++ optional (types.shellPackage.check config.users.defaultUserShell) config.users.defaultUserShell

     

       167
       167
       -
             ++ optional (cfg.chfnRestrict != null) pkgs.util-linux;

     

       164
       164
       +
           environment.systemPackages = lib.optional config.users.mutableUsers cfg.package

     

       165
       165
       +
             ++ lib.optional (lib.types.shellPackage.check config.users.defaultUserShell) config.users.defaultUserShell

     

       166
       166
       +
             ++ lib.optional (cfg.chfnRestrict != null) pkgs.util-linux;

     

       168
       167
        
       

     

       169
       168
        
           environment.etc =

     

       170
       169
        
             # Create custom toKeyValue generator

     

       171
       170
        
             # see https://man7.org/linux/man-pages/man5/login.defs.5.html for config specification

     

       172
       171
        
             let

     

       173
       173
       -
               toKeyValue = generators.toKeyValue {

     

       174
       174
       -
                 mkKeyValue = generators.mkKeyValueDefault { } " ";

     

       172
       172
       +
               toKeyValue = lib.generators.toKeyValue {

     

       173
       173
       +
                 mkKeyValue = lib.generators.mkKeyValueDefault { } " ";

     

       175
       174
        
               };

     

       176
       175
        
             in

     

       177
       176
        
             {

     
···

       231
       230
        
               newuidmap = mkSetuidRoot "${cfg.package.out}/bin/newuidmap";

     

       232
       231
        
               newgidmap = mkSetuidRoot "${cfg.package.out}/bin/newgidmap";

     

       233
       232
        
             }

     

       234
       234
       -
             // optionalAttrs config.users.mutableUsers {

     

       233
       233
       +
             // lib.optionalAttrs config.users.mutableUsers {

     

       235
       234
        
               chsh = mkSetuidRoot "${cfg.package.out}/bin/chsh";

     

       236
       235
        
               passwd = mkSetuidRoot "${cfg.package.out}/bin/passwd";

     

       237
       236
        
             };

+17 -18

nixos/modules/programs/singularity.nix

···

       5
       5
        
         ...

     

       6
       6
        
       }:

     

       7
       7
        
       

     

       8
       8
       -
       with lib;

     

       9
       8
        
       let

     

       10
       9
        
         cfg = config.programs.singularity;

     

       11
       10
        
       in

     

       12
       11
        
       {

     

       13
       12
        
       

     

       14
       13
        
         options.programs.singularity = {

     

       15
       15
       -
           enable = mkEnableOption "singularity" // {

     

       14
       14
       +
           enable = lib.mkEnableOption "singularity" // {

     

       16
       15
        
             description = ''

     

       17
       16
        
               Whether to install Singularity/Apptainer with system-level overriding such as SUID support.

     

       18
       17
        
             '';

     

       19
       18
        
           };

     

       20
       20
       -
           package = mkPackageOption pkgs "singularity" { example = "apptainer"; };

     

       21
       21
       -
           packageOverriden = mkOption {

     

       22
       22
       -
             type = types.nullOr types.package;

     

       19
       19
       +
           package = lib.mkPackageOption pkgs "singularity" { example = "apptainer"; };

     

       20
       20
       +
           packageOverriden = lib.mkOption {

     

       21
       21
       +
             type = lib.types.nullOr lib.types.package;

     

       23
       22
        
             default = null;

     

       24
       23
        
             description = ''

     

       25
       24
        
               This option provides access to the overridden result of `programs.singularity.package`.

     
···

       42
       41
        
               Use `lib.mkForce` to forcefully specify the overridden package.

     

       43
       42
        
             '';

     

       44
       43
        
           };

     

       45
       45
       -
           enableExternalLocalStateDir = mkOption {

     

       46
       46
       -
             type = types.bool;

     

       44
       44
       +
           enableExternalLocalStateDir = lib.mkOption {

     

       45
       45
       +
             type = lib.types.bool;

     

       47
       46
        
             default = true;

     

       48
       47
        
             example = false;

     

       49
       48
        
             description = ''

     
···

       54
       53
        
               `/var/lib/''${projectName}/mnt/session`.

     

       55
       54
        
             '';

     

       56
       55
        
           };

     

       57
       57
       -
           enableFakeroot = mkOption {

     

       58
       58
       -
             type = types.bool;

     

       56
       56
       +
           enableFakeroot = lib.mkOption {

     

       57
       57
       +
             type = lib.types.bool;

     

       59
       58
        
             default = true;

     

       60
       59
        
             example = false;

     

       61
       60
        
             description = ''

     

       62
       61
        
               Whether to enable the `--fakeroot` support of Singularity/Apptainer.

     

       63
       62
        
             '';

     

       64
       63
        
           };

     

       65
       65
       -
           enableSuid = mkOption {

     

       66
       66
       -
             type = types.bool;

     

       64
       64
       +
           enableSuid = lib.mkOption {

     

       65
       65
       +
             type = lib.types.bool;

     

       67
       66
        
             # SingularityCE requires SETUID for most things. Apptainer prefers user

     

       68
       67
        
             # namespaces, e.g. `apptainer exec --nv` would fail if built

     

       69
       68
        
             # `--with-suid`:

     

       70
       69
        
             # > `FATAL: nvidia-container-cli not allowed in setuid mode`

     

       71
       70
        
             default = cfg.package.projectName != "apptainer";

     

       72
       72
       -
             defaultText = literalExpression ''config.services.singularity.package.projectName != "apptainer"'';

     

       71
       71
       +
             defaultText = lib.literalExpression ''config.services.singularity.package.projectName != "apptainer"'';

     

       73
       72
        
             example = false;

     

       74
       73
        
             description = ''

     

       75
       74
        
               Whether to enable the SUID support of Singularity/Apptainer.

     
···

       77
       76
        
           };

     

       78
       77
        
         };

     

       79
       78
        
       

     

       80
       80
       -
         config = mkIf cfg.enable {

     

       79
       79
       +
         config = lib.mkIf cfg.enable {

     

       81
       80
        
           programs.singularity.packageOverriden = (

     

       82
       81
        
             cfg.package.override (

     

       83
       83
       -
               optionalAttrs cfg.enableExternalLocalStateDir { externalLocalStateDir = "/var/lib"; }

     

       84
       84
       -
               // optionalAttrs cfg.enableFakeroot {

     

       82
       82
       +
               lib.optionalAttrs cfg.enableExternalLocalStateDir { externalLocalStateDir = "/var/lib"; }

     

       83
       83
       +
               // lib.optionalAttrs cfg.enableFakeroot {

     

       85
       84
        
                 newuidmapPath = "/run/wrappers/bin/newuidmap";

     

       86
       85
        
                 newgidmapPath = "/run/wrappers/bin/newgidmap";

     

       87
       86
        
               }

     

       88
       88
       -
               // optionalAttrs cfg.enableSuid {

     

       87
       87
       +
               // lib.optionalAttrs cfg.enableSuid {

     

       89
       88
        
                 enableSuid = true;

     

       90
       89
        
                 starterSuidPath = "/run/wrappers/bin/${cfg.package.projectName}-suid";

     

       91
       90
        
               }

     

       92
       91
        
             )

     

       93
       92
        
           );

     

       94
       93
        
           environment.systemPackages = [ cfg.packageOverriden ];

     

       95
       95
       -
           security.wrappers."${cfg.packageOverriden.projectName}-suid" = mkIf cfg.enableSuid {

     

       94
       94
       +
           security.wrappers."${cfg.packageOverriden.projectName}-suid" = lib.mkIf cfg.enableSuid {

     

       96
       95
        
             setuid = true;

     

       97
       96
        
             owner = "root";

     

       98
       97
        
             group = "root";

     

       99
       98
        
             source = "${cfg.packageOverriden}/libexec/${cfg.packageOverriden.projectName}/bin/starter-suid.orig";

     

       100
       99
        
           };

     

       101
       101
       -
           systemd.tmpfiles.rules = mkIf cfg.enableExternalLocalStateDir [

     

       100
       100
       +
           systemd.tmpfiles.rules = lib.mkIf cfg.enableExternalLocalStateDir [

     

       102
       101
        
             "d /var/lib/${cfg.packageOverriden.projectName}/mnt/session 0770 root root -"

     

       103
       102
        
           ];

     

       104
       103
        
         };

+4 -6

nixos/modules/programs/slock.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.slock;

     

       7
       5
        
       

     
···

       9
       7
        
       {

     

       10
       8
        
         options = {

     

       11
       9
        
           programs.slock = {

     

       12
       12
       -
             enable = mkOption {

     

       10
       10
       +
             enable = lib.mkOption {

     

       13
       11
        
               default = false;

     

       14
       14
       -
               type = types.bool;

     

       12
       12
       +
               type = lib.types.bool;

     

       15
       13
        
               description = ''

     

       16
       14
        
                 Whether to install slock screen locker with setuid wrapper.

     

       17
       15
        
               '';

     

       18
       16
        
             };

     

       19
       19
       -
             package = mkPackageOption pkgs "slock" {};

     

       17
       17
       +
             package = lib.mkPackageOption pkgs "slock" {};

     

       20
       18
        
           };

     

       21
       19
        
         };

     

       22
       20
        
       

     

       23
       23
       -
         config = mkIf cfg.enable {

     

       21
       21
       +
         config = lib.mkIf cfg.enable {

     

       24
       22
        
           environment.systemPackages = [ cfg.package ];

     

       25
       23
        
           security.wrappers.slock =

     

       26
       24
        
             { setuid = true;

+4 -6

nixos/modules/programs/soundmodem.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.soundmodem;

     

       7
       5
        
       in

     

       8
       6
        
       {

     

       9
       7
        
         options = {

     

       10
       8
        
           programs.soundmodem = {

     

       11
       11
       -
             enable = mkOption {

     

       12
       12
       -
               type = types.bool;

     

       9
       9
       +
             enable = lib.mkOption {

     

       10
       10
       +
               type = lib.types.bool;

     

       13
       11
        
               default = false;

     

       14
       12
        
               description = ''

     

       15
       13
        
                 Whether to add Soundmodem to the global environment and configure a

     

       16
       14
        
                 wrapper for 'soundmodemconfig' for users in the 'soundmodem' group.

     

       17
       15
        
               '';

     

       18
       16
        
             };

     

       19
       19
       -
             package = mkPackageOption pkgs "soundmodem" { };

     

       17
       17
       +
             package = lib.mkPackageOption pkgs "soundmodem" { };

     

       20
       18
        
           };

     

       21
       19
        
         };

     

       22
       20
        
       

     

       23
       23
       -
         config = mkIf cfg.enable {

     

       21
       21
       +
         config = lib.mkIf cfg.enable {

     

       24
       22
        
           environment.systemPackages = [ cfg.package ];

     

       25
       23
        
           users.groups.soundmodem = { };

     

       26
       24

+7 -9

nixos/modules/programs/spacefm.nix

···

       2
       2
        
       

     

       3
       3
        
       { config, lib, pkgs, ... }:

     

       4
       4
        
       

     

       5
       5
       -
       with lib;

     

       6
       6
       -
       

     

       7
       5
        
       let cfg = config.programs.spacefm;

     

       8
       6
        
       

     

       9
       7
        
       in

     
···

       14
       12
        
       

     

       15
       13
        
           programs.spacefm = {

     

       16
       14
        
       

     

       17
       17
       -
             enable = mkOption {

     

       18
       18
       -
               type = types.bool;

     

       15
       15
       +
             enable = lib.mkOption {

     

       16
       16
       +
               type = lib.types.bool;

     

       19
       17
        
               default = false;

     

       20
       18
        
               description = ''

     

       21
       19
        
                 Whether to install SpaceFM and create {file}`/etc/spacefm/spacefm.conf`.

     

       22
       20
        
               '';

     

       23
       21
        
             };

     

       24
       22
        
       

     

       25
       25
       -
             settings = mkOption {

     

       26
       26
       -
               type = types.attrs;

     

       23
       23
       +
             settings = lib.mkOption {

     

       24
       24
       +
               type = lib.types.attrs;

     

       27
       25
        
               default = {

     

       28
       26
        
                 tmp_dir = "/tmp";

     

       29
       27
        
                 terminal_su = "${pkgs.sudo}/bin/sudo";

     

       30
       28
        
               };

     

       31
       31
       -
               defaultText = literalExpression ''

     

       29
       29
       +
               defaultText = lib.literalExpression ''

     

       32
       30
        
                 {

     

       33
       31
        
                   tmp_dir = "/tmp";

     

       34
       32
        
                   terminal_su = "''${pkgs.sudo}/bin/sudo";

     
···

       46
       44
        
       

     

       47
       45
        
         ###### implementation

     

       48
       46
        
       

     

       49
       49
       -
         config = mkIf cfg.enable {

     

       47
       47
       +
         config = lib.mkIf cfg.enable {

     

       50
       48
        
           environment.systemPackages = [ pkgs.spaceFM ];

     

       51
       49
        
       

     

       52
       50
        
           environment.etc."spacefm/spacefm.conf".text =

     

       53
       53
       -
             concatStrings (mapAttrsToList (n: v: "${n}=${toString v}\n") cfg.settings);

     

       51
       51
       +
             lib.concatStrings (lib.mapAttrsToList (n: v: "${n}=${builtins.toString v}\n") cfg.settings);

     

       54
       52
        
         };

     

       55
       53
        
       }

+67 -69

nixos/modules/programs/ssh.nix

···

       2
       2
        
       

     

       3
       3
        
       { config, lib, pkgs, ... }:

     

       4
       4
        
       

     

       5
       5
       -
       with lib;

     

       6
       6
       -
       

     

       7
       5
        
       let

     

       8
       6
        
       

     

       9
       7
        
         cfg  = config.programs.ssh;

     
···

       17
       15
        
             exec ${cfg.askPassword} "$@"

     

       18
       16
        
           '';

     

       19
       17
        
       

     

       20
       20
       -
         knownHosts = attrValues cfg.knownHosts;

     

       18
       18
       +
         knownHosts = builtins.attrValues cfg.knownHosts;

     

       21
       19
        
       

     

       22
       22
       -
         knownHostsText = (flip (concatMapStringsSep "\n") knownHosts

     

       20
       20
       +
         knownHostsText = (lib.flip (lib.concatMapStringsSep "\n") knownHosts

     

       23
       21
        
           (h: assert h.hostNames != [];

     

       24
       24
       -
             optionalString h.certAuthority "@cert-authority " + concatStringsSep "," h.hostNames + " "

     

       25
       25
       -
             + (if h.publicKey != null then h.publicKey else readFile h.publicKeyFile)

     

       22
       22
       +
             lib.optionalString h.certAuthority "@cert-authority " + builtins.concatStringsSep "," h.hostNames + " "

     

       23
       23
       +
             + (if h.publicKey != null then h.publicKey else builtins.readFile h.publicKeyFile)

     

       26
       24
        
           )) + "\n";

     

       27
       25
        
       

     

       28
       26
        
         knownHostsFiles = [ "/etc/ssh/ssh_known_hosts" ]

     

       29
       29
       -
           ++ map pkgs.copyPathToStore cfg.knownHostsFiles;

     

       27
       27
       +
           ++ builtins.map pkgs.copyPathToStore cfg.knownHostsFiles;

     

       30
       28
        
       

     

       31
       29
        
       in

     

       32
       30
        
       {

     
···

       36
       34
        
       

     

       37
       35
        
           programs.ssh = {

     

       38
       36
        
       

     

       39
       39
       -
             enableAskPassword = mkOption {

     

       40
       40
       -
               type = types.bool;

     

       37
       37
       +
             enableAskPassword = lib.mkOption {

     

       38
       38
       +
               type = lib.types.bool;

     

       41
       39
        
               default = config.services.xserver.enable;

     

       42
       42
       -
               defaultText = literalExpression "config.services.xserver.enable";

     

       40
       40
       +
               defaultText = lib.literalExpression "config.services.xserver.enable";

     

       43
       41
        
               description = "Whether to configure SSH_ASKPASS in the environment.";

     

       44
       42
        
             };

     

       45
       43
        
       

     

       46
       46
       -
             askPassword = mkOption {

     

       47
       47
       -
               type = types.str;

     

       44
       44
       +
             askPassword = lib.mkOption {

     

       45
       45
       +
               type = lib.types.str;

     

       48
       46
        
               default = "${pkgs.x11_ssh_askpass}/libexec/x11-ssh-askpass";

     

       49
       49
       -
               defaultText = literalExpression ''"''${pkgs.x11_ssh_askpass}/libexec/x11-ssh-askpass"'';

     

       47
       47
       +
               defaultText = lib.literalExpression ''"''${pkgs.x11_ssh_askpass}/libexec/x11-ssh-askpass"'';

     

       50
       48
        
               description = "Program used by SSH to ask for passwords.";

     

       51
       49
        
             };

     

       52
       50
        
       

     

       53
       53
       -
             forwardX11 = mkOption {

     

       51
       51
       +
             forwardX11 = lib.mkOption {

     

       54
       52
        
               type = with lib.types; nullOr bool;

     

       55
       53
        
               default = false;

     

       56
       54
        
               description = ''

     
···

       65
       63
        
               '';

     

       66
       64
        
             };

     

       67
       65
        
       

     

       68
       68
       -
             setXAuthLocation = mkOption {

     

       69
       69
       -
               type = types.bool;

     

       66
       66
       +
             setXAuthLocation = lib.mkOption {

     

       67
       67
       +
               type = lib.types.bool;

     

       70
       68
        
               description = ''

     

       71
       69
        
                 Whether to set the path to {command}`xauth` for X11-forwarded connections.

     

       72
       70
        
                 This causes a dependency on X11 packages.

     

       73
       71
        
               '';

     

       74
       72
        
             };

     

       75
       73
        
       

     

       76
       76
       -
             pubkeyAcceptedKeyTypes = mkOption {

     

       77
       77
       -
               type = types.listOf types.str;

     

       74
       74
       +
             pubkeyAcceptedKeyTypes = lib.mkOption {

     

       75
       75
       +
               type = lib.types.listOf lib.types.str;

     

       78
       76
        
               default = [];

     

       79
       77
        
               example = [ "ssh-ed25519" "ssh-rsa" ];

     

       80
       78
        
               description = ''

     

       81
       81
       -
                 Specifies the key types that will be used for public key authentication.

     

       79
       79
       +
                 Specifies the key lib.types that will be used for public key authentication.

     

       82
       80
        
               '';

     

       83
       81
        
             };

     

       84
       82
        
       

     

       85
       85
       -
             hostKeyAlgorithms = mkOption {

     

       86
       86
       -
               type = types.listOf types.str;

     

       83
       83
       +
             hostKeyAlgorithms = lib.mkOption {

     

       84
       84
       +
               type = lib.types.listOf lib.types.str;

     

       87
       85
        
               default = [];

     

       88
       86
        
               example = [ "ssh-ed25519" "ssh-rsa" ];

     

       89
       87
        
               description = ''

     
···

       91
       89
        
               '';

     

       92
       90
        
             };

     

       93
       91
        
       

     

       94
       94
       -
             extraConfig = mkOption {

     

       95
       95
       -
               type = types.lines;

     

       92
       92
       +
             extraConfig = lib.mkOption {

     

       93
       93
       +
               type = lib.types.lines;

     

       96
       94
        
               default = "";

     

       97
       95
        
               description = ''

     

       98
       96
        
                 Extra configuration text prepended to {file}`ssh_config`. Other generated

     
···

       102
       100
        
               '';

     

       103
       101
        
             };

     

       104
       102
        
       

     

       105
       105
       -
             startAgent = mkOption {

     

       106
       106
       -
               type = types.bool;

     

       103
       103
       +
             startAgent = lib.mkOption {

     

       104
       104
       +
               type = lib.types.bool;

     

       107
       105
        
               default = false;

     

       108
       106
        
               description = ''

     

       109
       107
        
                 Whether to start the OpenSSH agent when you log in.  The OpenSSH agent

     
···

       113
       111
        
               '';

     

       114
       112
        
             };

     

       115
       113
        
       

     

       116
       116
       -
             agentTimeout = mkOption {

     

       117
       117
       -
               type = types.nullOr types.str;

     

       114
       114
       +
             agentTimeout = lib.mkOption {

     

       115
       115
       +
               type = lib.types.nullOr lib.types.str;

     

       118
       116
        
               default = null;

     

       119
       117
        
               example = "1h";

     

       120
       118
        
               description = ''

     
···

       122
       120
        
               '';

     

       123
       121
        
             };

     

       124
       122
        
       

     

       125
       125
       -
             agentPKCS11Whitelist = mkOption {

     

       126
       126
       -
               type = types.nullOr types.str;

     

       123
       123
       +
             agentPKCS11Whitelist = lib.mkOption {

     

       124
       124
       +
               type = lib.types.nullOr lib.types.str;

     

       127
       125
        
               default = null;

     

       128
       128
       -
               example = literalExpression ''"''${pkgs.opensc}/lib/opensc-pkcs11.so"'';

     

       126
       126
       +
               example = lib.literalExpression ''"''${pkgs.opensc}/lib/opensc-pkcs11.so"'';

     

       129
       127
        
               description = ''

     

       130
       128
        
                 A pattern-list of acceptable paths for PKCS#11 shared libraries

     

       131
       129
        
                 that may be used with the -s option to ssh-add.

     

       132
       130
        
               '';

     

       133
       131
        
             };

     

       134
       132
        
       

     

       135
       135
       -
             package = mkPackageOption pkgs "openssh" { };

     

       133
       133
       +
             package = lib.mkPackageOption pkgs "openssh" { };

     

       136
       134
        
       

     

       137
       137
       -
             knownHosts = mkOption {

     

       135
       135
       +
             knownHosts = lib.mkOption {

     

       138
       136
        
               default = {};

     

       139
       139
       -
               type = types.attrsOf (types.submodule ({ name, config, options, ... }: {

     

       137
       137
       +
               type = lib.types.attrsOf (lib.types.submodule ({ name, config, options, ... }: {

     

       140
       138
        
                 options = {

     

       141
       141
       -
                   certAuthority = mkOption {

     

       142
       142
       -
                     type = types.bool;

     

       139
       139
       +
                   certAuthority = lib.mkOption {

     

       140
       140
       +
                     type = lib.types.bool;

     

       143
       141
        
                     default = false;

     

       144
       142
        
                     description = ''

     

       145
       143
        
                       This public key is an SSH certificate authority, rather than an

     

       146
       144
        
                       individual host's key.

     

       147
       145
        
                     '';

     

       148
       146
        
                   };

     

       149
       149
       -
                   hostNames = mkOption {

     

       150
       150
       -
                     type = types.listOf types.str;

     

       147
       147
       +
                   hostNames = lib.mkOption {

     

       148
       148
       +
                     type = lib.types.listOf lib.types.str;

     

       151
       149
        
                     default = [ name ] ++ config.extraHostNames;

     

       152
       152
       -
                     defaultText = literalExpression "[ ${name} ] ++ config.${options.extraHostNames}";

     

       150
       150
       +
                     defaultText = lib.literalExpression "[ ${name} ] ++ config.${options.extraHostNames}";

     

       153
       151
        
                     description = ''

     

       154
       152
        
                       A list of host names and/or IP numbers used for accessing

     

       155
       153
        
                       the host's ssh service. This list includes the name of the

     
···

       160
       158
        
                       `hostNames` list.

     

       161
       159
        
                     '';

     

       162
       160
        
                   };

     

       163
       163
       -
                   extraHostNames = mkOption {

     

       164
       164
       -
                     type = types.listOf types.str;

     

       161
       161
       +
                   extraHostNames = lib.mkOption {

     

       162
       162
       +
                     type = lib.types.listOf lib.types.str;

     

       165
       163
        
                     default = [];

     

       166
       164
        
                     description = ''

     

       167
       165
        
                       A list of additional host names and/or IP numbers used for

     
···

       169
       167
        
                       `hostNames` is set explicitly.

     

       170
       168
        
                     '';

     

       171
       169
        
                   };

     

       172
       172
       -
                   publicKey = mkOption {

     

       170
       170
       +
                   publicKey = lib.mkOption {

     

       173
       171
        
                     default = null;

     

       174
       174
       -
                     type = types.nullOr types.str;

     

       172
       172
       +
                     type = lib.types.nullOr lib.types.str;

     

       175
       173
        
                     example = "ecdsa-sha2-nistp521 AAAAE2VjZHN...UEPg==";

     

       176
       174
        
                     description = ''

     

       177
       175
        
                       The public key data for the host. You can fetch a public key

     
···

       180
       178
        
                       the key type and the key itself.

     

       181
       179
        
                     '';

     

       182
       180
        
                   };

     

       183
       183
       -
                   publicKeyFile = mkOption {

     

       181
       181
       +
                   publicKeyFile = lib.mkOption {

     

       184
       182
        
                     default = null;

     

       185
       185
       -
                     type = types.nullOr types.path;

     

       183
       183
       +
                     type = lib.types.nullOr lib.types.path;

     

       186
       184
        
                     description = ''

     

       187
       185
        
                       The path to the public key file for the host. The public

     

       188
       186
        
                       key file is read at build time and saved in the Nix store.

     
···

       204
       202
        
                 `extraHostNames` to add additional host names without

     

       205
       203
        
                 disabling this default.

     

       206
       204
        
               '';

     

       207
       207
       -
               example = literalExpression ''

     

       205
       205
       +
               example = lib.literalExpression ''

     

       208
       206
        
                 {

     

       209
       207
        
                   myhost = {

     

       210
       208
        
                     extraHostNames = [ "myhost.mydomain.com" "10.10.1.4" ];

     
···

       219
       217
        
               '';

     

       220
       218
        
             };

     

       221
       219
        
       

     

       222
       222
       -
             knownHostsFiles = mkOption {

     

       220
       220
       +
             knownHostsFiles = lib.mkOption {

     

       223
       221
        
               default = [];

     

       224
       224
       -
               type = with types; listOf path;

     

       222
       222
       +
               type = with lib.types; listOf path;

     

       225
       223
        
               description = ''

     

       226
       224
        
                 Files containing SSH host keys to set as global known hosts.

     

       227
       225
        
                 `/etc/ssh/ssh_known_hosts` (which is

     

       228
       226
        
                 generated by {option}`programs.ssh.knownHosts`) is

     

       229
       227
        
                 always included.

     

       230
       228
        
               '';

     

       231
       231
       -
               example = literalExpression ''

     

       229
       229
       +
               example = lib.literalExpression ''

     

       232
       230
        
                 [

     

       233
       231
        
                   ./known_hosts

     

       234
       232
        
                   (writeText "github.keys" '''

     
···

       240
       238
        
               '';

     

       241
       239
        
             };

     

       242
       240
        
       

     

       243
       243
       -
             kexAlgorithms = mkOption {

     

       244
       244
       -
               type = types.nullOr (types.listOf types.str);

     

       241
       241
       +
             kexAlgorithms = lib.mkOption {

     

       242
       242
       +
               type = lib.types.nullOr (lib.types.listOf lib.types.str);

     

       245
       243
        
               default = null;

     

       246
       244
        
               example = [ "curve25519-sha256@libssh.org" "diffie-hellman-group-exchange-sha256" ];

     

       247
       245
        
               description = ''

     
···

       249
       247
        
               '';

     

       250
       248
        
             };

     

       251
       249
        
       

     

       252
       252
       -
             ciphers = mkOption {

     

       253
       253
       -
               type = types.nullOr (types.listOf types.str);

     

       250
       250
       +
             ciphers = lib.mkOption {

     

       251
       251
       +
               type = lib.types.nullOr (lib.types.listOf lib.types.str);

     

       254
       252
        
               default = null;

     

       255
       253
        
               example = [ "chacha20-poly1305@openssh.com" "aes256-gcm@openssh.com" ];

     

       256
       254
        
               description = ''

     
···

       258
       256
        
               '';

     

       259
       257
        
             };

     

       260
       258
        
       

     

       261
       261
       -
             macs = mkOption {

     

       262
       262
       -
               type = types.nullOr (types.listOf types.str);

     

       259
       259
       +
             macs = lib.mkOption {

     

       260
       260
       +
               type = lib.types.nullOr (lib.types.listOf lib.types.str);

     

       263
       261
        
               default = null;

     

       264
       262
        
               example = [ "hmac-sha2-512-etm@openssh.com" "hmac-sha1" ];

     

       265
       263
        
               description = ''

     
···

       274
       272
        
         config = {

     

       275
       273
        
       

     

       276
       274
        
           programs.ssh.setXAuthLocation =

     

       277
       277
       -
             mkDefault (config.services.xserver.enable || config.programs.ssh.forwardX11 == true || config.services.openssh.settings.X11Forwarding);

     

       275
       275
       +
             lib.mkDefault (config.services.xserver.enable || config.programs.ssh.forwardX11 == true || config.services.openssh.settings.X11Forwarding);

     

       278
       276
        
       

     

       279
       277
        
           assertions =

     

       280
       278
        
             [ { assertion = cfg.forwardX11 == true -> cfg.setXAuthLocation;

     

       281
       279
        
                 message = "cannot enable X11 forwarding without setting XAuth location";

     

       282
       280
        
               }

     

       283
       283
       -
             ] ++ flip mapAttrsToList cfg.knownHosts (name: data: {

     

       281
       281
       +
             ] ++ lib.flip lib.mapAttrsToList cfg.knownHosts (name: data: {

     

       284
       282
        
               assertion = (data.publicKey == null && data.publicKeyFile != null) ||

     

       285
       283
        
                           (data.publicKey != null && data.publicKeyFile == null);

     

       286
       284
        
               message = "knownHost ${name} must contain either a publicKey or publicKeyFile";

     
···

       296
       294
        
               # Generated options from other settings

     

       297
       295
        
               Host *

     

       298
       296
        
               AddressFamily ${if config.networking.enableIPv6 then "any" else "inet"}

     

       299
       299
       -
               GlobalKnownHostsFile ${concatStringsSep " " knownHostsFiles}

     

       297
       297
       +
               GlobalKnownHostsFile ${builtins.concatStringsSep " " knownHostsFiles}

     

       300
       298
        
       

     

       301
       301
       -
               ${optionalString cfg.setXAuthLocation "XAuthLocation ${pkgs.xorg.xauth}/bin/xauth"}

     

       299
       299
       +
               ${lib.optionalString cfg.setXAuthLocation "XAuthLocation ${pkgs.xorg.xauth}/bin/xauth"}

     

       302
       300
        
               ${lib.optionalString (cfg.forwardX11 != null) "ForwardX11 ${if cfg.forwardX11 then "yes" else "no"}"}

     

       303
       301
        
       

     

       304
       304
       -
               ${optionalString (cfg.pubkeyAcceptedKeyTypes != []) "PubkeyAcceptedKeyTypes ${concatStringsSep "," cfg.pubkeyAcceptedKeyTypes}"}

     

       305
       305
       -
               ${optionalString (cfg.hostKeyAlgorithms != []) "HostKeyAlgorithms ${concatStringsSep "," cfg.hostKeyAlgorithms}"}

     

       306
       306
       -
               ${optionalString (cfg.kexAlgorithms != null) "KexAlgorithms ${concatStringsSep "," cfg.kexAlgorithms}"}

     

       307
       307
       -
               ${optionalString (cfg.ciphers != null) "Ciphers ${concatStringsSep "," cfg.ciphers}"}

     

       308
       308
       -
               ${optionalString (cfg.macs != null) "MACs ${concatStringsSep "," cfg.macs}"}

     

       302
       302
       +
               ${lib.optionalString (cfg.pubkeyAcceptedKeyTypes != []) "PubkeyAcceptedKeyTypes ${builtins.concatStringsSep "," cfg.pubkeyAcceptedKeyTypes}"}

     

       303
       303
       +
               ${lib.optionalString (cfg.hostKeyAlgorithms != []) "HostKeyAlgorithms ${builtins.concatStringsSep "," cfg.hostKeyAlgorithms}"}

     

       304
       304
       +
               ${lib.optionalString (cfg.kexAlgorithms != null) "KexAlgorithms ${builtins.concatStringsSep "," cfg.kexAlgorithms}"}

     

       305
       305
       +
               ${lib.optionalString (cfg.ciphers != null) "Ciphers ${builtins.concatStringsSep "," cfg.ciphers}"}

     

       306
       306
       +
               ${lib.optionalString (cfg.macs != null) "MACs ${builtins.concatStringsSep "," cfg.macs}"}

     

       309
       307
        
             '';

     

       310
       308
        
       

     

       311
       309
        
           environment.etc."ssh/ssh_known_hosts".text = knownHostsText;

     

       312
       310
        
       

     

       313
       311
        
           # FIXME: this should really be socket-activated for über-awesomeness.

     

       314
       314
       -
           systemd.user.services.ssh-agent = mkIf cfg.startAgent

     

       312
       312
       +
           systemd.user.services.ssh-agent = lib.mkIf cfg.startAgent

     

       315
       313
        
             { description = "SSH Agent";

     

       316
       314
        
               wantedBy = [ "default.target" ];

     

       317
       315
        
               unitConfig.ConditionUser = "!@system";

     
···

       319
       317
        
                 { ExecStartPre = "${pkgs.coreutils}/bin/rm -f %t/ssh-agent";

     

       320
       318
        
                   ExecStart =

     

       321
       319
        
                       "${cfg.package}/bin/ssh-agent " +

     

       322
       322
       -
                       optionalString (cfg.agentTimeout != null) ("-t ${cfg.agentTimeout} ") +

     

       323
       323
       -
                       optionalString (cfg.agentPKCS11Whitelist != null) ("-P ${cfg.agentPKCS11Whitelist} ") +

     

       320
       320
       +
                       lib.optionalString (cfg.agentTimeout != null) ("-t ${cfg.agentTimeout} ") +

     

       321
       321
       +
                       lib.optionalString (cfg.agentPKCS11Whitelist != null) ("-P ${cfg.agentPKCS11Whitelist} ") +

     

       324
       322
        
                       "-a %t/ssh-agent";

     

       325
       323
        
                   StandardOutput = "null";

     

       326
       324
        
                   Type = "forking";

     
···

       330
       328
        
               # Allow ssh-agent to ask for confirmation. This requires the

     

       331
       329
        
               # unit to know about the user's $DISPLAY (via ‘systemctl

     

       332
       330
        
               # import-environment’).

     

       333
       333
       -
               environment.SSH_ASKPASS = optionalString cfg.enableAskPassword askPasswordWrapper;

     

       331
       331
       +
               environment.SSH_ASKPASS = lib.optionalString cfg.enableAskPassword askPasswordWrapper;

     

       334
       332
        
               environment.DISPLAY = "fake"; # required to make ssh-agent start $SSH_ASKPASS

     

       335
       333
        
             };

     

       336
       334
        
       

     

       337
       337
       -
           environment.extraInit = optionalString cfg.startAgent

     

       335
       335
       +
           environment.extraInit = lib.optionalString cfg.startAgent

     

       338
       336
        
             ''

     

       339
       337
        
               if [ -z "$SSH_AUTH_SOCK" -a -n "$XDG_RUNTIME_DIR" ]; then

     

       340
       338
        
                 export SSH_AUTH_SOCK="$XDG_RUNTIME_DIR/ssh-agent"

     

       341
       339
        
               fi

     

       342
       340
        
             '';

     

       343
       341
        
       

     

       344
       344
       -
           environment.variables.SSH_ASKPASS = optionalString cfg.enableAskPassword cfg.askPassword;

     

       342
       342
       +
           environment.variables.SSH_ASKPASS = lib.optionalString cfg.enableAskPassword cfg.askPassword;

     

       345
       343
        
       

     

       346
       344
        
         };

     

       347
       345
        
       }

+35 -37

nixos/modules/programs/steam.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.steam;

     

       7
       5
        
         gamescopeCfg = config.programs.gamescope;

     
···

       11
       9
        
         in

     

       12
       10
        
           pkgs.writeShellScriptBin "steam-gamescope" ''

     

       13
       11
        
             ${builtins.concatStringsSep "\n" exports}

     

       14
       14
       -
             gamescope --steam ${toString cfg.gamescopeSession.args} -- steam -tenfoot -pipewire-dmabuf

     

       12
       12
       +
             gamescope --steam ${builtins.toString cfg.gamescopeSession.args} -- steam -tenfoot -pipewire-dmabuf

     

       15
       13
        
           '';

     

       16
       14
        
       

     

       17
       15
        
         gamescopeSessionFile =

     
···

       24
       22
        
           '').overrideAttrs (_: { passthru.providedSessions = [ "steam" ]; });

     

       25
       23
        
       in {

     

       26
       24
        
         options.programs.steam = {

     

       27
       27
       -
           enable = mkEnableOption "steam";

     

       25
       25
       +
           enable = lib.mkEnableOption "steam";

     

       28
       26
        
       

     

       29
       29
       -
           package = mkOption {

     

       30
       30
       -
             type = types.package;

     

       27
       27
       +
           package = lib.mkOption {

     

       28
       28
       +
             type = lib.types.package;

     

       31
       29
        
             default = pkgs.steam;

     

       32
       32
       -
             defaultText = literalExpression "pkgs.steam";

     

       33
       33
       -
             example = literalExpression ''

     

       30
       30
       +
             defaultText = lib.literalExpression "pkgs.steam";

     

       31
       31
       +
             example = lib.literalExpression ''

     

       34
       32
        
               pkgs.steam-small.override {

     

       35
       33
        
                 extraEnv = {

     

       36
       34
        
                   MANGOHUD = true;

     
···

       44
       42
        
             '';

     

       45
       43
        
             apply = steam: steam.override (prev: {

     

       46
       44
        
               extraEnv = (lib.optionalAttrs (cfg.extraCompatPackages != [ ]) {

     

       47
       47
       -
                 STEAM_EXTRA_COMPAT_TOOLS_PATHS = makeSearchPathOutput "steamcompattool" "" cfg.extraCompatPackages;

     

       48
       48
       -
               }) // (optionalAttrs cfg.extest.enable {

     

       45
       45
       +
                 STEAM_EXTRA_COMPAT_TOOLS_PATHS = lib.makeSearchPathOutput "steamcompattool" "" cfg.extraCompatPackages;

     

       46
       46
       +
               }) // (lib.optionalAttrs cfg.extest.enable {

     

       49
       47
        
                 LD_PRELOAD = "${pkgs.pkgsi686Linux.extest}/lib/libextest.so";

     

       50
       48
        
               }) // (prev.extraEnv or {});

     

       51
       49
        
               extraLibraries = pkgs: let

     
···

       55
       53
        
                   then [ package ] ++ extraPackages

     

       56
       54
        
                   else [ package32 ] ++ extraPackages32;

     

       57
       55
        
               in prevLibs ++ additionalLibs;

     

       58
       58
       -
             } // optionalAttrs (cfg.gamescopeSession.enable && gamescopeCfg.capSysNice)

     

       56
       56
       +
             } // lib.optionalAttrs (cfg.gamescopeSession.enable && gamescopeCfg.capSysNice)

     

       59
       57
        
             {

     

       60
       58
        
               buildFHSEnv = pkgs.buildFHSEnv.override {

     

       61
       59
        
                 # use the setuid wrapped bubblewrap

     
···

       71
       69
        
             '';

     

       72
       70
        
           };

     

       73
       71
        
       

     

       74
       74
       -
           extraCompatPackages = mkOption {

     

       75
       75
       -
             type = types.listOf types.package;

     

       72
       72
       +
           extraCompatPackages = lib.mkOption {

     

       73
       73
       +
             type = lib.types.listOf lib.types.package;

     

       76
       74
        
             default = [ ];

     

       77
       77
       -
             example = literalExpression ''

     

       75
       75
       +
             example = lib.literalExpression ''

     

       78
       76
        
               with pkgs; [

     

       79
       77
        
                 proton-ge-bin

     

       80
       78
        
               ]

     
···

       88
       86
        
             '';

     

       89
       87
        
           };

     

       90
       88
        
       

     

       91
       91
       -
           remotePlay.openFirewall = mkOption {

     

       92
       92
       -
             type = types.bool;

     

       89
       89
       +
           remotePlay.openFirewall = lib.mkOption {

     

       90
       90
       +
             type = lib.types.bool;

     

       93
       91
        
             default = false;

     

       94
       92
        
             description = ''

     

       95
       93
        
               Open ports in the firewall for Steam Remote Play.

     

       96
       94
        
             '';

     

       97
       95
        
           };

     

       98
       96
        
       

     

       99
       99
       -
           dedicatedServer.openFirewall = mkOption {

     

       100
       100
       -
             type = types.bool;

     

       97
       97
       +
           dedicatedServer.openFirewall = lib.mkOption {

     

       98
       98
       +
             type = lib.types.bool;

     

       101
       99
        
             default = false;

     

       102
       100
        
             description = ''

     

       103
       101
        
               Open ports in the firewall for Source Dedicated Server.

     

       104
       102
        
             '';

     

       105
       103
        
           };

     

       106
       104
        
       

     

       107
       107
       -
           localNetworkGameTransfers.openFirewall = mkOption {

     

       108
       108
       -
             type = types.bool;

     

       105
       105
       +
           localNetworkGameTransfers.openFirewall = lib.mkOption {

     

       106
       106
       +
             type = lib.types.bool;

     

       109
       107
        
             default = false;

     

       110
       108
        
             description = ''

     

       111
       109
        
               Open ports in the firewall for Steam Local Network Game Transfers.

     

       112
       110
        
             '';

     

       113
       111
        
           };

     

       114
       112
        
       

     

       115
       115
       -
           gamescopeSession = mkOption {

     

       113
       113
       +
           gamescopeSession = lib.mkOption {

     

       116
       114
        
             description = "Run a GameScope driven Steam session from your display-manager";

     

       117
       115
        
             default = {};

     

       118
       118
       -
             type = types.submodule {

     

       116
       116
       +
             type = lib.types.submodule {

     

       119
       117
        
               options = {

     

       120
       120
       -
                 enable = mkEnableOption "GameScope Session";

     

       121
       121
       -
                 args = mkOption {

     

       122
       122
       -
                   type = types.listOf types.str;

     

       118
       118
       +
                 enable = lib.mkEnableOption "GameScope Session";

     

       119
       119
       +
                 args = lib.mkOption {

     

       120
       120
       +
                   type = lib.types.listOf lib.types.str;

     

       123
       121
        
                   default = [ ];

     

       124
       122
        
                   description = ''

     

       125
       123
        
                     Arguments to be passed to GameScope for the session.

     

       126
       124
        
                   '';

     

       127
       125
        
                 };

     

       128
       126
        
       

     

       129
       129
       -
                 env = mkOption {

     

       130
       130
       -
                   type = types.attrsOf types.str;

     

       127
       127
       +
                 env = lib.mkOption {

     

       128
       128
       +
                   type = lib.types.attrsOf lib.types.str;

     

       131
       129
        
                   default = { };

     

       132
       130
        
                   description = ''

     

       133
       131
        
                     Environmental variables to be passed to GameScope for the session.

     
···

       137
       135
        
             };

     

       138
       136
        
           };

     

       139
       137
        
       

     

       140
       140
       -
           extest.enable = mkEnableOption ''

     

       138
       138
       +
           extest.enable = lib.mkEnableOption ''

     

       141
       139
        
             Load the extest library into Steam, to translate X11 input events to

     

       142
       140
        
             uinput events (e.g. for using Steam Input on Wayland)

     

       143
       141
        
           '';

     

       144
       142
        
         };

     

       145
       143
        
       

     

       146
       146
       -
         config = mkIf cfg.enable {

     

       144
       144
       +
         config = lib.mkIf cfg.enable {

     

       147
       145
        
           hardware.opengl = { # this fixes the "glXChooseVisual failed" bug, context: https://github.com/NixOS/nixpkgs/issues/47932

     

       148
       146
        
             enable = true;

     

       149
       147
        
             driSupport = true;

     

       150
       148
        
             driSupport32Bit = true;

     

       151
       149
        
           };

     

       152
       150
        
       

     

       153
       153
       -
           security.wrappers = mkIf (cfg.gamescopeSession.enable && gamescopeCfg.capSysNice) {

     

       151
       151
       +
           security.wrappers = lib.mkIf (cfg.gamescopeSession.enable && gamescopeCfg.capSysNice) {

     

       154
       152
        
             # needed or steam fails

     

       155
       153
        
             bwrap = {

     

       156
       154
        
               owner = "root";

     
···

       160
       158
        
             };

     

       161
       159
        
           };

     

       162
       160
        
       

     

       163
       163
       -
           programs.gamescope.enable = mkDefault cfg.gamescopeSession.enable;

     

       164
       164
       -
           services.displayManager.sessionPackages = mkIf cfg.gamescopeSession.enable [ gamescopeSessionFile ];

     

       161
       161
       +
           programs.gamescope.enable = lib.mkDefault cfg.gamescopeSession.enable;

     

       162
       162
       +
           services.displayManager.sessionPackages = lib.mkIf cfg.gamescopeSession.enable [ gamescopeSessionFile ];

     

       165
       163
        
       

     

       166
       164
        
           # optionally enable 32bit pulseaudio support if pulseaudio is enabled

     

       167
       165
        
           hardware.pulseaudio.support32Bit = config.hardware.pulseaudio.enable;

     
···

       174
       172
        
           ] ++ lib.optional cfg.gamescopeSession.enable steam-gamescope;

     

       175
       173
        
       

     

       176
       174
        
           networking.firewall = lib.mkMerge [

     

       177
       177
       -
             (mkIf (cfg.remotePlay.openFirewall || cfg.localNetworkGameTransfers.openFirewall) {

     

       175
       175
       +
             (lib.mkIf (cfg.remotePlay.openFirewall || cfg.localNetworkGameTransfers.openFirewall) {

     

       178
       176
        
               allowedUDPPorts = [ 27036 ]; # Peer discovery

     

       179
       177
        
             })

     

       180
       178
        
       

     

       181
       181
       -
             (mkIf cfg.remotePlay.openFirewall {

     

       179
       179
       +
             (lib.mkIf cfg.remotePlay.openFirewall {

     

       182
       180
        
               allowedTCPPorts = [ 27036 ];

     

       183
       181
        
               allowedUDPPortRanges = [ { from = 27031; to = 27035; } ];

     

       184
       182
        
             })

     

       185
       183
        
       

     

       186
       186
       -
             (mkIf cfg.dedicatedServer.openFirewall {

     

       184
       184
       +
             (lib.mkIf cfg.dedicatedServer.openFirewall {

     

       187
       185
        
               allowedTCPPorts = [ 27015 ]; # SRCDS Rcon port

     

       188
       186
        
               allowedUDPPorts = [ 27015 ]; # Gameplay traffic

     

       189
       187
        
             })

     

       190
       188
        
       

     

       191
       191
       -
             (mkIf cfg.localNetworkGameTransfers.openFirewall {

     

       189
       189
       +
             (lib.mkIf cfg.localNetworkGameTransfers.openFirewall {

     

       192
       190
        
               allowedTCPPorts = [ 27040 ]; # Data transfers

     

       193
       191
        
             })

     

       194
       192
        
           ];

     

       195
       193
        
         };

     

       196
       194
        
       

     

       197
       197
       -
         meta.maintainers = teams.steam;

     

       195
       195
       +
         meta.maintainers = lib.teams.steam;

     

       198
       196
        
       }

+8 -10

nixos/modules/programs/streamdeck-ui.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.streamdeck-ui;

     

       7
       5
        
       in

     

       8
       6
        
       {

     

       9
       7
        
         options.programs.streamdeck-ui = {

     

       10
       10
       -
           enable = mkEnableOption "streamdeck-ui";

     

       8
       8
       +
           enable = lib.mkEnableOption "streamdeck-ui";

     

       11
       9
        
       

     

       12
       12
       -
           autoStart = mkOption {

     

       10
       10
       +
           autoStart = lib.mkOption {

     

       13
       11
        
             default = true;

     

       14
       14
       -
             type = types.bool;

     

       12
       12
       +
             type = lib.types.bool;

     

       15
       13
        
             description = "Whether streamdeck-ui should be started automatically.";

     

       16
       14
        
           };

     

       17
       15
        
       

     

       18
       18
       -
           package = mkPackageOption pkgs "streamdeck-ui" {

     

       16
       16
       +
           package = lib.mkPackageOption pkgs "streamdeck-ui" {

     

       19
       17
        
             default = [ "streamdeck-ui" ];

     

       20
       18
        
           };

     

       21
       19
        
       

     

       22
       20
        
         };

     

       23
       21
        
       

     

       24
       24
       -
         config = mkIf cfg.enable {

     

       25
       25
       -
           environment.systemPackages = with pkgs; [

     

       22
       22
       +
         config = lib.mkIf cfg.enable {

     

       23
       23
       +
           environment.systemPackages = [

     

       26
       24
        
             cfg.package

     

       27
       27
       -
             (mkIf cfg.autoStart (makeAutostartItem { name = "streamdeck-ui-noui"; package = cfg.package; }))

     

       25
       25
       +
             (lib.mkIf cfg.autoStart (pkgs.makeAutostartItem { name = "streamdeck-ui-noui"; package = cfg.package; }))

     

       28
       26
        
           ];

     

       29
       27
        
       

     

       30
       28
        
           services.udev.packages = [ cfg.package ];

     

       31
       29
        
         };

     

       32
       30
        
       

     

       33
       33
       -
         meta.maintainers = with maintainers; [ majiir ];

     

       31
       31
       +
         meta.maintainers = with lib.maintainers; [ majiir ];

     

       34
       32
        
       }

+2 -4

nixos/modules/programs/sysdig.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.sysdig;

     

       7
       5
        
       in {

     

       8
       8
       -
         options.programs.sysdig.enable = mkEnableOption "sysdig, a tracing tool";

     

       6
       6
       +
         options.programs.sysdig.enable = lib.mkEnableOption "sysdig, a tracing tool";

     

       9
       7
        
       

     

       10
       10
       -
         config = mkIf cfg.enable {

     

       8
       8
       +
         config = lib.mkIf cfg.enable {

     

       11
       9
        
           environment.systemPackages = [ pkgs.sysdig ];

     

       12
       10
        
           boot.extraModulePackages = [ config.boot.kernelPackages.sysdig ];

     

       13
       11
        
         };

+2 -4

nixos/modules/programs/system-config-printer.nix

···

       1
       1
        
       { config, pkgs, lib, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       {

     

       6
       4
        
       

     

       7
       5
        
         ###### interface

     
···

       10
       8
        
       

     

       11
       9
        
           programs.system-config-printer = {

     

       12
       10
        
       

     

       13
       13
       -
             enable = mkEnableOption "system-config-printer, a Graphical user interface for CUPS administration";

     

       11
       11
       +
             enable = lib.mkEnableOption "system-config-printer, a Graphical user interface for CUPS administration";

     

       14
       12
        
       

     

       15
       13
        
           };

     

       16
       14
        
       

     
···

       19
       17
        
       

     

       20
       18
        
         ###### implementation

     

       21
       19
        
       

     

       22
       22
       -
         config = mkIf config.programs.system-config-printer.enable {

     

       20
       20
       +
         config = lib.mkIf config.programs.system-config-printer.enable {

     

       23
       21
        
       

     

       24
       22
        
           environment.systemPackages = [

     

       25
       23
        
             pkgs.system-config-printer

+3 -5

nixos/modules/programs/systemtap.nix

···

       1
       1
        
       { config, lib, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let cfg = config.programs.systemtap;

     

       6
       4
        
       in {

     

       7
       5
        
       

     

       8
       6
        
         options = {

     

       9
       7
        
           programs.systemtap = {

     

       10
       10
       -
             enable = mkOption {

     

       11
       11
       -
               type = types.bool;

     

       8
       8
       +
             enable = lib.mkOption {

     

       9
       9
       +
               type = lib.types.bool;

     

       12
       10
        
               default = false;

     

       13
       11
        
               description = ''

     

       14
       12
        
                 Install {command}`systemtap` along with necessary kernel options.

     
···

       16
       14
        
             };

     

       17
       15
        
           };

     

       18
       16
        
         };

     

       19
       19
       -
         config = mkIf cfg.enable {

     

       17
       17
       +
         config = lib.mkIf cfg.enable {

     

       20
       18
        
           system.requiredKernelConfig = with config.lib.kernelConfig; [

     

       21
       19
        
             (isYes "DEBUG")

     

       22
       20
        
           ];

+6 -8

nixos/modules/programs/thefuck.nix

···

       1
       1
        
       { config, pkgs, lib, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         prg = config.programs;

     

       7
       5
        
         cfg = prg.thefuck;

     
···

       16
       14
        
         {

     

       17
       15
        
           options = {

     

       18
       16
        
             programs.thefuck = {

     

       19
       19
       -
               enable = mkEnableOption "thefuck, an app which corrects your previous console command";

     

       17
       17
       +
               enable = lib.mkEnableOption "thefuck, an app which corrects your previous console command";

     

       20
       18
        
       

     

       21
       21
       -
               alias = mkOption {

     

       19
       19
       +
               alias = lib.mkOption {

     

       22
       20
        
                 default = "fuck";

     

       23
       23
       -
                 type = types.str;

     

       21
       21
       +
                 type = lib.types.str;

     

       24
       22
        
       

     

       25
       23
        
                 description = ''

     

       26
       24
        
                   `thefuck` needs an alias to be configured.

     
···

       30
       28
        
             };

     

       31
       29
        
           };

     

       32
       30
        
       

     

       33
       33
       -
           config = mkIf cfg.enable {

     

       31
       31
       +
           config = lib.mkIf cfg.enable {

     

       34
       32
        
             environment.systemPackages = with pkgs; [ thefuck ];

     

       35
       33
        
       

     

       36
       34
        
             programs.bash.interactiveShellInit = bashAndZshInitScript;

     

       37
       37
       -
             programs.zsh.interactiveShellInit = mkIf prg.zsh.enable bashAndZshInitScript;

     

       38
       38
       -
             programs.fish.interactiveShellInit = mkIf prg.fish.enable fishInitScript;

     

       35
       35
       +
             programs.zsh.interactiveShellInit = lib.mkIf prg.zsh.enable bashAndZshInitScript;

     

       36
       36
       +
             programs.fish.interactiveShellInit = lib.mkIf prg.fish.enable fishInitScript;

     

       39
       37
        
           };

     

       40
       38
        
         }

+6 -8

nixos/modules/programs/thunar.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let cfg = config.programs.thunar;

     

       6
       4
        
       

     

       7
       5
        
       in {

     

       8
       6
        
         meta = {

     

       9
       9
       -
           maintainers = teams.xfce.members;

     

       7
       7
       +
           maintainers = lib.teams.xfce.members;

     

       10
       8
        
         };

     

       11
       9
        
       

     

       12
       10
        
         options = {

     

       13
       11
        
           programs.thunar = {

     

       14
       14
       -
             enable = mkEnableOption "Thunar, the Xfce file manager";

     

       12
       12
       +
             enable = lib.mkEnableOption "Thunar, the Xfce file manager";

     

       15
       13
        
       

     

       16
       16
       -
             plugins = mkOption {

     

       14
       14
       +
             plugins = lib.mkOption {

     

       17
       15
        
               default = [];

     

       18
       18
       -
               type = types.listOf types.package;

     

       16
       16
       +
               type = lib.types.listOf lib.types.package;

     

       19
       17
        
               description = "List of thunar plugins to install.";

     

       20
       20
       -
               example = literalExpression "with pkgs.xfce; [ thunar-archive-plugin thunar-volman ]";

     

       18
       18
       +
               example = lib.literalExpression "with pkgs.xfce; [ thunar-archive-plugin thunar-volman ]";

     

       21
       19
        
             };

     

       22
       20
        
       

     

       23
       21
        
           };

     

       24
       22
        
         };

     

       25
       23
        
       

     

       26
       26
       -
         config = mkIf cfg.enable (

     

       24
       24
       +
         config = lib.mkIf cfg.enable (

     

       27
       25
        
           let package = pkgs.xfce.thunar.override { thunarPlugins = cfg.plugins; };

     

       28
       26
        
       

     

       29
       27
        
           in {

+3 -5

nixos/modules/programs/traceroute.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.traceroute;

     

       7
       5
        
       in {

     

       8
       6
        
         options = {

     

       9
       7
        
           programs.traceroute = {

     

       10
       10
       -
             enable = mkOption {

     

       11
       11
       -
               type = types.bool;

     

       8
       8
       +
             enable = lib.mkOption {

     

       9
       9
       +
               type = lib.types.bool;

     

       12
       10
        
               default = false;

     

       13
       11
        
               description = ''

     

       14
       12
        
                 Whether to configure a setcap wrapper for traceroute.

     
···

       17
       15
        
           };

     

       18
       16
        
         };

     

       19
       17
        
       

     

       20
       20
       -
         config = mkIf cfg.enable {

     

       18
       18
       +
         config = lib.mkIf cfg.enable {

     

       21
       19
        
           security.wrappers.traceroute = {

     

       22
       20
        
             owner = "root";

     

       23
       21
        
             group = "root";

+3 -5

nixos/modules/programs/turbovnc.nix

···

       2
       2
        
       

     

       3
       3
        
       { config, lib, pkgs, ... }:

     

       4
       4
        
       

     

       5
       5
       -
       with lib;

     

       6
       6
       -
       

     

       7
       5
        
       let

     

       8
       6
        
         cfg = config.programs.turbovnc;

     

       9
       7
        
       in

     
···

       12
       10
        
       

     

       13
       11
        
           programs.turbovnc = {

     

       14
       12
        
       

     

       15
       15
       -
             ensureHeadlessSoftwareOpenGL = mkOption {

     

       16
       16
       -
               type = types.bool;

     

       13
       13
       +
             ensureHeadlessSoftwareOpenGL = lib.mkOption {

     

       14
       14
       +
               type = lib.types.bool;

     

       17
       15
        
               default = false;

     

       18
       16
        
               description = ''

     

       19
       17
        
                 Whether to set up NixOS such that TurboVNC's built-in software OpenGL

     
···

       36
       34
        
       

     

       37
       35
        
         };

     

       38
       36
        
       

     

       39
       39
       -
         config = mkIf cfg.ensureHeadlessSoftwareOpenGL {

     

       37
       37
       +
         config = lib.mkIf cfg.ensureHeadlessSoftwareOpenGL {

     

       40
       38
        
       

     

       41
       39
        
           # TurboVNC has builtin support for Mesa llvmpipe's `swrast`

     

       42
       40
        
           # software rendering to implement GLX (OpenGL on Xorg).

+2 -4

nixos/modules/programs/udevil.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.udevil;

     

       7
       5
        
       

     

       8
       6
        
       in {

     

       9
       9
       -
         options.programs.udevil.enable = mkEnableOption "udevil, to mount filesystems without password";

     

       7
       7
       +
         options.programs.udevil.enable = lib.mkEnableOption "udevil, to mount filesystems without password";

     

       10
       8
        
       

     

       11
       11
       -
         config = mkIf cfg.enable {

     

       9
       9
       +
         config = lib.mkIf cfg.enable {

     

       12
       10
        
           security.wrappers.udevil =

     

       13
       11
        
             { setuid = true;

     

       14
       12
        
               owner = "root";

+2 -4

nixos/modules/programs/usbtop.nix

···

       1
       1
        
       { config, pkgs, lib, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.usbtop;

     

       7
       5
        
       in {

     

       8
       6
        
         options = {

     

       9
       9
       -
           programs.usbtop.enable = mkEnableOption "usbtop and required kernel module, to show estimated USB bandwidth";

     

       7
       7
       +
           programs.usbtop.enable = lib.mkEnableOption "usbtop and required kernel module, to show estimated USB bandwidth";

     

       10
       8
        
         };

     

       11
       9
        
       

     

       12
       12
       -
         config = mkIf cfg.enable {

     

       10
       10
       +
         config = lib.mkIf cfg.enable {

     

       13
       11
        
           environment.systemPackages = with pkgs; [

     

       14
       12
        
             usbtop

     

       15
       13
        
           ];

+5 -7

nixos/modules/programs/vim.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.vim;

     

       7
       5
        
       in {

     

       8
       6
        
         options.programs.vim = {

     

       9
       9
       -
           defaultEditor = mkOption {

     

       10
       10
       -
             type = types.bool;

     

       7
       7
       +
           defaultEditor = lib.mkOption {

     

       8
       8
       +
             type = lib.types.bool;

     

       11
       9
        
             default = false;

     

       12
       10
        
             description = ''

     

       13
       11
        
               When enabled, installs vim and configures vim to be the default editor

     
···

       15
       13
        
             '';

     

       16
       14
        
           };

     

       17
       15
        
       

     

       18
       18
       -
           package = mkPackageOption pkgs "vim" {

     

       16
       16
       +
           package = lib.mkPackageOption pkgs "vim" {

     

       19
       17
        
             example = "vim-full";

     

       20
       18
        
           };

     

       21
       19
        
         };

     

       22
       20
        
       

     

       23
       23
       -
         config = mkIf cfg.defaultEditor {

     

       21
       21
       +
         config = lib.mkIf cfg.defaultEditor {

     

       24
       22
        
           environment.systemPackages = [ cfg.package ];

     

       25
       25
       -
           environment.variables = { EDITOR = mkOverride 900 "vim"; };

     

       23
       23
       +
           environment.variables = { EDITOR = lib.mkOverride 900 "vim"; };

     

       26
       24
        
         };

     

       27
       25
        
       }

+3 -5

nixos/modules/programs/wavemon.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.wavemon;

     

       7
       5
        
       in {

     

       8
       6
        
         options = {

     

       9
       7
        
           programs.wavemon = {

     

       10
       10
       -
             enable = mkOption {

     

       11
       11
       -
               type = types.bool;

     

       8
       8
       +
             enable = lib.mkOption {

     

       9
       9
       +
               type = lib.types.bool;

     

       12
       10
        
               default = false;

     

       13
       11
        
               description = ''

     

       14
       12
        
                 Whether to add wavemon to the global environment and configure a

     
···

       18
       16
        
           };

     

       19
       17
        
         };

     

       20
       18
        
       

     

       21
       21
       -
         config = mkIf cfg.enable {

     

       19
       19
       +
         config = lib.mkIf cfg.enable {

     

       22
       20
        
           environment.systemPackages = with pkgs; [ wavemon ];

     

       23
       21
        
           security.wrappers.wavemon = {

     

       24
       22
        
             owner = "root";

+21 -21

nixos/modules/programs/wayland/hyprland.nix

···

       3
       3
        
       , pkgs

     

       4
       4
        
       , ...

     

       5
       5
        
       }:

     

       6
       6
       -
       with lib; let

     

       6
       6
       +
       let

     

       7
       7
        
         cfg = config.programs.hyprland;

     

       8
       8
        
       

     

       9
       9
        
         finalPortalPackage = cfg.portalPackage.override {

     
···

       12
       12
        
       in

     

       13
       13
        
       {

     

       14
       14
        
         options.programs.hyprland = {

     

       15
       15
       -
           enable = mkEnableOption null // {

     

       15
       15
       +
           enable = lib.mkEnableOption null // {

     

       16
       16
        
             description = ''

     

       17
       17
        
               Whether to enable Hyprland, the dynamic tiling Wayland compositor that doesn't sacrifice on its looks.

     

       18
       18
        
       

     
···

       23
       23
        
             '';

     

       24
       24
        
           };

     

       25
       25
        
       

     

       26
       26
       -
           package = mkPackageOption pkgs "hyprland" { };

     

       26
       26
       +
           package = lib.mkPackageOption pkgs "hyprland" { };

     

       27
       27
        
       

     

       28
       28
       -
           finalPackage = mkOption {

     

       29
       29
       -
             type = types.package;

     

       28
       28
       +
           finalPackage = lib.mkOption {

     

       29
       29
       +
             type = lib.types.package;

     

       30
       30
        
             readOnly = true;

     

       31
       31
        
             default = cfg.package.override {

     

       32
       32
        
               enableXWayland = cfg.xwayland.enable;

     

       33
       33
        
             };

     

       34
       34
       -
             defaultText = literalExpression

     

       34
       34
       +
             defaultText = lib.literalExpression

     

       35
       35
        
               "`programs.hyprland.package` with applied configuration";

     

       36
       36
        
             description = ''

     

       37
       37
        
               The Hyprland package after applying configuration.

     

       38
       38
        
             '';

     

       39
       39
        
           };

     

       40
       40
        
       

     

       41
       41
       -
           portalPackage = mkPackageOption pkgs "xdg-desktop-portal-hyprland" { };

     

       41
       41
       +
           portalPackage = lib.mkPackageOption pkgs "xdg-desktop-portal-hyprland" { };

     

       42
       42
        
       

     

       43
       43
       -
           xwayland.enable = mkEnableOption ("XWayland") // { default = true; };

     

       43
       43
       +
           xwayland.enable = lib.mkEnableOption ("XWayland") // { default = true; };

     

       44
       44
        
       

     

       45
       45
       -
           systemd.setPath.enable = mkEnableOption null // {

     

       45
       45
       +
           systemd.setPath.enable = lib.mkEnableOption null // {

     

       46
       46
        
             default = true;

     

       47
       47
        
             example = false;

     

       48
       48
        
             description = ''

     
···

       53
       53
        
           };

     

       54
       54
        
         };

     

       55
       55
        
       

     

       56
       56
       -
         config = mkIf cfg.enable {

     

       56
       56
       +
         config = lib.mkIf cfg.enable {

     

       57
       57
        
           environment.systemPackages = [ cfg.finalPackage ];

     

       58
       58
        
       

     

       59
       59
       -
           fonts.enableDefaultPackages = mkDefault true;

     

       60
       60
       -
           hardware.opengl.enable = mkDefault true;

     

       59
       59
       +
           fonts.enableDefaultPackages = lib.mkDefault true;

     

       60
       60
       +
           hardware.opengl.enable = lib.mkDefault true;

     

       61
       61
        
       

     

       62
       62
        
           programs = {

     

       63
       63
       -
             dconf.enable = mkDefault true;

     

       64
       64
       -
             xwayland.enable = mkDefault cfg.xwayland.enable;

     

       63
       63
       +
             dconf.enable = lib.mkDefault true;

     

       64
       64
       +
             xwayland.enable = lib.mkDefault cfg.xwayland.enable;

     

       65
       65
        
           };

     

       66
       66
        
       

     

       67
       67
        
           security.polkit.enable = true;

     
···

       69
       69
        
           services.displayManager.sessionPackages = [ cfg.finalPackage ];

     

       70
       70
        
       

     

       71
       71
        
           xdg.portal = {

     

       72
       72
       -
             enable = mkDefault true;

     

       72
       72
       +
             enable = lib.mkDefault true;

     

       73
       73
        
             extraPortals = [ finalPortalPackage ];

     

       74
       74
       -
             configPackages = mkDefault [ cfg.finalPackage ];

     

       74
       74
       +
             configPackages = lib.mkDefault [ cfg.finalPackage ];

     

       75
       75
        
           };

     

       76
       76
        
       

     

       77
       77
       -
           systemd = mkIf cfg.systemd.setPath.enable {

     

       77
       77
       +
           systemd = lib.mkIf cfg.systemd.setPath.enable {

     

       78
       78
        
             user.extraConfig = ''

     

       79
       79
        
               DefaultEnvironment="PATH=$PATH:/run/current-system/sw/bin:/etc/profiles/per-user/%u/bin:/run/wrappers/bin"

     

       80
       80
        
             '';

     

       81
       81
        
           };

     

       82
       82
        
         };

     

       83
       83
        
       

     

       84
       84
       -
         imports = with lib; [

     

       85
       85
       -
           (mkRemovedOptionModule

     

       84
       84
       +
         imports = [

     

       85
       85
       +
           (lib.mkRemovedOptionModule

     

       86
       86
        
             [ "programs" "hyprland" "xwayland" "hidpi" ]

     

       87
       87
        
             "XWayland patches are deprecated. Refer to https://wiki.hyprland.org/Configuring/XWayland"

     

       88
       88
        
           )

     

       89
       89
       -
           (mkRemovedOptionModule

     

       89
       89
       +
           (lib.mkRemovedOptionModule

     

       90
       90
        
             [ "programs" "hyprland" "enableNvidiaPatches" ]

     

       91
       91
        
             "Nvidia patches are no longer needed"

     

       92
       92
        
           )

     

       93
       93
       -
           (mkRemovedOptionModule

     

       93
       93
       +
           (lib.mkRemovedOptionModule

     

       94
       94
        
             [ "programs" "hyprland" "nvidiaPatches" ]

     

       95
       95
        
             "Nvidia patches are no longer needed"

     

       96
       96
        
           )

+11 -11

nixos/modules/programs/wayland/river.nix

···

       4
       4
        
         lib,

     

       5
       5
        
         ...

     

       6
       6
        
       }:

     

       7
       7
       -
       with lib; let

     

       7
       7
       +
       let

     

       8
       8
        
         cfg = config.programs.river;

     

       9
       9
        
       in {

     

       10
       10
        
         options.programs.river = {

     

       11
       11
       -
           enable = mkEnableOption "river, a dynamic tiling Wayland compositor";

     

       11
       11
       +
           enable = lib.mkEnableOption "river, a dynamic tiling Wayland compositor";

     

       12
       12
        
       

     

       13
       13
       -
           package = mkPackageOption pkgs "river" {

     

       13
       13
       +
           package = lib.mkPackageOption pkgs "river" {

     

       14
       14
        
             nullable = true;

     

       15
       15
        
             extraDescription = ''

     

       16
       16
        
               Set to `null` to not add any River package to your path.

     
···

       18
       18
        
             '';

     

       19
       19
        
           };

     

       20
       20
        
       

     

       21
       21
       -
           extraPackages = mkOption {

     

       22
       22
       -
             type = with types; listOf package;

     

       21
       21
       +
           extraPackages = lib.mkOption {

     

       22
       22
       +
             type = with lib.types; listOf package;

     

       23
       23
        
             default = with pkgs; [

     

       24
       24
        
               swaylock

     

       25
       25
        
               foot

     

       26
       26
        
               dmenu

     

       27
       27
        
             ];

     

       28
       28
       -
             defaultText = literalExpression ''

     

       28
       28
       +
             defaultText = lib.literalExpression ''

     

       29
       29
        
               with pkgs; [ swaylock foot dmenu ];

     

       30
       30
        
             '';

     

       31
       31
       -
             example = literalExpression ''

     

       31
       31
       +
             example = lib.literalExpression ''

     

       32
       32
        
               with pkgs; [

     

       33
       33
        
                 termite rofi light

     

       34
       34
        
               ]

     
···

       42
       42
        
         };

     

       43
       43
        
       

     

       44
       44
        
         config =

     

       45
       45
       -
           mkIf cfg.enable (mkMerge [

     

       45
       45
       +
           lib.mkIf cfg.enable (lib.mkMerge [

     

       46
       46
        
             {

     

       47
       47
       -
               environment.systemPackages = optional (cfg.package != null) cfg.package ++ cfg.extraPackages;

     

       47
       47
       +
               environment.systemPackages = lib.optional (cfg.package != null) cfg.package ++ cfg.extraPackages;

     

       48
       48
        
       

     

       49
       49
        
               # To make a river session available if a display manager like SDDM is enabled:

     

       50
       50
       -
               services.displayManager.sessionPackages = optionals (cfg.package != null) [ cfg.package ];

     

       50
       50
       +
               services.displayManager.sessionPackages = lib.optionals (cfg.package != null) [ cfg.package ];

     

       51
       51
        
       

     

       52
       52
        
               # https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=1050913

     

       53
       53
       -
               xdg.portal.config.river.default = mkDefault [ "wlr" "gtk" ];

     

       53
       53
       +
               xdg.portal.config.river.default = lib.mkDefault [ "wlr" "gtk" ];

     

       54
       54
        
             }

     

       55
       55
        
             (import ./wayland-session.nix { inherit lib pkgs; })

     

       56
       56
        
           ]);

+24 -26

nixos/modules/programs/wayland/sway.nix

···

       1
       1
        
       { config, pkgs, lib, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.sway;

     

       7
       5
        
       

     

       8
       8
       -
         wrapperOptions = types.submodule {

     

       6
       6
       +
         wrapperOptions = lib.types.submodule {

     

       9
       7
        
           options =

     

       10
       8
        
             let

     

       11
       11
       -
               mkWrapperFeature  = default: description: mkOption {

     

       12
       12
       -
                 type = types.bool;

     

       9
       9
       +
               mkWrapperFeature  = default: description: lib.mkOption {

     

       10
       10
       +
                 type = lib.types.bool;

     

       13
       11
        
                 inherit default;

     

       14
       12
        
                 example = !default;

     

       15
       13
        
                 description = "Whether to make use of the ${description}";

     
···

       50
       48
        
             };

     

       51
       49
        
       in {

     

       52
       50
        
         options.programs.sway = {

     

       53
       53
       -
           enable = mkEnableOption ''

     

       51
       51
       +
           enable = lib.mkEnableOption ''

     

       54
       52
        
             Sway, the i3-compatible tiling Wayland compositor. You can manually launch

     

       55
       53
        
             Sway by executing "exec sway" on a TTY. Copy /etc/sway/config to

     

       56
       54
        
             ~/.config/sway/config to modify the default configuration. See

     

       57
       55
        
             <https://github.com/swaywm/sway/wiki> and

     

       58
       56
        
             "man 5 sway" for more information'';

     

       59
       57
        
       

     

       60
       60
       -
           package = mkOption {

     

       61
       61
       -
             type = with types; nullOr package;

     

       58
       58
       +
           package = lib.mkOption {

     

       59
       59
       +
             type = with lib.types; nullOr package;

     

       62
       60
        
             default = pkgs.sway;

     

       63
       61
        
             apply = p: if p == null then null else genFinalPackage p;

     

       64
       64
       -
             defaultText = literalExpression "pkgs.sway";

     

       62
       62
       +
             defaultText = lib.literalExpression "pkgs.sway";

     

       65
       63
        
             description = ''

     

       66
       64
        
               Sway package to use. If the package does not contain the override arguments

     

       67
       65
        
               `extraSessionCommands`, `extraOptions`, `withBaseWrapper`, `withGtkWrapper`,

     
···

       72
       70
        
             '';

     

       73
       71
        
           };

     

       74
       72
        
       

     

       75
       75
       -
           wrapperFeatures = mkOption {

     

       73
       73
       +
           wrapperFeatures = lib.mkOption {

     

       76
       74
        
             type = wrapperOptions;

     

       77
       75
        
             default = { };

     

       78
       76
        
             example = { gtk = true; };

     
···

       81
       79
        
             '';

     

       82
       80
        
           };

     

       83
       81
        
       

     

       84
       84
       -
           extraSessionCommands = mkOption {

     

       85
       85
       -
             type = types.lines;

     

       82
       82
       +
           extraSessionCommands = lib.mkOption {

     

       83
       83
       +
             type = lib.types.lines;

     

       86
       84
        
             default = "";

     

       87
       85
        
             example = ''

     

       88
       86
        
               # SDL:

     
···

       102
       100
        
             '';

     

       103
       101
        
           };

     

       104
       102
        
       

     

       105
       105
       -
           extraOptions = mkOption {

     

       106
       106
       -
             type = types.listOf types.str;

     

       103
       103
       +
           extraOptions = lib.mkOption {

     

       104
       104
       +
             type = lib.types.listOf lib.types.str;

     

       107
       105
        
             default = [];

     

       108
       106
        
             example = [

     

       109
       107
        
               "--verbose"

     
···

       116
       114
        
             '';

     

       117
       115
        
           };

     

       118
       116
        
       

     

       119
       119
       -
           extraPackages = mkOption {

     

       120
       120
       -
             type = with types; listOf package;

     

       117
       117
       +
           extraPackages = lib.mkOption {

     

       118
       118
       +
             type = with lib.types; listOf package;

     

       121
       119
        
             default = with pkgs; [

     

       122
       120
        
               swaylock swayidle foot dmenu wmenu

     

       123
       121
        
             ];

     

       124
       124
       -
             defaultText = literalExpression ''

     

       122
       122
       +
             defaultText = lib.literalExpression ''

     

       125
       123
        
               with pkgs; [ swaylock swayidle foot dmenu wmenu ];

     

       126
       124
        
             '';

     

       127
       127
       -
             example = literalExpression ''

     

       125
       125
       +
             example = lib.literalExpression ''

     

       128
       126
        
               with pkgs; [

     

       129
       127
        
                 i3status i3status-rust

     

       130
       128
        
                 termite rofi light

     
···

       140
       138
        
       

     

       141
       139
        
         };

     

       142
       140
        
       

     

       143
       143
       -
         config = mkIf cfg.enable

     

       144
       144
       -
           (mkMerge [

     

       141
       141
       +
         config = lib.mkIf cfg.enable

     

       142
       142
       +
           (lib.mkMerge [

     

       145
       143
        
             {

     

       146
       144
        
               assertions = [

     

       147
       145
        
                 {

     
···

       154
       152
        
               ];

     

       155
       153
        
       

     

       156
       154
        
               environment = {

     

       157
       157
       -
                 systemPackages = optional (cfg.package != null) cfg.package ++ cfg.extraPackages;

     

       155
       155
       +
                 systemPackages = lib.optional (cfg.package != null) cfg.package ++ cfg.extraPackages;

     

       158
       156
        
                 # Needed for the default wallpaper:

     

       159
       159
       -
                 pathsToLink = optionals (cfg.package != null) [ "/share/backgrounds/sway" ];

     

       157
       157
       +
                 pathsToLink = lib.optionals (cfg.package != null) [ "/share/backgrounds/sway" ];

     

       160
       158
        
                 etc = {

     

       161
       159
        
                   "sway/config.d/nixos.conf".source = pkgs.writeText "nixos.conf" ''

     

       162
       160
        
                     # Import the most important environment variables into the D-Bus and systemd

     

       163
       161
        
                     # user environments (e.g. required for screen sharing and Pinentry prompts):

     

       164
       162
        
                     exec dbus-update-activation-environment --systemd DISPLAY WAYLAND_DISPLAY SWAYSOCK XDG_CURRENT_DESKTOP

     

       165
       163
        
                   '';

     

       166
       166
       -
                 } // optionalAttrs (cfg.package != null) {

     

       167
       167
       -
                   "sway/config".source = mkOptionDefault "${cfg.package}/etc/sway/config";

     

       164
       164
       +
                 } // lib.optionalAttrs (cfg.package != null) {

     

       165
       165
       +
                   "sway/config".source = lib.mkOptionDefault "${cfg.package}/etc/sway/config";

     

       168
       166
        
                 };

     

       169
       167
        
               };

     

       170
       168
        
       

     

       171
       169
        
               programs.gnupg.agent.pinentryPackage = lib.mkDefault pkgs.pinentry-gnome3;

     

       172
       170
        
       

     

       173
       171
        
               # https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=1050913

     

       174
       174
       -
               xdg.portal.config.sway.default = mkDefault [ "wlr" "gtk" ];

     

       172
       172
       +
               xdg.portal.config.sway.default = lib.mkDefault [ "wlr" "gtk" ];

     

       175
       173
        
       

     

       176
       174
        
               # To make a Sway session available if a display manager like SDDM is enabled:

     

       177
       177
       -
               services.displayManager.sessionPackages = optionals (cfg.package != null) [ cfg.package ]; }

     

       175
       175
       +
               services.displayManager.sessionPackages = lib.optionals (cfg.package != null) [ cfg.package ]; }

     

       178
       176
        
             (import ./wayland-session.nix { inherit lib pkgs; })

     

       179
       177
        
           ]);

     

       180
       178

+4 -6

nixos/modules/programs/wayland/waybar.nix

···

       1
       1
        
       { lib, pkgs, config, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.waybar;

     

       7
       5
        
       in

     

       8
       6
        
       {

     

       9
       7
        
         options.programs.waybar = {

     

       10
       10
       -
           enable = mkEnableOption "waybar, a highly customizable Wayland bar for Sway and Wlroots based compositors";

     

       11
       11
       -
           package = mkPackageOption pkgs "waybar" { };

     

       8
       8
       +
           enable = lib.mkEnableOption "waybar, a highly customizable Wayland bar for Sway and Wlroots based compositors";

     

       9
       9
       +
           package = lib.mkPackageOption pkgs "waybar" { };

     

       12
       10
        
         };

     

       13
       11
        
       

     

       14
       14
       -
         config = mkIf cfg.enable {

     

       12
       12
       +
         config = lib.mkIf cfg.enable {

     

       15
       13
        
           environment.systemPackages = [ cfg.package ];

     

       16
       14
        
           systemd.user.services.waybar = {

     

       17
       15
        
             description = "Waybar as systemd service";

     
···

       21
       19
        
           };

     

       22
       20
        
         };

     

       23
       21
        
       

     

       24
       24
       -
         meta.maintainers = [ maintainers.FlorianFranzen ];

     

       22
       22
       +
         meta.maintainers = [ lib.maintainers.FlorianFranzen ];

     

       25
       23
        
       }

+6 -6

nixos/modules/programs/wayland/wayland-session.nix

···

       1
       1
       -
       { lib, pkgs, ... }: with lib; {

     

       1
       1
       +
       { lib, pkgs, ... }: {

     

       2
       2
        
           security = {

     

       3
       3
        
             polkit.enable = true;

     

       4
       4
        
             pam.services.swaylock = {};

     

       5
       5
        
           };

     

       6
       6
        
       

     

       7
       7
       -
           hardware.opengl.enable = mkDefault true;

     

       8
       8
       -
           fonts.enableDefaultPackages = mkDefault true;

     

       7
       7
       +
           hardware.opengl.enable = lib.mkDefault true;

     

       8
       8
       +
           fonts.enableDefaultPackages = lib.mkDefault true;

     

       9
       9
        
       

     

       10
       10
        
           programs = {

     

       11
       11
       -
             dconf.enable = mkDefault true;

     

       12
       12
       -
             xwayland.enable = mkDefault true;

     

       11
       11
       +
             dconf.enable = lib.mkDefault true;

     

       12
       12
       +
             xwayland.enable = lib.mkDefault true;

     

       13
       13
        
           };

     

       14
       14
        
       

     

       15
       15
        
           xdg.portal = {

     

       16
       16
       -
             enable = mkDefault true;

     

       16
       16
       +
             enable = lib.mkDefault true;

     

       17
       17
        
       

     

       18
       18
        
             extraPortals = [

     

       19
       19
        
               # For screen sharing

+7 -9

nixos/modules/programs/weylus.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.weylus;

     

       7
       5
        
       in

     

       8
       6
        
       {

     

       9
       9
       -
         options.programs.weylus = with types; {

     

       10
       10
       -
           enable = mkEnableOption "weylus, which turns your smart phone into a graphic tablet/touch screen for your computer";

     

       7
       7
       +
         options.programs.weylus = with lib.types; {

     

       8
       8
       +
           enable = lib.mkEnableOption "weylus, which turns your smart phone into a graphic tablet/touch screen for your computer";

     

       11
       9
        
       

     

       12
       12
       -
           openFirewall = mkOption {

     

       10
       10
       +
           openFirewall = lib.mkOption {

     

       13
       11
        
             type = bool;

     

       14
       12
        
             default = false;

     

       15
       13
        
             description = ''

     
···

       17
       15
        
             '';

     

       18
       16
        
           };

     

       19
       17
        
       

     

       20
       20
       -
            users = mkOption {

     

       18
       18
       +
            users = lib.mkOption {

     

       21
       19
        
             type = listOf str;

     

       22
       20
        
             default = [ ];

     

       23
       21
        
             description = ''

     
···

       26
       24
        
             '';

     

       27
       25
        
           };

     

       28
       26
        
       

     

       29
       29
       -
           package = mkPackageOption pkgs "weylus" { };

     

       27
       27
       +
           package = lib.mkPackageOption pkgs "weylus" { };

     

       30
       28
        
         };

     

       31
       31
       -
         config = mkIf cfg.enable {

     

       32
       32
       -
           networking.firewall = mkIf cfg.openFirewall {

     

       29
       29
       +
         config = lib.mkIf cfg.enable {

     

       30
       30
       +
           networking.firewall = lib.mkIf cfg.openFirewall {

     

       33
       31
        
             allowedTCPPorts = [ 1701 9001 ];

     

       34
       32
        
           };

     

       35
       33

+4 -6

nixos/modules/programs/wireshark.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.wireshark;

     

       7
       5
        
         wireshark = cfg.package;

     

       8
       6
        
       in {

     

       9
       7
        
         options = {

     

       10
       8
        
           programs.wireshark = {

     

       11
       11
       -
             enable = mkOption {

     

       12
       12
       -
               type = types.bool;

     

       9
       9
       +
             enable = lib.mkOption {

     

       10
       10
       +
               type = lib.types.bool;

     

       13
       11
        
               default = false;

     

       14
       12
        
               description = ''

     

       15
       13
        
                 Whether to add Wireshark to the global environment and configure a

     

       16
       14
        
                 setcap wrapper for 'dumpcap' for users in the 'wireshark' group.

     

       17
       15
        
               '';

     

       18
       16
        
             };

     

       19
       19
       -
             package = mkPackageOption pkgs "wireshark-cli" {

     

       17
       17
       +
             package = lib.mkPackageOption pkgs "wireshark-cli" {

     

       20
       18
        
               example = "wireshark";

     

       21
       19
        
             };

     

       22
       20
        
           };

     

       23
       21
        
         };

     

       24
       22
        
       

     

       25
       25
       -
         config = mkIf cfg.enable {

     

       23
       23
       +
         config = lib.mkIf cfg.enable {

     

       26
       24
        
           environment.systemPackages = [ wireshark ];

     

       27
       25
        
           users.groups.wireshark = {};

     

       28
       26

+3 -5

nixos/modules/programs/xastir.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.xastir;

     

       7
       5
        
       in {

     

       8
       8
       -
         meta.maintainers = with maintainers; [ melling ];

     

       6
       6
       +
         meta.maintainers = with lib.maintainers; [ melling ];

     

       9
       7
        
       

     

       10
       8
        
         options.programs.xastir = {

     

       11
       11
       -
           enable = mkEnableOption "Xastir Graphical APRS client";

     

       9
       9
       +
           enable = lib.mkEnableOption "Xastir Graphical APRS client";

     

       12
       10
        
         };

     

       13
       11
        
       

     

       14
       14
       -
         config = mkIf cfg.enable {

     

       12
       12
       +
         config = lib.mkIf cfg.enable {

     

       15
       13
        
           environment.systemPackages = with pkgs; [ xastir ];

     

       16
       14
        
           security.wrappers.xastir = {

     

       17
       15
        
             source = "${pkgs.xastir}/bin/xastir";

+3 -5

nixos/modules/programs/xfconf.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let cfg = config.programs.xfconf;

     

       6
       4
        
       

     

       7
       5
        
       in {

     

       8
       6
        
         meta = {

     

       9
       9
       -
           maintainers = teams.xfce.members;

     

       7
       7
       +
           maintainers = lib.teams.xfce.members;

     

       10
       8
        
         };

     

       11
       9
        
       

     

       12
       10
        
         options = {

     

       13
       11
        
           programs.xfconf = {

     

       14
       14
       -
             enable = mkEnableOption "Xfconf, the Xfce configuration storage system";

     

       12
       12
       +
             enable = lib.mkEnableOption "Xfconf, the Xfce configuration storage system";

     

       15
       13
        
           };

     

       16
       14
        
         };

     

       17
       15
        
       

     

       18
       18
       -
         config = mkIf cfg.enable {

     

       16
       16
       +
         config = lib.mkIf cfg.enable {

     

       19
       17
        
           environment.systemPackages = [

     

       20
       18
        
             pkgs.xfce.xfconf

     

       21
       19
        
           ];

+23 -25

nixos/modules/programs/xfs_quota.nix

···

       2
       2
        
       

     

       3
       3
        
       { config, lib, pkgs, ... }:

     

       4
       4
        
       

     

       5
       5
       -
       with lib;

     

       6
       6
       -
       

     

       7
       5
        
       let

     

       8
       6
        
       

     

       9
       7
        
         cfg = config.programs.xfs_quota;

     

       10
       8
        
       

     

       11
       11
       -
         limitOptions = opts: concatStringsSep " " [

     

       12
       12
       -
           (optionalString (opts.sizeSoftLimit != null) "bsoft=${opts.sizeSoftLimit}")

     

       13
       13
       -
           (optionalString (opts.sizeHardLimit != null) "bhard=${opts.sizeHardLimit}")

     

       9
       9
       +
         limitOptions = opts: builtins.concatStringsSep " " [

     

       10
       10
       +
           (lib.optionalString (opts.sizeSoftLimit != null) "bsoft=${opts.sizeSoftLimit}")

     

       11
       11
       +
           (lib.optionalString (opts.sizeHardLimit != null) "bhard=${opts.sizeHardLimit}")

     

       14
       12
        
         ];

     

       15
       13
        
       

     

       16
       14
        
       in

     
···

       22
       20
        
         options = {

     

       23
       21
        
       

     

       24
       22
        
           programs.xfs_quota = {

     

       25
       25
       -
             projects = mkOption {

     

       23
       23
       +
             projects = lib.mkOption {

     

       26
       24
        
               default = {};

     

       27
       27
       -
               type = types.attrsOf (types.submodule {

     

       25
       25
       +
               type = lib.types.attrsOf (lib.types.submodule {

     

       28
       26
        
                 options = {

     

       29
       29
       -
                   id = mkOption {

     

       30
       30
       -
                     type = types.int;

     

       27
       27
       +
                   id = lib.mkOption {

     

       28
       28
       +
                     type = lib.types.int;

     

       31
       29
        
                     description = "Project ID.";

     

       32
       30
        
                   };

     

       33
       31
        
       

     

       34
       34
       -
                   fileSystem = mkOption {

     

       35
       35
       -
                     type = types.str;

     

       32
       32
       +
                   fileSystem = lib.mkOption {

     

       33
       33
       +
                     type = lib.types.str;

     

       36
       34
        
                     description = "XFS filesystem hosting the xfs_quota project.";

     

       37
       35
        
                     default = "/";

     

       38
       36
        
                   };

     

       39
       37
        
       

     

       40
       40
       -
                   path = mkOption {

     

       41
       41
       -
                     type = types.str;

     

       38
       38
       +
                   path = lib.mkOption {

     

       39
       39
       +
                     type = lib.types.str;

     

       42
       40
        
                     description = "Project directory.";

     

       43
       41
        
                   };

     

       44
       42
        
       

     

       45
       45
       -
                   sizeSoftLimit = mkOption {

     

       46
       46
       -
                     type = types.nullOr types.str;

     

       43
       43
       +
                   sizeSoftLimit = lib.mkOption {

     

       44
       44
       +
                     type = lib.types.nullOr lib.types.str;

     

       47
       45
        
                     default = null;

     

       48
       46
        
                     example = "30g";

     

       49
       47
        
                     description = "Soft limit of the project size";

     

       50
       48
        
                   };

     

       51
       49
        
       

     

       52
       52
       -
                   sizeHardLimit = mkOption {

     

       53
       53
       -
                     type = types.nullOr types.str;

     

       50
       50
       +
                   sizeHardLimit = lib.mkOption {

     

       51
       51
       +
                     type = lib.types.nullOr lib.types.str;

     

       54
       52
        
                     default = null;

     

       55
       53
        
                     example = "50g";

     

       56
       54
        
                     description = "Hard limit of the project size.";

     
···

       75
       73
        
       

     

       76
       74
        
         ###### implementation

     

       77
       75
        
       

     

       78
       78
       -
         config = mkIf (cfg.projects != {}) {

     

       76
       76
       +
         config = lib.mkIf (cfg.projects != {}) {

     

       79
       77
        
       

     

       80
       78
        
           environment.etc.projects.source = pkgs.writeText "etc-project"

     

       81
       81
       -
             (concatStringsSep "\n" (mapAttrsToList

     

       82
       82
       -
               (name: opts: "${toString opts.id}:${opts.path}") cfg.projects));

     

       79
       79
       +
             (builtins.concatStringsSep "\n" (lib.mapAttrsToList

     

       80
       80
       +
               (name: opts: "${builtins.toString opts.id}:${opts.path}") cfg.projects));

     

       83
       81
        
       

     

       84
       82
        
           environment.etc.projid.source = pkgs.writeText "etc-projid"

     

       85
       85
       -
             (concatStringsSep "\n" (mapAttrsToList

     

       86
       86
       -
               (name: opts: "${name}:${toString opts.id}") cfg.projects));

     

       83
       83
       +
             (builtins.concatStringsSep "\n" (lib.mapAttrsToList

     

       84
       84
       +
               (name: opts: "${name}:${builtins.toString opts.id}") cfg.projects));

     

       87
       85
        
       

     

       88
       88
       -
           systemd.services = mapAttrs' (name: opts:

     

       89
       89
       -
             nameValuePair "xfs_quota-${name}" {

     

       86
       86
       +
           systemd.services = lib.mapAttrs' (name: opts:

     

       87
       87
       +
             lib.nameValuePair "xfs_quota-${name}" {

     

       90
       88
        
               description = "Setup xfs_quota for project ${name}";

     

       91
       89
        
               script = ''

     

       92
       90
        
                 ${pkgs.xfsprogs.bin}/bin/xfs_quota -x -c 'project -s ${name}' ${opts.fileSystem}

     
···

       94
       92
        
               '';

     

       95
       93
        
       

     

       96
       94
        
               wantedBy = [ "multi-user.target" ];

     

       97
       97
       -
               after = [ ((replaceStrings [ "/" ] [ "-" ] opts.fileSystem) + ".mount") ];

     

       95
       95
       +
               after = [ ((builtins.replaceStrings [ "/" ] [ "-" ] opts.fileSystem) + ".mount") ];

     

       98
       96
        
       

     

       99
       97
        
               restartTriggers = [ config.environment.etc.projects.source ];

     

       100
       98

+6 -8

nixos/modules/programs/xonsh.nix

···

       2
       2
        
       

     

       3
       3
        
       { config, lib, pkgs, ... }:

     

       4
       4
        
       

     

       5
       5
       -
       with lib;

     

       6
       6
       -
       

     

       7
       5
        
       let

     

       8
       6
        
       

     

       9
       7
        
         cfg = config.programs.xonsh;

     
···

       16
       14
        
       

     

       17
       15
        
           programs.xonsh = {

     

       18
       16
        
       

     

       19
       19
       -
             enable = mkOption {

     

       17
       17
       +
             enable = lib.mkOption {

     

       20
       18
        
               default = false;

     

       21
       19
        
               description = ''

     

       22
       20
        
                 Whether to configure xonsh as an interactive shell.

     

       23
       21
        
               '';

     

       24
       24
       -
               type = types.bool;

     

       22
       22
       +
               type = lib.types.bool;

     

       25
       23
        
             };

     

       26
       24
        
       

     

       27
       27
       -
             package = mkPackageOption pkgs "xonsh" {

     

       25
       25
       +
             package = lib.mkPackageOption pkgs "xonsh" {

     

       28
       26
        
               example = "xonsh.override { extraPackages = ps: [ ps.requests ]; }";

     

       29
       27
        
             };

     

       30
       28
        
       

     

       31
       31
       -
             config = mkOption {

     

       29
       29
       +
             config = lib.mkOption {

     

       32
       30
        
               default = "";

     

       33
       31
        
               description = "Control file to customize your shell behavior.";

     

       34
       34
       -
               type = types.lines;

     

       32
       32
       +
               type = lib.types.lines;

     

       35
       33
        
             };

     

       36
       34
        
       

     

       37
       35
        
           };

     

       38
       36
        
       

     

       39
       37
        
         };

     

       40
       38
        
       

     

       41
       41
       -
         config = mkIf cfg.enable {

     

       39
       39
       +
         config = lib.mkIf cfg.enable {

     

       42
       40
        
       

     

       43
       41
        
           environment.etc."xonsh/xonshrc".text = ''

     

       44
       42
        
             # /etc/xonsh/xonshrc: DO NOT EDIT -- this file has been generated automatically.

+11 -13

nixos/modules/programs/xss-lock.nix

···

       1
       1
        
       { config, pkgs, lib, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.xss-lock;

     

       7
       5
        
       in

     

       8
       6
        
       {

     

       9
       7
        
         options.programs.xss-lock = {

     

       10
       10
       -
           enable = mkEnableOption "xss-lock";

     

       8
       8
       +
           enable = lib.mkEnableOption "xss-lock";

     

       11
       9
        
       

     

       12
       12
       -
           lockerCommand = mkOption {

     

       10
       10
       +
           lockerCommand = lib.mkOption {

     

       13
       11
        
             default = "${pkgs.i3lock}/bin/i3lock";

     

       14
       14
       -
             defaultText = literalExpression ''"''${pkgs.i3lock}/bin/i3lock"'';

     

       15
       15
       -
             example = literalExpression ''"''${pkgs.i3lock-fancy}/bin/i3lock-fancy"'';

     

       16
       16
       -
             type = types.separatedString " ";

     

       12
       12
       +
             defaultText = lib.literalExpression ''"''${pkgs.i3lock}/bin/i3lock"'';

     

       13
       13
       +
             example = lib.literalExpression ''"''${pkgs.i3lock-fancy}/bin/i3lock-fancy"'';

     

       14
       14
       +
             type = lib.types.separatedString " ";

     

       17
       15
        
             description = "Locker to be used with xsslock";

     

       18
       16
        
           };

     

       19
       17
        
       

     

       20
       20
       -
           extraOptions = mkOption {

     

       18
       18
       +
           extraOptions = lib.mkOption {

     

       21
       19
        
             default = [ ];

     

       22
       20
        
             example = [ "--ignore-sleep" ];

     

       23
       23
       -
             type = types.listOf types.str;

     

       21
       21
       +
             type = lib.types.listOf lib.types.str;

     

       24
       22
        
             description = ''

     

       25
       23
        
               Additional command-line arguments to pass to

     

       26
       24
        
               {command}`xss-lock`.

     
···

       28
       26
        
           };

     

       29
       27
        
         };

     

       30
       28
        
       

     

       31
       31
       -
         config = mkIf cfg.enable {

     

       29
       29
       +
         config = lib.mkIf cfg.enable {

     

       32
       30
        
           systemd.user.services.xss-lock = {

     

       33
       31
        
             description = "XSS Lock Daemon";

     

       34
       32
        
             wantedBy = [ "graphical-session.target" ];

     

       35
       33
        
             partOf = [ "graphical-session.target" ];

     

       36
       36
       -
             serviceConfig.ExecStart = with lib;

     

       37
       37
       -
               strings.concatStringsSep " " ([

     

       34
       34
       +
             serviceConfig.ExecStart =

     

       35
       35
       +
               builtins.concatStringsSep " " ([

     

       38
       36
        
                   "${pkgs.xss-lock}/bin/xss-lock" "--session \${XDG_SESSION_ID}"

     

       39
       39
       -
                 ] ++ (map escapeShellArg cfg.extraOptions) ++ [

     

       37
       37
       +
                 ] ++ (builtins.map lib.escapeShellArg cfg.extraOptions) ++ [

     

       40
       38
        
                   "--"

     

       41
       39
        
                   cfg.lockerCommand

     

       42
       40
        
               ]);

+9 -11

nixos/modules/programs/xwayland.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.xwayland;

     

       7
       5
        
       

     
···

       10
       8
        
       {

     

       11
       9
        
         options.programs.xwayland = {

     

       12
       10
        
       

     

       13
       13
       -
           enable = mkEnableOption "Xwayland (an X server for interfacing X11 apps with the Wayland protocol)";

     

       11
       11
       +
           enable = lib.mkEnableOption "Xwayland (an X server for interfacing X11 apps with the Wayland protocol)";

     

       14
       12
        
       

     

       15
       15
       -
           defaultFontPath = mkOption {

     

       16
       16
       -
             type = types.str;

     

       17
       17
       -
             default = optionalString config.fonts.fontDir.enable

     

       13
       13
       +
           defaultFontPath = lib.mkOption {

     

       14
       14
       +
             type = lib.types.str;

     

       15
       15
       +
             default = lib.optionalString config.fonts.fontDir.enable

     

       18
       16
        
               "/run/current-system/sw/share/X11/fonts";

     

       19
       19
       -
             defaultText = literalExpression ''

     

       17
       17
       +
             defaultText = lib.literalExpression ''

     

       20
       18
        
               optionalString config.fonts.fontDir.enable "/run/current-system/sw/share/X11/fonts"

     

       21
       19
        
             '';

     

       22
       20
        
             description = ''

     
···

       24
       22
        
             '';

     

       25
       23
        
           };

     

       26
       24
        
       

     

       27
       27
       -
           package = mkOption {

     

       28
       28
       -
             type = types.path;

     

       25
       25
       +
           package = lib.mkOption {

     

       26
       26
       +
             type = lib.types.path;

     

       29
       27
        
             default = pkgs.xwayland.override (oldArgs: {

     

       30
       28
        
               inherit (cfg) defaultFontPath;

     

       31
       29
        
             });

     

       32
       32
       -
             defaultText = literalExpression ''

     

       30
       30
       +
             defaultText = lib.literalExpression ''

     

       33
       31
        
               pkgs.xwayland.override (oldArgs: {

     

       34
       32
        
                 inherit (config.programs.xwayland) defaultFontPath;

     

       35
       33
        
               })

     
···

       39
       37
        
       

     

       40
       38
        
         };

     

       41
       39
        
       

     

       42
       42
       -
         config = mkIf cfg.enable {

     

       40
       40
       +
         config = lib.mkIf cfg.enable {

     

       43
       41
        
       

     

       44
       42
        
           # Needed by some applications for fonts and default settings

     

       45
       43
        
           environment.pathsToLink = [ "/share/X11" ];

+29 -31

nixos/modules/programs/yabar.nix

···

       1
       1
        
       { lib, pkgs, config, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.yabar;

     

       7
       5
        
       

     

       8
       8
       -
         mapExtra = v: lib.concatStringsSep "\n" (mapAttrsToList (

     

       9
       9
       -
           key: val: "${key} = ${if (isString val) then "\"${val}\"" else "${builtins.toString val}"};"

     

       6
       6
       +
         mapExtra = v: lib.concatStringsSep "\n" (lib.mapAttrsToList (

     

       7
       7
       +
           key: val: "${key} = ${if (builtins.isString val) then "\"${val}\"" else "${builtins.toString val}"};"

     

       10
       8
        
         ) v);

     

       11
       9
        
       

     

       12
       12
       -
         listKeys = r: concatStringsSep "," (map (n: "\"${n}\"") (attrNames r));

     

       10
       10
       +
         listKeys = r: builtins.concatStringsSep "," (builtins.map (n: "\"${n}\"") (builtins.attrNames r));

     

       13
       11
        
       

     

       14
       12
        
         configFile = let

     

       15
       15
       -
           bars = mapAttrsToList (

     

       13
       13
       +
           bars = lib.mapAttrsToList (

     

       16
       14
        
             name: cfg: ''

     

       17
       15
        
               ${name}: {

     

       18
       16
        
                 font: "${cfg.font}";

     
···

       22
       20
        
       

     

       23
       21
        
                 block-list: [${listKeys cfg.indicators}]

     

       24
       22
        
       

     

       25
       25
       -
                 ${concatStringsSep "\n" (mapAttrsToList (

     

       23
       23
       +
                 ${builtins.concatStringsSep "\n" (lib.mapAttrsToList (

     

       26
       24
        
                   name: cfg: ''

     

       27
       25
        
                     ${name}: {

     

       28
       26
        
                       exec: "${cfg.exec}";

     
···

       36
       34
        
           ) cfg.bars;

     

       37
       35
        
         in pkgs.writeText "yabar.conf" ''

     

       38
       36
        
           bar-list = [${listKeys cfg.bars}];

     

       39
       39
       -
           ${concatStringsSep "\n" bars}

     

       37
       37
       +
           ${builtins.concatStringsSep "\n" bars}

     

       40
       38
        
         '';

     

       41
       39
        
       in

     

       42
       40
        
         {

     

       43
       41
        
           options.programs.yabar = {

     

       44
       44
       -
             enable = mkEnableOption "yabar, a status bar for X window managers";

     

       42
       42
       +
             enable = lib.mkEnableOption "yabar, a status bar for X window managers";

     

       45
       43
        
       

     

       46
       46
       -
             package = mkOption {

     

       44
       44
       +
             package = lib.mkOption {

     

       47
       45
        
               default = pkgs.yabar-unstable;

     

       48
       48
       -
               defaultText = literalExpression "pkgs.yabar-unstable";

     

       49
       49
       -
               example = literalExpression "pkgs.yabar";

     

       50
       50
       -
               type = types.package;

     

       46
       46
       +
               defaultText = lib.literalExpression "pkgs.yabar-unstable";

     

       47
       47
       +
               example = lib.literalExpression "pkgs.yabar";

     

       48
       48
       +
               type = lib.types.package;

     

       51
       49
        
       

     

       52
       50
        
               # `yabar-stable` segfaults under certain conditions.

     

       53
       53
       -
               apply = x: if x == pkgs.yabar-unstable then x else flip warn x ''

     

       51
       51
       +
               apply = x: if x == pkgs.yabar-unstable then x else lib.flip lib.warn x ''

     

       54
       52
        
                 It's not recommended to use `yabar' with `programs.yabar', the (old) stable release

     

       55
       53
        
                 tends to segfault under certain circumstances:

     

       56
       54
        
       

     
···

       70
       68
        
               '';

     

       71
       69
        
             };

     

       72
       70
        
       

     

       73
       73
       -
             bars = mkOption {

     

       71
       71
       +
             bars = lib.mkOption {

     

       74
       72
        
               default = {};

     

       75
       75
       -
               type = types.attrsOf(types.submodule {

     

       73
       73
       +
               type = lib.types.attrsOf(lib.types.submodule {

     

       76
       74
        
                 options = {

     

       77
       77
       -
                   font = mkOption {

     

       75
       75
       +
                   font = lib.mkOption {

     

       78
       76
        
                     default = "sans bold 9";

     

       79
       77
        
                     example = "Droid Sans, FontAwesome Bold 9";

     

       80
       80
       -
                     type = types.str;

     

       78
       78
       +
                     type = lib.types.str;

     

       81
       79
        
       

     

       82
       80
        
                     description = ''

     

       83
       81
        
                       The font that will be used to draw the status bar.

     

       84
       82
        
                     '';

     

       85
       83
        
                   };

     

       86
       84
        
       

     

       87
       87
       -
                   position = mkOption {

     

       85
       85
       +
                   position = lib.mkOption {

     

       88
       86
        
                     default = "top";

     

       89
       87
        
                     example = "bottom";

     

       90
       90
       -
                     type = types.enum [ "top" "bottom" ];

     

       88
       88
       +
                     type = lib.types.enum [ "top" "bottom" ];

     

       91
       89
        
       

     

       92
       90
        
                     description = ''

     

       93
       91
        
                       The position where the bar will be rendered.

     

       94
       92
        
                     '';

     

       95
       93
        
                   };

     

       96
       94
        
       

     

       97
       97
       -
                   extra = mkOption {

     

       95
       95
       +
                   extra = lib.mkOption {

     

       98
       96
        
                     default = {};

     

       99
       99
       -
                     type = types.attrsOf types.str;

     

       97
       97
       +
                     type = lib.types.attrsOf lib.types.str;

     

       100
       98
        
       

     

       101
       99
        
                     description = ''

     

       102
       100
        
                       An attribute set which contains further attributes of a bar.

     

       103
       101
        
                     '';

     

       104
       102
        
                   };

     

       105
       103
        
       

     

       106
       106
       -
                   indicators = mkOption {

     

       104
       104
       +
                   indicators = lib.mkOption {

     

       107
       105
        
                     default = {};

     

       108
       108
       -
                     type = types.attrsOf(types.submodule {

     

       109
       109
       -
                       options.exec = mkOption {

     

       106
       106
       +
                     type = lib.types.attrsOf(lib.types.submodule {

     

       107
       107
       +
                       options.exec = lib.mkOption {

     

       110
       108
        
                         example = "YABAR_DATE";

     

       111
       111
       -
                         type = types.str;

     

       109
       109
       +
                         type = lib.types.str;

     

       112
       110
        
                         description = ''

     

       113
       111
        
                            The type of the indicator to be executed.

     

       114
       112
        
                         '';

     

       115
       113
        
                       };

     

       116
       114
        
       

     

       117
       117
       -
                       options.align = mkOption {

     

       115
       115
       +
                       options.align = lib.mkOption {

     

       118
       116
        
                         default = "left";

     

       119
       117
        
                         example = "right";

     

       120
       120
       -
                         type = types.enum [ "left" "center" "right" ];

     

       118
       118
       +
                         type = lib.types.enum [ "left" "center" "right" ];

     

       121
       119
        
       

     

       122
       120
        
                         description = ''

     

       123
       121
        
                           Whether to align the indicator at the left or right of the bar.

     

       124
       122
        
                         '';

     

       125
       123
        
                       };

     

       126
       124
        
       

     

       127
       127
       -
                       options.extra = mkOption {

     

       125
       125
       +
                       options.extra = lib.mkOption {

     

       128
       126
        
                         default = {};

     

       129
       129
       -
                         type = types.attrsOf (types.either types.str types.int);

     

       127
       127
       +
                         type = lib.types.attrsOf (lib.types.either lib.types.str lib.types.int);

     

       130
       128
        
       

     

       131
       129
        
                         description = ''

     

       132
       130
        
                           An attribute set which contains further attributes of a indicator.

     
···

       147
       145
        
             };

     

       148
       146
        
           };

     

       149
       147
        
       

     

       150
       150
       -
           config = mkIf cfg.enable {

     

       148
       148
       +
           config = lib.mkIf cfg.enable {

     

       151
       149
        
             systemd.user.services.yabar = {

     

       152
       150
        
               description = "yabar service";

     

       153
       151
        
               wantedBy = [ "graphical-session.target" ];

+2 -4

nixos/modules/programs/zmap.nix

···

       1
       1
        
       { pkgs, config, lib, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.zmap;

     

       7
       5
        
       in {

     

       8
       6
        
         options.programs.zmap = {

     

       9
       9
       -
           enable = mkEnableOption "ZMap, a network scanner designed for Internet-wide network surveys";

     

       7
       7
       +
           enable = lib.mkEnableOption "ZMap, a network scanner designed for Internet-wide network surveys";

     

       10
       8
        
         };

     

       11
       9
        
       

     

       12
       12
       -
         config = mkIf cfg.enable {

     

       10
       10
       +
         config = lib.mkIf cfg.enable {

     

       13
       11
        
           environment.systemPackages = [ pkgs.zmap ];

     

       14
       12
        
       

     

       15
       13
        
           environment.etc."zmap/blacklist.conf".source = "${pkgs.zmap}/etc/zmap/blacklist.conf";

+25 -27

nixos/modules/programs/zsh/oh-my-zsh.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
       

     

       7
       5
        
         cfg = config.programs.zsh.ohMyZsh;

     
···

       20
       18
        
       

     

       21
       19
        
         custom =

     

       22
       20
        
           if cfg.custom != null then cfg.custom

     

       23
       23
       -
           else if length cfg.customPkgs == 0 then null

     

       21
       21
       +
           else if builtins.length cfg.customPkgs == 0 then null

     

       24
       22
        
           else pkgs.linkFarm "oh-my-zsh-custom" [

     

       25
       23
        
             (mkLinkFarmEntry' "themes")

     

       26
       24
        
             (mkLinkFarmEntry "completions" "site-functions")

     
···

       30
       28
        
       in

     

       31
       29
        
         {

     

       32
       30
        
           imports = [

     

       33
       33
       -
             (mkRenamedOptionModule [ "programs" "zsh" "oh-my-zsh" "enable" ] [ "programs" "zsh" "ohMyZsh" "enable" ])

     

       34
       34
       -
             (mkRenamedOptionModule [ "programs" "zsh" "oh-my-zsh" "theme" ] [ "programs" "zsh" "ohMyZsh" "theme" ])

     

       35
       35
       -
             (mkRenamedOptionModule [ "programs" "zsh" "oh-my-zsh" "custom" ] [ "programs" "zsh" "ohMyZsh" "custom" ])

     

       36
       36
       -
             (mkRenamedOptionModule [ "programs" "zsh" "oh-my-zsh" "plugins" ] [ "programs" "zsh" "ohMyZsh" "plugins" ])

     

       31
       31
       +
             (lib.mkRenamedOptionModule [ "programs" "zsh" "oh-my-zsh" "enable" ] [ "programs" "zsh" "ohMyZsh" "enable" ])

     

       32
       32
       +
             (lib.mkRenamedOptionModule [ "programs" "zsh" "oh-my-zsh" "theme" ] [ "programs" "zsh" "ohMyZsh" "theme" ])

     

       33
       33
       +
             (lib.mkRenamedOptionModule [ "programs" "zsh" "oh-my-zsh" "custom" ] [ "programs" "zsh" "ohMyZsh" "custom" ])

     

       34
       34
       +
             (lib.mkRenamedOptionModule [ "programs" "zsh" "oh-my-zsh" "plugins" ] [ "programs" "zsh" "ohMyZsh" "plugins" ])

     

       37
       35
        
           ];

     

       38
       36
        
       

     

       39
       37
        
           options = {

     

       40
       38
        
             programs.zsh.ohMyZsh = {

     

       41
       41
       -
               enable = mkOption {

     

       42
       42
       -
                 type = types.bool;

     

       39
       39
       +
               enable = lib.mkOption {

     

       40
       40
       +
                 type = lib.types.bool;

     

       43
       41
        
                 default = false;

     

       44
       42
        
                 description = ''

     

       45
       43
        
                   Enable oh-my-zsh.

     

       46
       44
        
                 '';

     

       47
       45
        
               };

     

       48
       46
        
       

     

       49
       49
       -
               package = mkPackageOption pkgs "oh-my-zsh" { };

     

       47
       47
       +
               package = lib.mkPackageOption pkgs "oh-my-zsh" { };

     

       50
       48
        
       

     

       51
       51
       -
               plugins = mkOption {

     

       49
       49
       +
               plugins = lib.mkOption {

     

       52
       50
        
                 default = [];

     

       53
       53
       -
                 type = types.listOf(types.str);

     

       51
       51
       +
                 type = lib.types.listOf(lib.types.str);

     

       54
       52
        
                 description = ''

     

       55
       53
        
                   List of oh-my-zsh plugins

     

       56
       54
        
                 '';

     

       57
       55
        
               };

     

       58
       56
        
       

     

       59
       59
       -
               custom = mkOption {

     

       57
       57
       +
               custom = lib.mkOption {

     

       60
       58
        
                 default = null;

     

       61
       61
       -
                 type = with types; nullOr str;

     

       59
       59
       +
                 type = with lib.types; nullOr str;

     

       62
       60
        
                 description = ''

     

       63
       61
        
                   Path to a custom oh-my-zsh package to override config of oh-my-zsh.

     

       64
       62
        
                   (Can't be used along with `customPkgs`).

     

       65
       63
        
                 '';

     

       66
       64
        
               };

     

       67
       65
        
       

     

       68
       68
       -
               customPkgs = mkOption {

     

       66
       66
       +
               customPkgs = lib.mkOption {

     

       69
       67
        
                 default = [];

     

       70
       70
       -
                 type = types.listOf types.package;

     

       68
       68
       +
                 type = lib.types.listOf lib.types.package;

     

       71
       69
        
                 description = ''

     

       72
       70
        
                   List of custom packages that should be loaded into `oh-my-zsh`.

     

       73
       71
        
                 '';

     

       74
       72
        
               };

     

       75
       73
        
       

     

       76
       76
       -
               theme = mkOption {

     

       74
       74
       +
               theme = lib.mkOption {

     

       77
       75
        
                 default = "";

     

       78
       78
       -
                 type = types.str;

     

       76
       76
       +
                 type = lib.types.str;

     

       79
       77
        
                 description = ''

     

       80
       78
        
                   Name of the theme to be used by oh-my-zsh.

     

       81
       79
        
                 '';

     

       82
       80
        
               };

     

       83
       81
        
       

     

       84
       84
       -
               cacheDir = mkOption {

     

       82
       82
       +
               cacheDir = lib.mkOption {

     

       85
       83
        
                 default = "$HOME/.cache/oh-my-zsh";

     

       86
       86
       -
                 type = types.str;

     

       84
       84
       +
                 type = lib.types.str;

     

       87
       85
        
                 description = ''

     

       88
       86
        
                   Cache directory to be used by `oh-my-zsh`.

     

       89
       87
        
                   Without this option it would default to the read-only nix store.

     
···

       92
       90
        
             };

     

       93
       91
        
           };

     

       94
       92
        
       

     

       95
       95
       -
           config = mkIf cfg.enable {

     

       93
       93
       +
           config = lib.mkIf cfg.enable {

     

       96
       94
        
       

     

       97
       95
        
             # Prevent zsh from overwriting oh-my-zsh's prompt

     

       98
       98
       -
             programs.zsh.promptInit = mkDefault "";

     

       96
       96
       +
             programs.zsh.promptInit = lib.mkDefault "";

     

       99
       97
        
       

     

       100
       98
        
             environment.systemPackages = [ cfg.package ];

     

       101
       99
        
       

     
···

       103
       101
        
               # oh-my-zsh configuration generated by NixOS

     

       104
       102
        
               export ZSH=${cfg.package}/share/oh-my-zsh

     

       105
       103
        
       

     

       106
       106
       -
               ${optionalString (length(cfg.plugins) > 0)

     

       107
       107
       -
                 "plugins=(${concatStringsSep " " cfg.plugins})"

     

       104
       104
       +
               ${lib.optionalString (builtins.length(cfg.plugins) > 0)

     

       105
       105
       +
                 "plugins=(${builtins.concatStringsSep " " cfg.plugins})"

     

       108
       106
        
               }

     

       109
       107
        
       

     

       110
       110
       -
               ${optionalString (custom != null)

     

       108
       108
       +
               ${lib.optionalString (custom != null)

     

       111
       109
        
                 "ZSH_CUSTOM=\"${custom}\""

     

       112
       110
        
               }

     

       113
       111
        
       

     

       114
       114
       -
               ${optionalString (stringLength(cfg.theme) > 0)

     

       112
       112
       +
               ${lib.optionalString (builtins.stringLength(cfg.theme) > 0)

     

       115
       113
        
                 "ZSH_THEME=\"${cfg.theme}\""

     

       116
       114
        
               }

     

       117
       115
        
       

     

       118
       118
       -
               ${optionalString (cfg.cacheDir != null) ''

     

       116
       116
       +
               ${lib.optionalString (cfg.cacheDir != null) ''

     

       119
       117
        
                 if [[ ! -d "${cfg.cacheDir}" ]]; then

     

       120
       118
        
                   mkdir -p "${cfg.cacheDir}"

     

       121
       119
        
                 fi

+3 -5

nixos/modules/programs/zsh/zsh-autoenv.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.zsh.zsh-autoenv;

     

       7
       5
        
       in {

     

       8
       6
        
         options = {

     

       9
       7
        
           programs.zsh.zsh-autoenv = {

     

       10
       10
       -
             enable = mkEnableOption "zsh-autoenv";

     

       11
       11
       -
             package = mkPackageOption pkgs "zsh-autoenv" { };

     

       8
       8
       +
             enable = lib.mkEnableOption "zsh-autoenv";

     

       9
       9
       +
             package = lib.mkPackageOption pkgs "zsh-autoenv" { };

     

       12
       10
        
           };

     

       13
       11
        
         };

     

       14
       12
        
       

     

       15
       15
       -
         config = mkIf cfg.enable {

     

       13
       13
       +
         config = lib.mkIf cfg.enable {

     

       16
       14
        
           programs.zsh.interactiveShellInit = ''

     

       17
       15
        
             source ${cfg.package}/share/zsh-autoenv/autoenv.zsh

     

       18
       16
        
           '';

+15 -17

nixos/modules/programs/zsh/zsh-autosuggestions.nix

···

       1
       1
        
       { config, pkgs, lib, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.zsh.autosuggestions;

     

       7
       5
        
       in

     

       8
       6
        
       {

     

       9
       7
        
         imports = [

     

       10
       10
       -
           (mkRenamedOptionModule [ "programs" "zsh" "enableAutosuggestions" ] [ "programs" "zsh" "autosuggestions" "enable" ])

     

       8
       8
       +
           (lib.mkRenamedOptionModule [ "programs" "zsh" "enableAutosuggestions" ] [ "programs" "zsh" "autosuggestions" "enable" ])

     

       11
       9
        
         ];

     

       12
       10
        
       

     

       13
       11
        
         options.programs.zsh.autosuggestions = {

     

       14
       12
        
       

     

       15
       15
       -
           enable = mkEnableOption "zsh-autosuggestions";

     

       13
       13
       +
           enable = lib.mkEnableOption "zsh-autosuggestions";

     

       16
       14
        
       

     

       17
       17
       -
           highlightStyle = mkOption {

     

       18
       18
       -
             type = types.str;

     

       15
       15
       +
           highlightStyle = lib.mkOption {

     

       16
       16
       +
             type = lib.types.str;

     

       19
       17
        
             default = "fg=8"; # https://github.com/zsh-users/zsh-autosuggestions/tree/v0.4.3#suggestion-highlight-style

     

       20
       18
        
             description = "Highlight style for suggestions ({fore,back}ground color)";

     

       21
       19
        
             example = "fg=cyan";

     

       22
       20
        
           };

     

       23
       21
        
       

     

       24
       24
       -
           strategy = mkOption {

     

       25
       25
       -
             type = types.listOf (types.enum [ "history" "completion" "match_prev_cmd" ]);

     

       22
       22
       +
           strategy = lib.mkOption {

     

       23
       23
       +
             type = lib.types.listOf (lib.types.enum [ "history" "completion" "match_prev_cmd" ]);

     

       26
       24
        
             default = [ "history" ];

     

       27
       25
        
             description = ''

     

       28
       26
        
               `ZSH_AUTOSUGGEST_STRATEGY` is an array that specifies how suggestions should be generated.

     
···

       37
       35
        
             '';

     

       38
       36
        
           };

     

       39
       37
        
       

     

       40
       40
       -
           async = mkOption {

     

       41
       41
       -
             type = types.bool;

     

       38
       38
       +
           async = lib.mkOption {

     

       39
       39
       +
             type = lib.types.bool;

     

       42
       40
        
             default = true;

     

       43
       41
        
             description = "Whether to fetch suggestions asynchronously";

     

       44
       42
        
             example = false;

     

       45
       43
        
           };

     

       46
       44
        
       

     

       47
       47
       -
           extraConfig = mkOption {

     

       48
       48
       -
             type = with types; attrsOf str;

     

       45
       45
       +
           extraConfig = lib.mkOption {

     

       46
       46
       +
             type = lib.types.attrsOf lib.types.str;

     

       49
       47
        
             default = {};

     

       50
       48
        
             description = "Attribute set with additional configuration values";

     

       51
       51
       -
             example = literalExpression ''

     

       49
       49
       +
             example = lib.literalExpression ''

     

       52
       50
        
               {

     

       53
       51
        
                 "ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE" = "20";

     

       54
       52
        
               }

     
···

       57
       55
        
       

     

       58
       56
        
         };

     

       59
       57
        
       

     

       60
       60
       -
         config = mkIf cfg.enable {

     

       58
       58
       +
         config = lib.mkIf cfg.enable {

     

       61
       59
        
       

     

       62
       60
        
           programs.zsh.interactiveShellInit = ''

     

       63
       61
        
             source ${pkgs.zsh-autosuggestions}/share/zsh-autosuggestions/zsh-autosuggestions.zsh

     

       64
       62
        
       

     

       65
       63
        
             export ZSH_AUTOSUGGEST_HIGHLIGHT_STYLE="${cfg.highlightStyle}"

     

       66
       66
       -
             export ZSH_AUTOSUGGEST_STRATEGY=(${concatStringsSep " " cfg.strategy})

     

       67
       67
       -
             ${optionalString (!cfg.async) "unset ZSH_AUTOSUGGEST_USE_ASYNC"}

     

       64
       64
       +
             export ZSH_AUTOSUGGEST_STRATEGY=(${builtins.concatStringsSep " " cfg.strategy})

     

       65
       65
       +
             ${lib.optionalString (!cfg.async) "unset ZSH_AUTOSUGGEST_USE_ASYNC"}

     

       68
       66
        
       

     

       69
       69
       -
             ${concatStringsSep "\n" (mapAttrsToList (key: value: ''export ${key}="${value}"'') cfg.extraConfig)}

     

       67
       67
       +
             ${builtins.concatStringsSep "\n" (lib.mapAttrsToList (key: value: ''export ${key}="${value}"'') cfg.extraConfig)}

     

       70
       68
        
           '';

     

       71
       69
        
       

     

       72
       70
        
         };

+25 -27

nixos/modules/programs/zsh/zsh-syntax-highlighting.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       6
       4
        
         cfg = config.programs.zsh.syntaxHighlighting;

     

       7
       5
        
       in

     

       8
       6
        
       {

     

       9
       7
        
         imports = [

     

       10
       10
       -
           (mkRenamedOptionModule [ "programs" "zsh" "enableSyntaxHighlighting" ] [ "programs" "zsh" "syntaxHighlighting" "enable" ])

     

       11
       11
       -
           (mkRenamedOptionModule [ "programs" "zsh" "syntax-highlighting" "enable" ] [ "programs" "zsh" "syntaxHighlighting" "enable" ])

     

       12
       12
       -
           (mkRenamedOptionModule [ "programs" "zsh" "syntax-highlighting" "highlighters" ] [ "programs" "zsh" "syntaxHighlighting" "highlighters" ])

     

       13
       13
       -
           (mkRenamedOptionModule [ "programs" "zsh" "syntax-highlighting" "patterns" ] [ "programs" "zsh" "syntaxHighlighting" "patterns" ])

     

       8
       8
       +
           (lib.mkRenamedOptionModule [ "programs" "zsh" "enableSyntaxHighlighting" ] [ "programs" "zsh" "syntaxHighlighting" "enable" ])

     

       9
       9
       +
           (lib.mkRenamedOptionModule [ "programs" "zsh" "syntax-highlighting" "enable" ] [ "programs" "zsh" "syntaxHighlighting" "enable" ])

     

       10
       10
       +
           (lib.mkRenamedOptionModule [ "programs" "zsh" "syntax-highlighting" "highlighters" ] [ "programs" "zsh" "syntaxHighlighting" "highlighters" ])

     

       11
       11
       +
           (lib.mkRenamedOptionModule [ "programs" "zsh" "syntax-highlighting" "patterns" ] [ "programs" "zsh" "syntaxHighlighting" "patterns" ])

     

       14
       12
        
         ];

     

       15
       13
        
       

     

       16
       14
        
         options = {

     

       17
       15
        
           programs.zsh.syntaxHighlighting = {

     

       18
       18
       -
             enable = mkEnableOption "zsh-syntax-highlighting";

     

       16
       16
       +
             enable = lib.mkEnableOption "zsh-syntax-highlighting";

     

       19
       17
        
       

     

       20
       20
       -
             highlighters = mkOption {

     

       18
       18
       +
             highlighters = lib.mkOption {

     

       21
       19
        
               default = [ "main" ];

     

       22
       20
        
       

     

       23
       21
        
               # https://github.com/zsh-users/zsh-syntax-highlighting/blob/master/docs/highlighters.md

     

       24
       24
       -
               type = types.listOf(types.enum([

     

       22
       22
       +
               type = lib.types.listOf(lib.types.enum([

     

       25
       23
        
                 "main"

     

       26
       24
        
                 "brackets"

     

       27
       25
        
                 "pattern"

     
···

       39
       37
        
               '';

     

       40
       38
        
             };

     

       41
       39
        
       

     

       42
       42
       -
             patterns = mkOption {

     

       40
       40
       +
             patterns = lib.mkOption {

     

       43
       41
        
               default = {};

     

       44
       44
       -
               type = types.attrsOf types.str;

     

       42
       42
       +
               type = lib.types.attrsOf lib.types.str;

     

       45
       43
        
       

     

       46
       46
       -
               example = literalExpression ''

     

       44
       44
       +
               example = lib.literalExpression ''

     

       47
       45
        
                 {

     

       48
       46
        
                   "rm -rf *" = "fg=white,bold,bg=red";

     

       49
       47
        
                 }

     
···

       56
       54
        
                 https://github.com/zsh-users/zsh-syntax-highlighting/blob/master/docs/highlighters/pattern.md

     

       57
       55
        
               '';

     

       58
       56
        
             };

     

       59
       59
       -
             styles = mkOption {

     

       57
       57
       +
             styles = lib.mkOption {

     

       60
       58
        
               default = {};

     

       61
       61
       -
               type = types.attrsOf types.str;

     

       59
       59
       +
               type = lib.types.attrsOf lib.types.str;

     

       62
       60
        
       

     

       63
       63
       -
               example = literalExpression ''

     

       61
       61
       +
               example = lib.literalExpression ''

     

       64
       62
        
                 {

     

       65
       63
        
                   "alias" = "fg=magenta,bold";

     

       66
       64
        
                 }

     
···

       76
       74
        
           };

     

       77
       75
        
         };

     

       78
       76
        
       

     

       79
       79
       -
         config = mkIf cfg.enable {

     

       80
       80
       -
           environment.systemPackages = with pkgs; [ zsh-syntax-highlighting ];

     

       77
       77
       +
         config = lib.mkIf cfg.enable {

     

       78
       78
       +
           environment.systemPackages = [ pkgs.zsh-syntax-highlighting ];

     

       81
       79
        
       

     

       82
       80
        
           assertions = [

     

       83
       81
        
             {

     

       84
       84
       -
               assertion = length(attrNames cfg.patterns) > 0 -> elem "pattern" cfg.highlighters;

     

       82
       82
       +
               assertion = builtins.length(builtins.attrNames cfg.patterns) > 0 -> builtins.elem "pattern" cfg.highlighters;

     

       85
       83
        
               message = ''

     

       86
       84
        
                 When highlighting patterns, "pattern" needs to be included in the list of highlighters.

     

       87
       85
        
               '';

     

       88
       86
        
             }

     

       89
       87
        
           ];

     

       90
       88
        
       

     

       91
       91
       -
           programs.zsh.interactiveShellInit = with pkgs;

     

       92
       92
       -
             lib.mkAfter (lib.concatStringsSep "\n" ([

     

       93
       93
       -
               "source ${zsh-syntax-highlighting}/share/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh"

     

       94
       94
       -
             ] ++ optional (length(cfg.highlighters) > 0)

     

       95
       95
       -
               "ZSH_HIGHLIGHT_HIGHLIGHTERS=(${concatStringsSep " " cfg.highlighters})"

     

       96
       96
       -
               ++ optionals (length(attrNames cfg.patterns) > 0)

     

       97
       97
       -
                 (mapAttrsToList (

     

       89
       89
       +
           programs.zsh.interactiveShellInit =

     

       90
       90
       +
             lib.lib.mkAfter (lib.concatStringsSep "\n" ([

     

       91
       91
       +
               "source ${pkgs.zsh-syntax-highlighting}/share/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh"

     

       92
       92
       +
             ] ++ lib.optional (builtins.length(cfg.highlighters) > 0)

     

       93
       93
       +
               "ZSH_HIGHLIGHT_HIGHLIGHTERS=(${builtins.concatStringsSep " " cfg.highlighters})"

     

       94
       94
       +
               ++ lib.optionals (builtins.length(builtins.attrNames cfg.patterns) > 0)

     

       95
       95
       +
                 (lib.mapAttrsToList (

     

       98
       96
        
                   pattern: design:

     

       99
       97
        
                   "ZSH_HIGHLIGHT_PATTERNS+=('${pattern}' '${design}')"

     

       100
       98
        
                 ) cfg.patterns)

     

       101
       101
       -
               ++ optionals (length(attrNames cfg.styles) > 0)

     

       102
       102
       -
                 (mapAttrsToList (

     

       99
       99
       +
               ++ lib.optionals (builtins.length(builtins.attrNames cfg.styles) > 0)

     

       100
       100
       +
                 (lib.mapAttrsToList (

     

       103
       101
        
                   styles: design:

     

       104
       102
        
                   "ZSH_HIGHLIGHT_STYLES[${styles}]='${design}'"

     

       105
       103
        
                 ) cfg.styles)

+42 -44

nixos/modules/programs/zsh/zsh.nix

···

       2
       2
        
       

     

       3
       3
        
       { config, lib, options, pkgs, ... }:

     

       4
       4
        
       

     

       5
       5
       -
       with lib;

     

       6
       6
       -
       

     

       7
       5
        
       let

     

       8
       6
        
       

     

       9
       7
        
         cfge = config.environment;

     
···

       11
       9
        
         cfg = config.programs.zsh;

     

       12
       10
        
         opt = options.programs.zsh;

     

       13
       11
        
       

     

       14
       14
       -
         zshAliases = concatStringsSep "\n" (

     

       15
       15
       -
           mapAttrsFlatten (k: v: "alias -- ${k}=${escapeShellArg v}")

     

       16
       16
       -
             (filterAttrs (k: v: v != null) cfg.shellAliases)

     

       12
       12
       +
         zshAliases = builtins.concatStringsSep "\n" (

     

       13
       13
       +
           lib.mapAttrsFlatten (k: v: "alias -- ${k}=${lib.escapeShellArg v}")

     

       14
       14
       +
             (lib.filterAttrs (k: v: v != null) cfg.shellAliases)

     

       17
       15
        
         );

     

       18
       16
        
       

     

       19
       17
        
         zshStartupNotes = ''

     
···

       42
       40
        
       

     

       43
       41
        
           programs.zsh = {

     

       44
       42
        
       

     

       45
       45
       -
             enable = mkOption {

     

       43
       43
       +
             enable = lib.mkOption {

     

       46
       44
        
               default = false;

     

       47
       45
        
               description = ''

     

       48
       46
        
                 Whether to configure zsh as an interactive shell. To enable zsh for

     
···

       50
       48
        
                 option for that user. To enable zsh system-wide use the

     

       51
       49
        
                 {option}`users.defaultUserShell` option.

     

       52
       50
        
               '';

     

       53
       53
       -
               type = types.bool;

     

       51
       51
       +
               type = lib.types.bool;

     

       54
       52
        
             };

     

       55
       53
        
       

     

       56
       56
       -
             shellAliases = mkOption {

     

       54
       54
       +
             shellAliases = lib.mkOption {

     

       57
       55
        
               default = { };

     

       58
       56
        
               description = ''

     

       59
       57
        
                 Set of aliases for zsh shell, which overrides {option}`environment.shellAliases`.

     

       60
       58
        
                 See {option}`environment.shellAliases` for an option format description.

     

       61
       59
        
               '';

     

       62
       62
       -
               type = with types; attrsOf (nullOr (either str path));

     

       60
       60
       +
               type = with lib.types; attrsOf (nullOr (either str path));

     

       63
       61
        
             };

     

       64
       62
        
       

     

       65
       65
       -
             shellInit = mkOption {

     

       63
       63
       +
             shellInit = lib.mkOption {

     

       66
       64
        
               default = "";

     

       67
       65
        
               description = ''

     

       68
       66
        
                 Shell script code called during zsh shell initialisation.

     

       69
       67
        
               '';

     

       70
       70
       -
               type = types.lines;

     

       68
       68
       +
               type = lib.types.lines;

     

       71
       69
        
             };

     

       72
       70
        
       

     

       73
       73
       -
             loginShellInit = mkOption {

     

       71
       71
       +
             loginShellInit = lib.mkOption {

     

       74
       72
        
               default = "";

     

       75
       73
        
               description = ''

     

       76
       74
        
                 Shell script code called during zsh login shell initialisation.

     

       77
       75
        
               '';

     

       78
       78
       -
               type = types.lines;

     

       76
       76
       +
               type = lib.types.lines;

     

       79
       77
        
             };

     

       80
       78
        
       

     

       81
       81
       -
             interactiveShellInit = mkOption {

     

       79
       79
       +
             interactiveShellInit = lib.mkOption {

     

       82
       80
        
               default = "";

     

       83
       81
        
               description = ''

     

       84
       82
        
                 Shell script code called during interactive zsh shell initialisation.

     

       85
       83
        
               '';

     

       86
       86
       -
               type = types.lines;

     

       84
       84
       +
               type = lib.types.lines;

     

       87
       85
        
             };

     

       88
       86
        
       

     

       89
       89
       -
             promptInit = mkOption {

     

       87
       87
       +
             promptInit = lib.mkOption {

     

       90
       88
        
               default = ''

     

       91
       89
        
                 # Note that to manually override this in ~/.zshrc you should run `prompt off`

     

       92
       90
        
                 # before setting your PS1 and etc. Otherwise this will likely to interact with

     
···

       97
       95
        
               description = ''

     

       98
       96
        
                 Shell script code used to initialise the zsh prompt.

     

       99
       97
        
               '';

     

       100
       100
       -
               type = types.lines;

     

       98
       98
       +
               type = lib.types.lines;

     

       101
       99
        
             };

     

       102
       100
        
       

     

       103
       103
       -
             histSize = mkOption {

     

       101
       101
       +
             histSize = lib.mkOption {

     

       104
       102
        
               default = 2000;

     

       105
       103
        
               description = ''

     

       106
       104
        
                 Change history size.

     

       107
       105
        
               '';

     

       108
       108
       -
               type = types.int;

     

       106
       106
       +
               type = lib.types.int;

     

       109
       107
        
             };

     

       110
       108
        
       

     

       111
       111
       -
             histFile = mkOption {

     

       109
       109
       +
             histFile = lib.mkOption {

     

       112
       110
        
               default = "$HOME/.zsh_history";

     

       113
       111
        
               description = ''

     

       114
       112
        
                 Change history file.

     

       115
       113
        
               '';

     

       116
       116
       -
               type = types.str;

     

       114
       114
       +
               type = lib.types.str;

     

       117
       115
        
             };

     

       118
       116
        
       

     

       119
       119
       -
             setOptions = mkOption {

     

       120
       120
       -
               type = types.listOf types.str;

     

       117
       117
       +
             setOptions = lib.mkOption {

     

       118
       118
       +
               type = lib.types.listOf lib.types.str;

     

       121
       119
        
               default = [

     

       122
       120
        
                 "HIST_IGNORE_DUPS"

     

       123
       121
        
                 "SHARE_HISTORY"

     
···

       130
       128
        
               '';

     

       131
       129
        
             };

     

       132
       130
        
       

     

       133
       133
       -
             enableCompletion = mkOption {

     

       131
       131
       +
             enableCompletion = lib.mkOption {

     

       134
       132
        
               default = true;

     

       135
       133
        
               description = ''

     

       136
       134
        
                 Enable zsh completion for all interactive zsh shells.

     

       137
       135
        
               '';

     

       138
       138
       -
               type = types.bool;

     

       136
       136
       +
               type = lib.types.bool;

     

       139
       137
        
             };

     

       140
       138
        
       

     

       141
       141
       -
             enableBashCompletion = mkOption {

     

       139
       139
       +
             enableBashCompletion = lib.mkOption {

     

       142
       140
        
               default = false;

     

       143
       141
        
               description = ''

     

       144
       142
        
                 Enable compatibility with bash's programmable completion system.

     

       145
       143
        
               '';

     

       146
       146
       -
               type = types.bool;

     

       144
       144
       +
               type = lib.types.bool;

     

       147
       145
        
             };

     

       148
       146
        
       

     

       149
       149
       -
             enableGlobalCompInit = mkOption {

     

       147
       147
       +
             enableGlobalCompInit = lib.mkOption {

     

       150
       148
        
               default = cfg.enableCompletion;

     

       151
       151
       -
               defaultText = literalExpression "config.${opt.enableCompletion}";

     

       149
       149
       +
               defaultText = lib.literalExpression "config.${opt.enableCompletion}";

     

       152
       150
        
               description = ''

     

       153
       151
        
                 Enable execution of compinit call for all interactive zsh shells.

     

       154
       152
        
       

     
···

       156
       154
        
                 `fpath` and a custom `compinit`

     

       157
       155
        
                 call in the local config is required.

     

       158
       156
        
               '';

     

       159
       159
       -
               type = types.bool;

     

       157
       157
       +
               type = lib.types.bool;

     

       160
       158
        
             };

     

       161
       159
        
       

     

       162
       162
       -
             enableLsColors = mkOption {

     

       160
       160
       +
             enableLsColors = lib.mkOption {

     

       163
       161
        
               default = true;

     

       164
       162
        
               description = ''

     

       165
       163
        
                 Enable extra colors in directory listings (used by `ls` and `tree`).

     

       166
       164
        
               '';

     

       167
       167
       -
               type = types.bool;

     

       165
       165
       +
               type = lib.types.bool;

     

       168
       166
        
             };

     

       169
       167
        
       

     

       170
       168
        
           };

     

       171
       169
        
       

     

       172
       170
        
         };

     

       173
       171
        
       

     

       174
       174
       -
         config = mkIf cfg.enable {

     

       172
       172
       +
         config = lib.mkIf cfg.enable {

     

       175
       173
        
       

     

       176
       176
       -
           programs.zsh.shellAliases = mapAttrs (name: mkDefault) cfge.shellAliases;

     

       174
       174
       +
           programs.zsh.shellAliases = builtins.mapAttrs (name: lib.mkDefault) cfge.shellAliases;

     

       177
       175
        
       

     

       178
       176
        
           environment.etc.zshenv.text =

     

       179
       177
        
             ''

     
···

       239
       237
        
               if [ -n "$__ETC_ZSHRC_SOURCED" -o -n "$NOSYSZSHRC" ]; then return; fi

     

       240
       238
        
               __ETC_ZSHRC_SOURCED=1

     

       241
       239
        
       

     

       242
       242
       -
               ${optionalString (cfg.setOptions != []) ''

     

       240
       240
       +
               ${lib.optionalString (cfg.setOptions != []) ''

     

       243
       241
        
                 # Set zsh options.

     

       244
       244
       -
                 setopt ${concatStringsSep " " cfg.setOptions}

     

       242
       242
       +
                 setopt ${builtins.concatStringsSep " " cfg.setOptions}

     

       245
       243
        
               ''}

     

       246
       244
        
       

     

       247
       245
        
               # Alternative method of determining short and full hostname.

     
···

       249
       247
        
       

     

       250
       248
        
               # Setup command line history.

     

       251
       249
        
               # Don't export these, otherwise other shells (bash) will try to use same HISTFILE.

     

       252
       252
       -
               SAVEHIST=${toString cfg.histSize}

     

       253
       253
       -
               HISTSIZE=${toString cfg.histSize}

     

       250
       250
       +
               SAVEHIST=${builtins.toString cfg.histSize}

     

       251
       251
       +
               HISTSIZE=${builtins.toString cfg.histSize}

     

       254
       252
        
               HISTFILE=${cfg.histFile}

     

       255
       253
        
       

     

       256
       254
        
               # Configure sane keyboard defaults.

     

       257
       255
        
               . /etc/zinputrc

     

       258
       256
        
       

     

       259
       259
       -
               ${optionalString cfg.enableGlobalCompInit ''

     

       257
       257
       +
               ${lib.optionalString cfg.enableGlobalCompInit ''

     

       260
       258
        
                 # Enable autocompletion.

     

       261
       259
        
                 autoload -U compinit && compinit

     

       262
       260
        
               ''}

     

       263
       261
        
       

     

       264
       264
       -
               ${optionalString cfg.enableBashCompletion ''

     

       262
       262
       +
               ${lib.optionalString cfg.enableBashCompletion ''

     

       265
       263
        
                 # Enable compatibility with bash's completion system.

     

       266
       264
        
                 autoload -U bashcompinit && bashcompinit

     

       267
       265
        
               ''}

     
···

       271
       269
        
       

     

       272
       270
        
               ${cfg.interactiveShellInit}

     

       273
       271
        
       

     

       274
       274
       -
               ${optionalString cfg.enableLsColors ''

     

       272
       272
       +
               ${lib.optionalString cfg.enableLsColors ''

     

       275
       273
        
                 # Extra colors for directory listings.

     

       276
       274
        
                 eval "$(${pkgs.coreutils}/bin/dircolors -b)"

     

       277
       275
        
               ''}

     
···

       302
       300
        
           environment.etc.zinputrc.text = builtins.readFile ./zinputrc;

     

       303
       301
        
       

     

       304
       302
        
           environment.systemPackages = [ pkgs.zsh ]

     

       305
       305
       -
             ++ optional cfg.enableCompletion pkgs.nix-zsh-completions;

     

       303
       303
       +
             ++ lib.optional cfg.enableCompletion pkgs.nix-zsh-completions;

     

       306
       304
        
       

     

       307
       307
       -
           environment.pathsToLink = optional cfg.enableCompletion "/share/zsh";

     

       305
       305
       +
           environment.pathsToLink = lib.optional cfg.enableCompletion "/share/zsh";

     

       308
       306
        
       

     

       309
       309
       -
           #users.defaultUserShell = mkDefault "/run/current-system/sw/bin/zsh";

     

       307
       307
       +
           #users.defaultUserShell = lib.mkDefault "/run/current-system/sw/bin/zsh";

     

       310
       308
        
       

     

       311
       309
        
           environment.shells =

     

       312
       310
        
             [