commit d98322834b496876723a529b92c2f80eeae0a60c · pyrox.dev/nixpkgs

+1 -1

nixos/modules/programs/rust-motd.nix

···

       7
       7
        
         format = pkgs.formats.toml { };

     

       8
       8
        
       in {

     

       9
       9
        
         options.programs.rust-motd = {

     

       10
       10
       -
           enable = mkEnableOption "rust-motd";

     

       10
       10
       +
           enable = mkEnableOption (lib.mdDoc "rust-motd");

     

       11
       11
        
           enableMotdInSSHD = mkOption {

     

       12
       12
        
             default = true;

     

       13
       13
        
             type = types.bool;

+1 -1

nixos/modules/services/continuous-integration/buildkite-agents.nix

···

       9
       9
        
           inherit name;

     

       10
       10
        
           value = mkOption {

     

       11
       11
        
             default = null;

     

       12
       12
       -
             inherit description;

     

       12
       12
       +
             description = lib.mdDoc description;

     

       13
       13
        
             type = types.nullOr types.lines;

     

       14
       14
        
           } // (if example == null then {} else { inherit example; });

     

       15
       15
        
         };

+1 -1

nixos/modules/services/desktops/espanso.nix

···

       6
       6
        
         meta = { maintainers = with lib.maintainers; [ numkem ]; };

     

       7
       7
        
       

     

       8
       8
        
         options = {

     

       9
       9
       -
           services.espanso = { enable = options.mkEnableOption "Espanso"; };

     

       9
       9
       +
           services.espanso = { enable = options.mkEnableOption (lib.mdDoc "Espanso"); };

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         config = mkIf cfg.enable {

+1 -1

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

···

       101
       101
        
           todosrht

     

       102
       102
        
         ]);

     

       103
       103
        
         mkOptionNullOrStr = description: mkOption {

     

       104
       104
       -
           inherit description;

     

       104
       104
       +
           description = lib.mdDoc description;

     

       105
       105
        
           type = with types; nullOr str;

     

       106
       106
        
           default = null;

     

       107
       107
        
         };

+1 -1

nixos/modules/services/monitoring/prometheus/exporters/rtl_433.nix

···

       16
       16
        
                 };

     

       17
       17
        
                 "${field}" = lib.mkOption {

     

       18
       18
        
                   type = int;

     

       19
       19
       -
                   inherit description;

     

       19
       19
       +
                   description = lib.mdDoc description;

     

       20
       20
        
                 };

     

       21
       21
        
                 location = lib.mkOption {

     

       22
       22
        
                   type = str;

+1 -1

nixos/modules/services/monitoring/prometheus/exporters/v2ray.nix

···

       11
       11
        
           v2rayEndpoint = mkOption {

     

       12
       12
        
             type = types.str;

     

       13
       13
        
             default = "127.0.0.1:54321";

     

       14
       14
       -
             description = ''

     

       14
       14
       +
             description = lib.mdDoc ''

     

       15
       15
        
               v2ray grpc api endpoint

     

       16
       16
        
             '';

     

       17
       17
        
           };

+3 -3

nixos/modules/services/networking/i2pd.nix

···

       396
       396
        
             };

     

       397
       397
        
       

     

       398
       398
        
             precomputation.elgamal = mkEnableTrueOption "Precomputed ElGamal tables" // {

     

       399
       399
       -
               description = ''

     

       399
       399
       +
               description = lib.mdDoc ''

     

       400
       400
        
                 Whenever to use precomputated tables for ElGamal.

     

       401
       401
       -
                 <command>i2pd</command> defaults to <literal>false</literal>

     

       401
       401
       +
                 {command}`i2pd` defaults to `false`

     

       402
       402
        
                 to save 64M of memory (and looses some performance).

     

       403
       403
        
       

     

       404
       404
       -
                 We default to <literal>true</literal> as that is what most

     

       404
       404
       +
                 We default to `true` as that is what most

     

       405
       405
        
                 users want anyway.

     

       406
       406
        
               '';

     

       407
       407
        
             };

+4 -4

nixos/modules/services/networking/keepalived/default.nix

···

       268
       268
        
               type = types.nullOr types.path;

     

       269
       269
        
               default = null;

     

       270
       270
        
               example = "/run/keys/keepalived.env";

     

       271
       271
       -
               description = ''

     

       271
       271
       +
               description = lib.mdDoc ''

     

       272
       272
        
                 Environment variables from this file will be interpolated into the

     

       273
       273
       -
                 final config file using envsubst with this syntax: <literal>$ENVIRONMENT</literal>

     

       274
       274
       -
                 or <literal>''${VARIABLE}</literal>.

     

       275
       275
       -
                 The file should contain lines formatted as <literal>SECRET_VAR=SECRET_VALUE</literal>.

     

       273
       273
       +
                 final config file using envsubst with this syntax: `$ENVIRONMENT`

     

       274
       274
       +
                 or `''${VARIABLE}`.

     

       275
       275
       +
                 The file should contain lines formatted as `SECRET_VAR=SECRET_VALUE`.

     

       276
       276
        
                 This is useful to avoid putting secrets into the nix store.

     

       277
       277
        
               '';

     

       278
       278
        
             };

+1 -1

nixos/modules/services/networking/strongswan-swanctl/param-constructors.nix

···

       152
       152
        
           option = mkOption {

     

       153
       153
        
             type = types.attrsOf (types.submodule {options = paramsToOptions params;});

     

       154
       154
        
             default = {};

     

       155
       155
       -
             inherit description;

     

       155
       155
       +
             description = lib.mdDoc description;

     

       156
       156
        
           };

     

       157
       157
        
           render = postfix: attrs:

     

       158
       158
        
             let postfixedAttrs = mapAttrs' (name: nameValuePair "${name}-${postfix}") attrs;

+4 -4

nixos/modules/services/networking/wpa_supplicant.nix

···

       187
       187
        
             };

     

       188
       188
        
       

     

       189
       189
        
             allowAuxiliaryImperativeNetworks = mkEnableOption (lib.mdDoc "support for imperative & declarative networks") // {

     

       190
       190
       -
               description = ''

     

       190
       190
       +
               description = lib.mdDoc ''

     

       191
       191
        
                 Whether to allow configuring networks "imperatively" (e.g. via

     

       192
       192
       -
                 <literal>wpa_supplicant_gui</literal>) and declaratively via

     

       193
       193
       -
                 <xref linkend="opt-networking.wireless.networks"/>.

     

       192
       192
       +
                 `wpa_supplicant_gui`) and declaratively via

     

       193
       193
       +
                 [](#opt-networking.wireless.networks).

     

       194
       194
        
       

     

       195
       195
       -
                 Please note that this adds a custom patch to <literal>wpa_supplicant</literal>.

     

       195
       195
       +
                 Please note that this adds a custom patch to `wpa_supplicant`.

     

       196
       196
        
               '';

     

       197
       197
        
             };

     

       198
       198

+21 -21

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

···

       48
       48
        
       {

     

       49
       49
        
         # interface

     

       50
       50
        
         options.services.dolibarr = {

     

       51
       51
       -
           enable = mkEnableOption "dolibarr";

     

       51
       51
       +
           enable = mkEnableOption (lib.mdDoc "dolibarr");

     

       52
       52
        
       

     

       53
       53
        
           domain = mkOption {

     

       54
       54
        
             type = types.str;

     

       55
       55
        
             default = "localhost";

     

       56
       56
       -
             description = ''

     

       56
       56
       +
             description = lib.mdDoc ''

     

       57
       57
        
               Domain name of your server.

     

       58
       58
        
             '';

     

       59
       59
        
           };

     
···

       61
       61
        
           user = mkOption {

     

       62
       62
        
             type = types.str;

     

       63
       63
        
             default = "dolibarr";

     

       64
       64
       -
             description = ''

     

       64
       64
       +
             description = lib.mdDoc ''

     

       65
       65
        
               User account under which dolibarr runs.

     

       66
       66
        
       

     

       67
       67
       -
               <note><para>

     

       68
       68
       -
                 If left as the default value this user will automatically be created

     

       69
       69
       -
                 on system activation, otherwise you are responsible for

     

       70
       70
       -
                 ensuring the user exists before the dolibarr application starts.

     

       71
       71
       -
               </para></note>

     

       67
       67
       +
               ::: {.note}

     

       68
       68
       +
               If left as the default value this user will automatically be created

     

       69
       69
       +
               on system activation, otherwise you are responsible for

     

       70
       70
       +
               ensuring the user exists before the dolibarr application starts.

     

       71
       71
       +
               :::

     

       72
       72
        
             '';

     

       73
       73
        
           };

     

       74
       74
        
       

     

       75
       75
        
           group = mkOption {

     

       76
       76
        
             type = types.str;

     

       77
       77
        
             default = "dolibarr";

     

       78
       78
       -
             description = ''

     

       78
       78
       +
             description = lib.mdDoc ''

     

       79
       79
        
               Group account under which dolibarr runs.

     

       80
       80
        
       

     

       81
       81
       -
               <note><para>

     

       82
       82
       -
                 If left as the default value this group will automatically be created

     

       83
       83
       -
                 on system activation, otherwise you are responsible for

     

       84
       84
       -
                 ensuring the group exists before the dolibarr application starts.

     

       85
       85
       -
               </para></note>

     

       81
       81
       +
               ::: {.note}

     

       82
       82
       +
               If left as the default value this group will automatically be created

     

       83
       83
       +
               on system activation, otherwise you are responsible for

     

       84
       84
       +
               ensuring the group exists before the dolibarr application starts.

     

       85
       85
       +
               :::

     

       86
       86
        
             '';

     

       87
       87
        
           };

     

       88
       88
        
       

     

       89
       89
        
           stateDir = mkOption {

     

       90
       90
        
             type = types.str;

     

       91
       91
        
             default = "/var/lib/dolibarr";

     

       92
       92
       -
             description = ''

     

       92
       92
       +
             description = lib.mdDoc ''

     

       93
       93
        
               State and configuration directory dolibarr will use.

     

       94
       94
        
             '';

     

       95
       95
        
           };

     
···

       98
       98
        
             host = mkOption {

     

       99
       99
        
               type = types.str;

     

       100
       100
        
               default = "localhost";

     

       101
       101
       -
               description = "Database host address.";

     

       101
       101
       +
               description = lib.mdDoc "Database host address.";

     

       102
       102
        
             };

     

       103
       103
        
             port = mkOption {

     

       104
       104
        
               type = types.port;

     

       105
       105
        
               default = 3306;

     

       106
       106
       -
               description = "Database host port.";

     

       106
       106
       +
               description = lib.mdDoc "Database host port.";

     

       107
       107
        
             };

     

       108
       108
        
             name = mkOption {

     

       109
       109
        
               type = types.str;

     

       110
       110
        
               default = "dolibarr";

     

       111
       111
       -
               description = "Database name.";

     

       111
       111
       +
               description = lib.mdDoc "Database name.";

     

       112
       112
        
             };

     

       113
       113
        
             user = mkOption {

     

       114
       114
        
               type = types.str;

     

       115
       115
        
               default = "dolibarr";

     

       116
       116
       -
               description = "Database username.";

     

       116
       116
       +
               description = lib.mdDoc "Database username.";

     

       117
       117
        
             };

     

       118
       118
        
             passwordFile = mkOption {

     

       119
       119
        
               type = with types; nullOr path;

     

       120
       120
        
               default = null;

     

       121
       121
        
               example = "/run/keys/dolibarr-dbpassword";

     

       122
       122
       -
               description = "Database password file.";

     

       122
       122
       +
               description = lib.mdDoc "Database password file.";

     

       123
       123
        
             };

     

       124
       124
        
             createLocally = mkOption {

     

       125
       125
        
               type = types.bool;

     

       126
       126
        
               default = true;

     

       127
       127
       -
               description = "Create the database and database user locally.";

     

       127
       127
       +
               description = lib.mdDoc "Create the database and database user locally.";

     

       128
       128
        
             };

     

       129
       129
        
           };

     

       130
       130

+28 -28

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

···

       133
       133
        
       in {

     

       134
       134
        
         options.services.writefreely = {

     

       135
       135
        
           enable =

     

       136
       136
       -
             lib.mkEnableOption "Writefreely, build a digital writing community";

     

       136
       136
       +
             lib.mkEnableOption (lib.mdDoc "Writefreely, build a digital writing community");

     

       137
       137
        
       

     

       138
       138
        
           package = lib.mkOption {

     

       139
       139
        
             type = lib.types.package;

     

       140
       140
        
             default = pkgs.writefreely;

     

       141
       141
        
             defaultText = lib.literalExpression "pkgs.writefreely";

     

       142
       142
       -
             description = "Writefreely package to use.";

     

       142
       142
       +
             description = lib.mdDoc "Writefreely package to use.";

     

       143
       143
        
           };

     

       144
       144
        
       

     

       145
       145
        
           stateDir = mkOption {

     

       146
       146
        
             type = types.path;

     

       147
       147
        
             default = "/var/lib/writefreely";

     

       148
       148
       -
             description = "The state directory where keys and data are stored.";

     

       148
       148
       +
             description = lib.mdDoc "The state directory where keys and data are stored.";

     

       149
       149
        
           };

     

       150
       150
        
       

     

       151
       151
        
           user = mkOption {

     

       152
       152
        
             type = types.str;

     

       153
       153
        
             default = "writefreely";

     

       154
       154
       -
             description = "User under which Writefreely is ran.";

     

       154
       154
       +
             description = lib.mdDoc "User under which Writefreely is ran.";

     

       155
       155
        
           };

     

       156
       156
        
       

     

       157
       157
        
           group = mkOption {

     

       158
       158
        
             type = types.str;

     

       159
       159
        
             default = "writefreely";

     

       160
       160
       -
             description = "Group under which Writefreely is ran.";

     

       160
       160
       +
             description = lib.mdDoc "Group under which Writefreely is ran.";

     

       161
       161
        
           };

     

       162
       162
        
       

     

       163
       163
        
           host = mkOption {

     

       164
       164
        
             type = types.str;

     

       165
       165
        
             default = "";

     

       166
       166
       -
             description = "The public host name to serve.";

     

       166
       166
       +
             description = lib.mdDoc "The public host name to serve.";

     

       167
       167
        
             example = "example.com";

     

       168
       168
        
           };

     

       169
       169
        
       

     

       170
       170
        
           settings = mkOption {

     

       171
       171
        
             default = { };

     

       172
       172
       -
             description = ''

     

       173
       173
       -
               Writefreely configuration (<filename>config.ini</filename>). Refer to

     

       174
       174
       -
               <link xlink:href="https://writefreely.org/docs/latest/admin/config" />

     

       172
       172
       +
             description = lib.mdDoc ''

     

       173
       173
       +
               Writefreely configuration ({file}`config.ini`). Refer to

     

       174
       174
       +
               <https://writefreely.org/docs/latest/admin/config>

     

       175
       175
        
               for details.

     

       176
       176
        
             '';

     

       177
       177
        
       

     
···

       183
       183
        
                   theme = mkOption {

     

       184
       184
        
                     type = types.str;

     

       185
       185
        
                     default = "write";

     

       186
       186
       -
                     description = "The theme to apply.";

     

       186
       186
       +
                     description = lib.mdDoc "The theme to apply.";

     

       187
       187
        
                   };

     

       188
       188
        
                 };

     

       189
       189
        
       

     
···

       192
       192
        
                     type = types.port;

     

       193
       193
        
                     default = if cfg.nginx.enable then 18080 else 80;

     

       194
       194
        
                     defaultText = "80";

     

       195
       195
       -
                     description = "The port WriteFreely should listen on.";

     

       195
       195
       +
                     description = lib.mdDoc "The port WriteFreely should listen on.";

     

       196
       196
        
                   };

     

       197
       197
        
                 };

     

       198
       198
        
               };

     
···

       203
       203
        
             type = mkOption {

     

       204
       204
        
               type = types.enum [ "sqlite3" "mysql" ];

     

       205
       205
        
               default = "sqlite3";

     

       206
       206
       -
               description = "The database provider to use.";

     

       206
       206
       +
               description = lib.mdDoc "The database provider to use.";

     

       207
       207
        
             };

     

       208
       208
        
       

     

       209
       209
        
             name = mkOption {

     

       210
       210
        
               type = types.str;

     

       211
       211
        
               default = "writefreely";

     

       212
       212
       -
               description = "The name of the database to store data in.";

     

       212
       212
       +
               description = lib.mdDoc "The name of the database to store data in.";

     

       213
       213
        
             };

     

       214
       214
        
       

     

       215
       215
        
             user = mkOption {

     

       216
       216
        
               type = types.nullOr types.str;

     

       217
       217
        
               default = if cfg.database.type == "mysql" then "writefreely" else null;

     

       218
       218
        
               defaultText = "writefreely";

     

       219
       219
       -
               description = "The database user to connect as.";

     

       219
       219
       +
               description = lib.mdDoc "The database user to connect as.";

     

       220
       220
        
             };

     

       221
       221
        
       

     

       222
       222
        
             passwordFile = mkOption {

     

       223
       223
        
               type = types.nullOr types.path;

     

       224
       224
        
               default = null;

     

       225
       225
       -
               description = "The file to load the database password from.";

     

       225
       225
       +
               description = lib.mdDoc "The file to load the database password from.";

     

       226
       226
        
             };

     

       227
       227
        
       

     

       228
       228
        
             host = mkOption {

     

       229
       229
        
               type = types.str;

     

       230
       230
        
               default = "localhost";

     

       231
       231
       -
               description = "The database host to connect to.";

     

       231
       231
       +
               description = lib.mdDoc "The database host to connect to.";

     

       232
       232
        
             };

     

       233
       233
        
       

     

       234
       234
        
             port = mkOption {

     

       235
       235
        
               type = types.port;

     

       236
       236
        
               default = 3306;

     

       237
       237
       -
               description = "The port used when connecting to the database host.";

     

       237
       237
       +
               description = lib.mdDoc "The port used when connecting to the database host.";

     

       238
       238
        
             };

     

       239
       239
        
       

     

       240
       240
        
             tls = mkOption {

     

       241
       241
        
               type = types.bool;

     

       242
       242
        
               default = false;

     

       243
       243
        
               description =

     

       244
       244
       -
                 "Whether or not TLS should be used for the database connection.";

     

       244
       244
       +
                 lib.mdDoc "Whether or not TLS should be used for the database connection.";

     

       245
       245
        
             };

     

       246
       246
        
       

     

       247
       247
        
             migrate = mkOption {

     

       248
       248
        
               type = types.bool;

     

       249
       249
        
               default = true;

     

       250
       250
        
               description =

     

       251
       251
       -
                 "Whether or not to automatically run migrations on startup.";

     

       251
       251
       +
                 lib.mdDoc "Whether or not to automatically run migrations on startup.";

     

       252
       252
        
             };

     

       253
       253
        
       

     

       254
       254
        
             createLocally = mkOption {

     

       255
       255
        
               type = types.bool;

     

       256
       256
        
               default = false;

     

       257
       257
       -
               description = ''

     

       258
       258
       -
                 When <option>services.writefreely.database.type</option> is set to

     

       259
       259
       -
                 <code>"mysql"</code>, this option will enable the MySQL service locally.

     

       257
       257
       +
               description = lib.mdDoc ''

     

       258
       258
       +
                 When {option}`services.writefreely.database.type` is set to

     

       259
       259
       +
                 `"mysql"`, this option will enable the MySQL service locally.

     

       260
       260
        
               '';

     

       261
       261
        
             };

     

       262
       262
        
           };

     
···

       264
       264
        
           admin = {

     

       265
       265
        
             name = mkOption {

     

       266
       266
        
               type = types.nullOr types.str;

     

       267
       267
       -
               description = "The name of the first admin user.";

     

       267
       267
       +
               description = lib.mdDoc "The name of the first admin user.";

     

       268
       268
        
               default = null;

     

       269
       269
        
             };

     

       270
       270
        
       

     

       271
       271
        
             initialPasswordFile = mkOption {

     

       272
       272
        
               type = types.path;

     

       273
       273
       -
               description = ''

     

       273
       273
       +
               description = lib.mdDoc ''

     

       274
       274
        
                 Path to a file containing the initial password for the admin user.

     

       275
       275
       -
                 If not provided, the default password will be set to <code>nixos</code>.

     

       275
       275
       +
                 If not provided, the default password will be set to `nixos`.

     

       276
       276
        
               '';

     

       277
       277
        
               default = pkgs.writeText "default-admin-pass" "nixos";

     

       278
       278
        
               defaultText = "/nix/store/xxx-default-admin-pass";

     
···

       284
       284
        
               type = types.bool;

     

       285
       285
        
               default = false;

     

       286
       286
        
               description =

     

       287
       287
       -
                 "Whether or not to enable and configure nginx as a proxy for WriteFreely.";

     

       287
       287
       +
                 lib.mdDoc "Whether or not to enable and configure nginx as a proxy for WriteFreely.";

     

       288
       288
        
             };

     

       289
       289
        
       

     

       290
       290
        
             forceSSL = mkOption {

     

       291
       291
        
               type = types.bool;

     

       292
       292
        
               default = false;

     

       293
       293
       -
               description = "Whether or not to force the use of SSL.";

     

       293
       293
       +
               description = lib.mdDoc "Whether or not to force the use of SSL.";

     

       294
       294
        
             };

     

       295
       295
        
           };

     

       296
       296
        
       

     
···

       299
       299
        
               type = types.bool;

     

       300
       300
        
               default = false;

     

       301
       301
        
               description =

     

       302
       302
       -
                 "Whether or not to automatically fetch and configure SSL certs.";

     

       302
       302
       +
                 lib.mdDoc "Whether or not to automatically fetch and configure SSL certs.";

     

       303
       303
        
             };

     

       304
       304
        
           };

     

       305
       305
        
         };

+5 -7

nixos/modules/system/boot/networkd.nix

···

       1257
       1257
        
               default = {};

     

       1258
       1258
        
               example = { Route = "fd00::/64"; };

     

       1259
       1259
        
               type = types.addCheck (types.attrsOf unitOption) check.network.sectionIPv6RoutePrefix;

     

       1260
       1260
       -
               description = ''

     

       1260
       1260
       +
               description = lib.mdDoc ''

     

       1261
       1261
        
                 Each attribute in this set specifies an option in the

     

       1262
       1262
       -
                 <literal>[IPv6RoutePrefix]</literal> section of the unit.  See

     

       1263
       1263
       -
                 <citerefentry><refentrytitle>systemd.network</refentrytitle>

     

       1264
       1264
       -
                 <manvolnum>5</manvolnum></citerefentry> for details.

     

       1262
       1262
       +
                 `[IPv6RoutePrefix]` section of the unit.  See

     

       1263
       1263
       +
                 {manpage}`systemd.network(5)` for details.

     

       1265
       1264
        
               '';

     

       1266
       1265
        
             };

     

       1267
       1266
        
           };

     
···

       1413
       1412
        
             default = [];

     

       1414
       1413
        
             example = [ { ipv6RoutePrefixConfig = { Route = "fd00::/64"; LifetimeSec = 3600; }; } ];

     

       1415
       1414
        
             type = with types; listOf (submodule ipv6RoutePrefixOptions);

     

       1416
       1416
       -
             description = ''

     

       1415
       1415
       +
             description = lib.mdDoc ''

     

       1417
       1416
        
               A list of ipv6RoutePrefix sections to be added to the unit.  See

     

       1418
       1418
       -
               <citerefentry><refentrytitle>systemd.network</refentrytitle>

     

       1419
       1419
       -
               <manvolnum>5</manvolnum></citerefentry> for details.

     

       1417
       1417
       +
               {manpage}`systemd.network(5)` for details.

     

       1420
       1418
        
             '';

     

       1421
       1419
        
           };

     

       1422
       1420

+1 -1

nixos/modules/virtualisation/qemu-vm.nix

···

       584
       584
        
             example = literalExpression ''

     

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

     

       586
       586
        
             '';

     

       587
       587
       -
             description = ''

     

       587
       587
       +
             description = lib.mdDoc ''

     

       588
       588
        
               pkgs set to use for the host-specific packages of the vm runner.

     

       589
       589
        
               Changing this to e.g. a Darwin package set allows running NixOS VMs on Darwin.

     

       590
       590
        
             '';