commit 0ff3b35356b5a57f93b4a7c27ed9ca4c71d388ac · pyrox.dev/nixpkgs

+1 -1

nixos/modules/programs/htop.nix

···

       20
       20
        
           package = mkOption {

     

       21
       21
        
             type = types.package;

     

       22
       22
        
             default = pkgs.htop;

     

       23
       23
       -
             defaultText = "pkgs.htop";

     

       23
       23
       +
             defaultText = lib.literalExpression "pkgs.htop";

     

       24
       24
        
             description = lib.mdDoc ''

     

       25
       25
        
               The htop package that should be used.

     

       26
       26
        
             '';

+1 -1

nixos/modules/programs/weylus.nix

···

       29
       29
        
           package = mkOption {

     

       30
       30
        
             type = package;

     

       31
       31
        
             default = pkgs.weylus;

     

       32
       32
       -
             defaultText = "pkgs.weylus";

     

       32
       32
       +
             defaultText = lib.literalExpression "pkgs.weylus";

     

       33
       33
        
             description = lib.mdDoc "Weylus package to install.";

     

       34
       34
        
           };

     

       35
       35
        
         };

+7 -5

nixos/modules/services/audio/liquidsoap.nix

···

       38
       38
        
       

     

       39
       39
        
             default = {};

     

       40
       40
        
       

     

       41
       41
       -
             example = {

     

       42
       42
       -
               myStream1 = "/etc/liquidsoap/myStream1.liq";

     

       43
       43
       -
               myStream2 = literalExpression "./myStream2.liq";

     

       44
       44
       -
               myStream3 = "out(playlist(\"/srv/music/\"))";

     

       45
       45
       -
             };

     

       41
       41
       +
             example = literalExpression ''

     

       42
       42
       +
               {

     

       43
       43
       +
                 myStream1 = "/etc/liquidsoap/myStream1.liq";

     

       44
       44
       +
                 myStream2 = ./myStream2.liq;

     

       45
       45
       +
                 myStream3 = "out(playlist(\"/srv/music/\"))";

     

       46
       46
       +
               }

     

       47
       47
       +
             '';

     

       46
       48
        
       

     

       47
       49
        
             type = types.attrsOf (types.either types.path types.str);

     

       48
       50
        
           };

+1 -1

nixos/modules/services/databases/clickhouse.nix

···

       16
       16
        
             package = mkOption {

     

       17
       17
        
               type = types.package;

     

       18
       18
        
               default = pkgs.clickhouse;

     

       19
       19
       -
               defaultText = "pkgs.clickhouse";

     

       19
       19
       +
               defaultText = lib.literalExpression "pkgs.clickhouse";

     

       20
       20
        
               description = lib.mdDoc ''

     

       21
       21
        
                 ClickHouse package to use.

     

       22
       22
        
               '';

+6 -4

nixos/modules/services/databases/mysql.nix

···

       160
       160
        
                 List of database names and their initial schemas that should be used to create databases on the first startup

     

       161
       161
        
                 of MySQL. The schema attribute is optional: If not specified, an empty database is created.

     

       162
       162
        
               '';

     

       163
       163
       -
               example = [

     

       164
       164
       -
                 { name = "foodatabase"; schema = literalExpression "./foodatabase.sql"; }

     

       165
       165
       -
                 { name = "bardatabase"; }

     

       166
       166
       -
               ];

     

       163
       163
       +
               example = literalExpression ''

     

       164
       164
       +
                 [

     

       165
       165
       +
                   { name = "foodatabase"; schema = ./foodatabase.sql; }

     

       166
       166
       +
                   { name = "bardatabase"; }

     

       167
       167
       +
                 ]

     

       168
       168
       +
               '';

     

       167
       169
        
             };

     

       168
       170
        
       

     

       169
       171
        
             initialScript = mkOption {

+1 -1

nixos/modules/services/databases/openldap.nix

···

       16
       16
        
             # systemd/systemd#19604

     

       17
       17
        
             description = ''

     

       18
       18
        
               LDAP value - either a string, or an attrset containing

     

       19
       19
       -
               <literal>path</literal> or <literal>base64</literal> for included

     

       19
       19
       +
               `path` or `base64` for included

     

       20
       20
        
               values or base-64 encoded values respectively.

     

       21
       21
        
             '';

     

       22
       22
        
             check = x: lib.isString x || (lib.isAttrs x && (x ? path || x ? base64));

+5 -3

nixos/modules/services/games/asf.nix

···

       43
       43
        
           web-ui = mkOption {

     

       44
       44
        
             type = types.submodule {

     

       45
       45
        
               options = {

     

       46
       46
       -
                 enable = mkEnableOption

     

       47
       47
       -
                   (lib.mdDoc "Wheter to start the web-ui. This is the preferred way of configuring things such as the steam guard token");

     

       46
       46
       +
                 enable = mkEnableOption "" // {

     

       47
       47
       +
                   description = lib.mdDoc "Whether to start the web-ui. This is the preferred way of configuring things such as the steam guard token.";

     

       48
       48
       +
                 };

     

       48
       49
        
       

     

       49
       50
        
                 package = mkOption {

     

       50
       51
        
                   type = types.package;

     

       51
       52
        
                   default = pkgs.ArchiSteamFarm.ui;

     

       53
       53
       +
                   defaultText = lib.literalExpression "pkgs.ArchiSteamFarm.ui";

     

       52
       54
        
                   description =

     

       53
       55
        
                     lib.mdDoc "Web-UI package to use. Contents must be in lib/dist.";

     

       54
       56
        
                 };

     
···

       56
       58
        
             };

     

       57
       59
        
             default = {

     

       58
       60
        
               enable = true;

     

       59
       59
       -
               package = pkgs.ArchiSteamFarm.ui;

     

       60
       61
        
             };

     

       61
       62
        
             example = {

     

       62
       63
        
               enable = false;

     
···

       67
       68
        
           package = mkOption {

     

       68
       69
        
             type = types.package;

     

       69
       70
        
             default = pkgs.ArchiSteamFarm;

     

       71
       71
       +
             defaultText = lib.literalExpression "pkgs.ArchiSteamFarm";

     

       70
       72
        
             description =

     

       71
       73
        
               lib.mdDoc "Package to use. Should always be the latest version, for security reasons, since this module uses very new features and to not get out of sync with the Steam API.";

     

       72
       74
        
           };

+1 -1

nixos/modules/services/games/terraria.nix

···

       116
       116
        
             openFirewall = mkOption {

     

       117
       117
        
               type = types.bool;

     

       118
       118
        
               default = false;

     

       119
       119
       -
               description = lib.mdDoc "Wheter to open ports in the firewall";

     

       119
       119
       +
               description = lib.mdDoc "Whether to open ports in the firewall";

     

       120
       120
        
             };

     

       121
       121
        
       

     

       122
       122
        
             dataDir = mkOption {

+1 -1

nixos/modules/services/hardware/argonone.nix

···

       9
       9
        
           package = lib.mkOption {

     

       10
       10
        
             type = lib.types.package;

     

       11
       11
        
             default = pkgs.argononed;

     

       12
       12
       -
             defaultText = "pkgs.argononed";

     

       12
       12
       +
             defaultText = lib.literalExpression "pkgs.argononed";

     

       13
       13
        
             description = lib.mdDoc ''

     

       14
       14
        
               The package implementing the Argon One driver

     

       15
       15
        
             '';

+1 -1

nixos/modules/services/hardware/joycond.nix

···

       14
       14
        
           package = mkOption {

     

       15
       15
        
             type = types.package;

     

       16
       16
        
             default = pkgs.joycond;

     

       17
       17
       -
             defaultText = "pkgs.joycond";

     

       17
       17
       +
             defaultText = lib.literalExpression "pkgs.joycond";

     

       18
       18
        
             description = lib.mdDoc ''

     

       19
       19
        
               The joycond package to use.

     

       20
       20
        
             '';

+1 -2

nixos/modules/services/matrix/conduit.nix

···

       23
       23
        
             package = mkOption {

     

       24
       24
        
               type = types.package;

     

       25
       25
        
               default = pkgs.matrix-conduit;

     

       26
       26
       -
               defaultText = "pkgs.matrix-conduit";

     

       27
       27
       -
               example = "pkgs.matrix-conduit";

     

       26
       26
       +
               defaultText = lib.literalExpression "pkgs.matrix-conduit";

     

       28
       27
        
               description = lib.mdDoc ''

     

       29
       28
        
                 Package of the conduit matrix server to use.

     

       30
       29
        
               '';

+1

nixos/modules/services/matrix/synapse.nix

···

       286
       286
        
                   log_config = mkOption {

     

       287
       287
        
                     type = types.path;

     

       288
       288
        
                     default = ./synapse-log_config.yaml;

     

       289
       289
       +
                     defaultText = lib.literalExpression "nixos/modules/services/matrix/synapse-log_config.yaml";

     

       289
       290
        
                     description = lib.mdDoc ''

     

       290
       291
        
                       The file that holds the logging configuration.

     

       291
       292
        
                     '';

+2 -2

nixos/modules/services/misc/autorandr.nix

···

       258
       258
        
               type = hooksModule;

     

       259
       259
        
               description = lib.mdDoc "Global hook scripts";

     

       260
       260
        
               default = { };

     

       261
       261
       -
               example = ''

     

       261
       261
       +
               example = literalExpression ''

     

       262
       262
        
                 {

     

       263
       263
        
                   postswitch = {

     

       264
       264
        
                     "notify-i3" = "''${pkgs.i3}/bin/i3-msg restart";

     
···

       279
       279
        
                           exit 1

     

       280
       280
        
                       esac

     

       281
       281
        
                       echo "Xft.dpi: $DPI" | ''${pkgs.xorg.xrdb}/bin/xrdb -merge

     

       282
       282
       -
                     '''

     

       282
       282
       +
                     ''';

     

       283
       283
        
                   };

     

       284
       284
        
                 }

     

       285
       285
        
               '';

+1 -2

nixos/modules/services/misc/heisenbridge.nix

···

       28
       28
        
           package = mkOption {

     

       29
       29
        
             type = types.package;

     

       30
       30
        
             default = pkgs.heisenbridge;

     

       31
       31
       -
             defaultText = "pkgs.heisenbridge";

     

       32
       32
       -
             example = "pkgs.heisenbridge.override { … = …; }";

     

       31
       31
       +
             defaultText = lib.literalExpression "pkgs.heisenbridge";

     

       33
       32
        
             description = lib.mdDoc ''

     

       34
       33
        
               Package of the application to run, exposed for overriding purposes.

     

       35
       34
        
             '';

+2 -2

nixos/modules/services/misc/portunus.nix

···

       29
       29
        
           package = mkOption {

     

       30
       30
        
             type = types.package;

     

       31
       31
        
             default = pkgs.portunus;

     

       32
       32
       -
             defaultText = "pkgs.portunus";

     

       32
       32
       +
             defaultText = lib.literalExpression "pkgs.portunus";

     

       33
       33
        
             description = lib.mdDoc "The Portunus package to use.";

     

       34
       34
        
           };

     

       35
       35
        
       

     
···

       108
       108
        
             package = mkOption {

     

       109
       109
        
               type = types.package;

     

       110
       110
        
               default = pkgs.openldap;

     

       111
       111
       -
               defaultText = "pkgs.openldap";

     

       111
       111
       +
               defaultText = lib.literalExpression "pkgs.openldap";

     

       112
       112
        
               description = lib.mdDoc "The OpenLDAP package to use.";

     

       113
       113
        
             };

     

       114
       114

+1 -1

nixos/modules/services/misc/sourcehut/default.nix

···

       505
       505
        
                   description = lib.mdDoc "Origin URL for API, 100 more than web.";

     

       506
       506
        
                   type = types.str;

     

       507
       507
        
                   default = "http://${cfg.listenAddress}:${toString (cfg.meta.port + 100)}";

     

       508
       508
       -
                   defaultText = ''http://<xref linkend="opt-services.sourcehut.listenAddress"/>:''${toString (<xref linkend="opt-services.sourcehut.meta.port"/> + 100)}'';

     

       508
       508
       +
                   defaultText = lib.literalMD ''`"http://''${`[](#opt-services.sourcehut.listenAddress)`}:''${toString (`[](#opt-services.sourcehut.meta.port)` + 100)}"`'';

     

       509
       509
        
                 };

     

       510
       510
        
                 webhooks = mkOption {

     

       511
       511
        
                   description = lib.mdDoc "The Redis connection used for the webhooks worker.";

+14 -12

nixos/modules/services/monitoring/grafana-agent.nix

···

       16
       16
        
           package = mkOption {

     

       17
       17
        
             type = types.package;

     

       18
       18
        
             default = pkgs.grafana-agent;

     

       19
       19
       -
             defaultText = "pkgs.grafana-agent";

     

       19
       19
       +
             defaultText = lib.literalExpression "pkgs.grafana-agent";

     

       20
       20
        
             description = lib.mdDoc "The grafana-agent package to use.";

     

       21
       21
        
           };

     

       22
       22
        
       

     
···

       49
       49
        
             };

     

       50
       50
        
       

     

       51
       51
        
             default = { };

     

       52
       52
       -
             defaultText = ''

     

       53
       53
       -
               metrics = {

     

       54
       54
       -
                 wal_directory = "\''${STATE_DIRECTORY}";

     

       55
       55
       -
                 global.scrape_interval = "5s";

     

       56
       56
       -
               };

     

       57
       57
       -
               integrations = {

     

       58
       58
       -
                 agent.enabled = true;

     

       59
       59
       -
                 agent.scrape_integration = true;

     

       60
       60
       -
                 node_exporter.enabled = true;

     

       61
       61
       -
                 replace_instance_label = true;

     

       62
       62
       -
               };

     

       52
       52
       +
             defaultText = lib.literalExpression ''

     

       53
       53
       +
               {

     

       54
       54
       +
                 metrics = {

     

       55
       55
       +
                   wal_directory = "\''${STATE_DIRECTORY}";

     

       56
       56
       +
                   global.scrape_interval = "5s";

     

       57
       57
       +
                 };

     

       58
       58
       +
                 integrations = {

     

       59
       59
       +
                   agent.enabled = true;

     

       60
       60
       +
                   agent.scrape_integration = true;

     

       61
       61
       +
                   node_exporter.enabled = true;

     

       62
       62
       +
                   replace_instance_label = true;

     

       63
       63
       +
                 };

     

       64
       64
       +
               }

     

       63
       65
        
             '';

     

       64
       66
        
             example = {

     

       65
       67
        
               metrics.global.remote_write = [{

+1 -2

nixos/modules/services/monitoring/uptime-kuma.nix

···

       13
       13
        
       

     

       14
       14
        
             package = mkOption {

     

       15
       15
        
               type = types.package;

     

       16
       16
       -
               example = literalExpression "pkgs.uptime-kuma";

     

       17
       16
        
               default = pkgs.uptime-kuma;

     

       18
       18
       -
               defaultText = "pkgs.uptime-kuma";

     

       17
       17
       +
               defaultText = literalExpression "pkgs.uptime-kuma";

     

       19
       18
        
               description = lib.mdDoc "Uptime Kuma package to use.";

     

       20
       19
        
             };

     

       21
       20

+1 -1

nixos/modules/services/networking/ddclient.nix

···

       71
       71
        
             package = mkOption {

     

       72
       72
        
               type = package;

     

       73
       73
        
               default = pkgs.ddclient;

     

       74
       74
       -
               defaultText = "pkgs.ddclient";

     

       74
       74
       +
               defaultText = lib.literalExpression "pkgs.ddclient";

     

       75
       75
        
               description = lib.mdDoc ''

     

       76
       76
        
                 The ddclient executable package run by the service.

     

       77
       77
        
               '';

+2 -2

nixos/modules/services/networking/ergochat.nix

···

       17
       17
        
             configFile = lib.mkOption {

     

       18
       18
        
               type = lib.types.path;

     

       19
       19
        
               default = (pkgs.formats.yaml {}).generate "ergo.conf" cfg.settings;

     

       20
       20
       -
               defaultText = "generated config file from <literal>.settings</literal>";

     

       20
       20
       +
               defaultText = lib.literalMD "generated config file from `settings`";

     

       21
       21
        
               description = lib.mdDoc ''

     

       22
       22
        
                 Path to configuration file.

     

       23
       23
       -
                 Setting this will skip any configuration done via `.settings`

     

       23
       23
       +
                 Setting this will skip any configuration done via `settings`

     

       24
       24
        
               '';

     

       25
       25
        
             };

     

       26
       26

+1 -1

nixos/modules/services/networking/multipath.nix

···

       28
       28
        
             type = package;

     

       29
       29
        
             description = lib.mdDoc "multipath-tools package to use";

     

       30
       30
        
             default = pkgs.multipath-tools;

     

       31
       31
       -
             defaultText = "pkgs.multipath-tools";

     

       31
       31
       +
             defaultText = lib.literalExpression "pkgs.multipath-tools";

     

       32
       32
        
           };

     

       33
       33
        
       

     

       34
       34
        
           devices = mkOption {

+1 -1

nixos/modules/services/networking/nomad.nix

···

       67
       67
        
                 Additional plugins dir used to configure nomad.

     

       68
       68
        
               '';

     

       69
       69
        
               example = literalExpression ''

     

       70
       70
       -
                 [ "<pluginDir>" "pkgs.<plugins-name>"]

     

       70
       70
       +
                 [ "<pluginDir>" pkgs.<plugins-name> ]

     

       71
       71
        
               '';

     

       72
       72
        
             };

     

       73
       73

+1 -1

nixos/modules/services/networking/sabnzbd.nix

···

       20
       20
        
             package = mkOption {

     

       21
       21
        
               type = types.package;

     

       22
       22
        
               default = pkgs.sabnzbd;

     

       23
       23
       -
               defaultText = "pkgs.sabnzbd";

     

       23
       23
       +
               defaultText = lib.literalExpression "pkgs.sabnzbd";

     

       24
       24
        
               description = lib.mdDoc "The sabnzbd executable package run by the service.";

     

       25
       25
        
             };

     

       26
       26

+1 -1

nixos/modules/services/search/meilisearch.nix

···

       21
       21
        
           package = mkOption {

     

       22
       22
        
             description = lib.mdDoc "The package to use for meilisearch. Use this if you require specific features to be enabled. The default package has no features.";

     

       23
       23
        
             default = pkgs.meilisearch;

     

       24
       24
       -
             defaultText = "pkgs.meilisearch";

     

       24
       24
       +
             defaultText = lib.literalExpression "pkgs.meilisearch";

     

       25
       25
        
             type = types.package;

     

       26
       26
        
           };

     

       27
       27

+1 -1

nixos/modules/services/security/opensnitch.nix

···

       91
       91
        
                   InterceptUnknown = mkOption {

     

       92
       92
        
                     type = types.bool;

     

       93
       93
        
                     description = mdDoc ''

     

       94
       94
       -
                       Wheter to intercept spare connections.

     

       94
       94
       +
                       Whether to intercept spare connections.

     

       95
       95
        
                     '';

     

       96
       96
        
                   };

     

       97
       97

+1 -1

nixos/modules/services/web-apps/code-server.nix

···

       15
       15
        
       

     

       16
       16
        
             package = mkOption {

     

       17
       17
        
               default = pkgs.code-server;

     

       18
       18
       -
               defaultText = "pkgs.code-server";

     

       18
       18
       +
               defaultText = lib.literalExpression "pkgs.code-server";

     

       19
       19
        
               description = lib.mdDoc "Which code-server derivation to use.";

     

       20
       20
        
               type = types.package;

     

       21
       21
        
             };

+1 -1

nixos/modules/services/web-apps/invidious.nix

···

       151
       151
        
           package = lib.mkOption {

     

       152
       152
        
             type = types.package;

     

       153
       153
        
             default = pkgs.invidious;

     

       154
       154
       -
             defaultText = "pkgs.invidious";

     

       154
       154
       +
             defaultText = lib.literalExpression "pkgs.invidious";

     

       155
       155
        
             description = lib.mdDoc "The Invidious package to use.";

     

       156
       156
        
           };

     

       157
       157

+2 -2

nixos/modules/services/web-apps/mattermost.nix

···

       106
       106
        
             package = mkOption {

     

       107
       107
        
               type = types.package;

     

       108
       108
        
               default = pkgs.mattermost;

     

       109
       109
       -
               defaultText = "pkgs.mattermost";

     

       109
       109
       +
               defaultText = lib.literalExpression "pkgs.mattermost";

     

       110
       110
        
               description = lib.mdDoc "Mattermost derivation to use.";

     

       111
       111
        
             };

     

       112
       112
        
       

     
···

       238
       238
        
               package = mkOption {

     

       239
       239
        
                 type = types.package;

     

       240
       240
        
                 default = pkgs.matterircd;

     

       241
       241
       -
                 defaultText = "pkgs.matterircd";

     

       241
       241
       +
                 defaultText = lib.literalExpression "pkgs.matterircd";

     

       242
       242
        
                 description = lib.mdDoc "matterircd derivation to use.";

     

       243
       243
        
               };

     

       244
       244
        
               parameters = mkOption {

+1 -1

nixos/modules/services/web-apps/onlyoffice.nix

···

       29
       29
        
           package = mkOption {

     

       30
       30
        
             type = types.package;

     

       31
       31
        
             default = pkgs.onlyoffice-documentserver;

     

       32
       32
       -
             defaultText = "pkgs.onlyoffice-documentserver";

     

       32
       32
       +
             defaultText = lib.literalExpression "pkgs.onlyoffice-documentserver";

     

       33
       33
        
             description = lib.mdDoc "Which package to use for the OnlyOffice instance.";

     

       34
       34
        
           };

     

       35
       35

+1 -1

nixos/modules/services/web-servers/lighttpd/default.nix

···

       137
       137
        
       

     

       138
       138
        
             package = mkOption {

     

       139
       139
        
               default = pkgs.lighttpd;

     

       140
       140
       -
               defaultText = "pkgs.lighttpd";

     

       140
       140
       +
               defaultText = lib.literalExpression "pkgs.lighttpd";

     

       141
       141
        
               type = types.package;

     

       142
       142
        
               description = lib.mdDoc ''

     

       143
       143
        
                 lighttpd package to use.

+5 -4

nixos/modules/virtualisation/qemu-vm.nix

···

       580
       580
        
           virtualisation.host.pkgs = mkOption {

     

       581
       581
        
             type = options.nixpkgs.pkgs.type;

     

       582
       582
        
             default = pkgs;

     

       583
       583
       -
             defaultText = "pkgs";

     

       583
       583
       +
             defaultText = literalExpression "pkgs";

     

       584
       584
        
             example = literalExpression ''

     

       585
       585
        
               import pkgs.path { system = "x86_64-darwin"; }

     

       586
       586
        
             '';

     
···

       595
       595
        
               mkOption {

     

       596
       596
        
                 type = types.package;

     

       597
       597
        
                 default = cfg.host.pkgs.qemu_kvm;

     

       598
       598
       -
                 example = "pkgs.qemu_test";

     

       598
       598
       +
                 defaultText = literalExpression "config.virtualisation.host.pkgs.qemu_kvm";

     

       599
       599
       +
                 example = literalExpression "pkgs.qemu_test";

     

       599
       600
        
                 description = lib.mdDoc "QEMU package to use.";

     

       600
       601
        
               };

     

       601
       602
        
       

     
···

       721
       722
        
             firmware = mkOption {

     

       722
       723
        
               type = types.path;

     

       723
       724
        
               default = pkgs.OVMF.firmware;

     

       724
       724
       -
               defaultText = "pkgs.OVMF.firmware";

     

       725
       725
       +
               defaultText = literalExpression "pkgs.OVMF.firmware";

     

       725
       726
        
               description =

     

       726
       727
        
                 lib.mdDoc ''

     

       727
       728
        
                   Firmware binary for EFI implementation, defaults to OVMF.

     
···

       731
       732
        
             variables = mkOption {

     

       732
       733
        
               type = types.path;

     

       733
       734
        
               default = pkgs.OVMF.variables;

     

       734
       734
       -
               defaultText = "pkgs.OVMF.variables";

     

       735
       735
       +
               defaultText = literalExpression "pkgs.OVMF.variables";

     

       735
       736
        
               description =

     

       736
       737
        
                 lib.mdDoc ''

     

       737
       738
        
                   Platform-specific flash binary for EFI variables, implementation-dependent to the EFI firmware.