commit 03b81d1befa696f03d68d1d7a59f800e6ab3516e · pyrox.dev/nixpkgs

+12

maintainers/maintainer-list.nix

···

       3741
       3741
        
           githubId = 130903;

     

       3742
       3742
        
           name = "Ana Hobden";

     

       3743
       3743
        
         };

     

       3744
       3744
       +
         holgerpeters = {

     

       3745
       3745
       +
           name = "Holger Peters";

     

       3746
       3746
       +
           email = "holger.peters@posteo.de";

     

       3747
       3747
       +
           github = "HolgerPeters";

     

       3748
       3748
       +
           githubId = 4097049;

     

       3749
       3749
       +
         };

     

       3744
       3750
        
         hrdinka = {

     

       3745
       3751
        
           email = "c.nix@hrdinka.at";

     

       3746
       3752
        
           github = "hrdinka";

     
···

       8654
       8660
        
           github = "spacekookie";

     

       8655
       8661
        
           githubId = 7669898;

     

       8656
       8662
        
           name = "Katharina Fey";

     

       8663
       8663
       +
         };

     

       8664
       8664
       +
         spease = {

     

       8665
       8665
       +
           email = "peasteven@gmail.com";

     

       8666
       8666
       +
           github = "spease";

     

       8667
       8667
       +
           githubId = 2825204;

     

       8668
       8668
       +
           name = "Steven Pease";

     

       8657
       8669
        
         };

     

       8658
       8670
        
         spencerjanssen = {

     

       8659
       8671
        
           email = "spencerjanssen@gmail.com";

+1

nixos/modules/services/cluster/k3s/default.nix

···

       47
       47
        
       

     

       48
       48
        
           extraFlags = mkOption {

     

       49
       49
        
             description = "Extra flags to pass to the k3s command.";

     

       50
       50
       +
             type = types.str;

     

       50
       51
        
             default = "";

     

       51
       52
        
             example = "--no-deploy traefik --cluster-cidr 10.24.0.0/16";

     

       52
       53
        
           };

+2

nixos/modules/services/mail/postfix.nix

···

       560
       560
        
       

     

       561
       561
        
             transport = mkOption {

     

       562
       562
        
               default = "";

     

       563
       563
       +
               type = types.lines;

     

       563
       564
        
               description = "

     

       564
       565
        
                 Entries for the transport map, cf. man-page transport(8).

     

       565
       566
        
               ";

     
···

       573
       574
        
       

     

       574
       575
        
             dnsBlacklistOverrides = mkOption {

     

       575
       576
        
               default = "";

     

       577
       577
       +
               type = types.lines;

     

       576
       578
        
               description = "contents of check_client_access for overriding dnsBlacklists";

     

       577
       579
        
             };

     

       578
       580

+1

nixos/modules/services/misc/rippled.nix

···

       389
       389
        
       

     

       390
       390
        
             extraConfig = mkOption {

     

       391
       391
        
               default = "";

     

       392
       392
       +
               type = types.lines;

     

       392
       393
        
               description = ''

     

       393
       394
        
                 Extra lines to be added verbatim to the rippled.cfg configuration file.

     

       394
       395
        
               '';

+1

nixos/modules/services/misc/svnserve.nix

···

       24
       24
        
             };

     

       25
       25
        
       

     

       26
       26
        
             svnBaseDir = mkOption {

     

       27
       27
       +
               type = types.str;

     

       27
       28
        
               default = "/repos";

     

       28
       29
        
               description = "Base directory from which Subversion repositories are accessed.";

     

       29
       30
        
             };

+5

nixos/modules/services/misc/synergy.nix

···

       23
       23
        
       

     

       24
       24
        
               screenName = mkOption {

     

       25
       25
        
                 default = "";

     

       26
       26
       +
                 type = types.str;

     

       26
       27
        
                 description = ''

     

       27
       28
        
                   Use the given name instead of the hostname to identify

     

       28
       29
        
                   ourselves to the server.

     

       29
       30
        
                 '';

     

       30
       31
        
               };

     

       31
       32
        
               serverAddress = mkOption {

     

       33
       33
       +
                 type = types.str;

     

       32
       34
        
                 description = ''

     

       33
       35
        
                   The server address is of the form: [hostname][:port].  The

     

       34
       36
        
                   hostname must be the address or hostname of the server.  The

     
···

       46
       48
        
               enable = mkEnableOption "the Synergy server (send keyboard and mouse events)";

     

       47
       49
        
       

     

       48
       50
        
               configFile = mkOption {

     

       51
       51
       +
                 type = types.path;

     

       49
       52
        
                 default = "/etc/synergy-server.conf";

     

       50
       53
        
                 description = "The Synergy server configuration file.";

     

       51
       54
        
               };

     

       52
       55
        
               screenName = mkOption {

     

       56
       56
       +
                 type = types.str;

     

       53
       57
        
                 default = "";

     

       54
       58
        
                 description = ''

     

       55
       59
        
                   Use the given name instead of the hostname to identify

     
···

       57
       61
        
                 '';

     

       58
       62
        
               };

     

       59
       63
        
               address = mkOption {

     

       64
       64
       +
                 type = types.str;

     

       60
       65
        
                 default = "";

     

       61
       66
        
                 description = "Address on which to listen for clients.";

     

       62
       67
        
               };

+1

nixos/modules/services/misc/weechat.nix

···

       20
       20
        
             type = types.str;

     

       21
       21
        
           };

     

       22
       22
        
           binary = mkOption {

     

       23
       23
       +
             type = types.path;

     

       23
       24
        
             description = "Binary to execute (by default \${weechat}/bin/weechat).";

     

       24
       25
        
             example = literalExample ''

     

       25
       26
        
               ''${pkgs.weechat}/bin/weechat-headless

+3

nixos/modules/services/network-filesystems/netatalk.nix

···

       46
       46
        
             enable = mkEnableOption "the Netatalk AFP fileserver";

     

       47
       47
        
       

     

       48
       48
        
             port = mkOption {

     

       49
       49
       +
               type = types.port;

     

       49
       50
        
               default = 548;

     

       50
       51
        
               description = "TCP port to be used for AFP.";

     

       51
       52
        
             };

     
···

       68
       69
        
               };

     

       69
       70
        
       

     

       70
       71
        
               path = mkOption {

     

       72
       72
       +
                 type = types.str;

     

       71
       73
        
                 default = "";

     

       72
       74
        
                 example = "afp-data";

     

       73
       75
        
                 description = "Share not the whole user home but this subdirectory path.";

     
···

       75
       77
        
       

     

       76
       78
        
               basedirRegex = mkOption {

     

       77
       79
        
                 example = "/home";

     

       80
       80
       +
                 type = types.str;

     

       78
       81
        
                 description = "Regex which matches the parent directory of the user homes.";

     

       79
       82
        
               };

     

       80
       83

+1

nixos/modules/services/network-filesystems/openafs/server.nix

···

       61
       61
        
             };

     

       62
       62
        
       

     

       63
       63
        
             advertisedAddresses = mkOption {

     

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

     

       64
       65
        
               default = [];

     

       65
       66
        
               description = "List of IP addresses this server is advertised under. See NetInfo(5)";

     

       66
       67
        
             };

+15

nixos/modules/services/network-filesystems/xtreemfs.nix

···

       92
       92
        
             enable = mkEnableOption "XtreemFS";

     

       93
       93
        
       

     

       94
       94
        
             homeDir = mkOption {

     

       95
       95
       +
               type = types.path;

     

       95
       96
        
               default = "/var/lib/xtreemfs";

     

       96
       97
        
               description = ''

     

       97
       98
        
                 XtreemFS home dir for the xtreemfs user.

     
···

       109
       110
        
       

     

       110
       111
        
               uuid = mkOption {

     

       111
       112
        
                 example = "eacb6bab-f444-4ebf-a06a-3f72d7465e40";

     

       113
       113
       +
                 type = types.str;

     

       112
       114
        
                 description = ''

     

       113
       115
        
                   Must be set to a unique identifier, preferably a UUID according to

     

       114
       116
        
                   RFC 4122. UUIDs can be generated with `uuidgen` command, found in

     
···

       117
       119
        
               };

     

       118
       120
        
               port = mkOption {

     

       119
       121
        
                 default = 32638;

     

       122
       122
       +
                 type = types.port;

     

       120
       123
        
                 description = ''

     

       121
       124
        
                   The port to listen on for incoming connections (TCP).

     

       122
       125
        
                 '';

     

       123
       126
        
               };

     

       124
       127
        
               address = mkOption {

     

       128
       128
       +
                 type = types.str;

     

       125
       129
        
                 example = "127.0.0.1";

     

       126
       130
        
                 default = "";

     

       127
       131
        
                 description = ''

     
···

       131
       135
        
               };

     

       132
       136
        
               httpPort = mkOption {

     

       133
       137
        
                 default = 30638;

     

       138
       138
       +
                 type = types.port;

     

       134
       139
        
                 description = ''

     

       135
       140
        
                   Specifies the listen port for the HTTP service that returns the

     

       136
       141
        
                   status page.

     

       137
       142
        
                 '';

     

       138
       143
        
               };

     

       139
       144
        
               syncMode = mkOption {

     

       145
       145
       +
                 type = types.enum [ "ASYNC" "SYNC_WRITE_METADATA" "SYNC_WRITE" "FDATASYNC" "ASYNC" ];

     

       140
       146
        
                 default = "FSYNC";

     

       141
       147
        
                 example = "FDATASYNC";

     

       142
       148
        
                 description = ''

     
···

       229
       235
        
       

     

       230
       236
        
               uuid = mkOption {

     

       231
       237
        
                 example = "eacb6bab-f444-4ebf-a06a-3f72d7465e41";

     

       238
       238
       +
                 type = types.str;

     

       232
       239
        
                 description = ''

     

       233
       240
        
                   Must be set to a unique identifier, preferably a UUID according to

     

       234
       241
        
                   RFC 4122. UUIDs can be generated with `uuidgen` command, found in

     
···

       237
       244
        
               };

     

       238
       245
        
               port = mkOption {

     

       239
       246
        
                 default = 32636;

     

       247
       247
       +
                 type = types.port;

     

       240
       248
        
                 description = ''

     

       241
       249
        
                   The port to listen on for incoming connections (TCP).

     

       242
       250
        
                 '';

     

       243
       251
        
               };

     

       244
       252
        
               address = mkOption {

     

       245
       253
        
                 example = "127.0.0.1";

     

       254
       254
       +
                 type = types.str;

     

       246
       255
        
                 default = "";

     

       247
       256
        
                 description = ''

     

       248
       257
        
                   If specified, it defines the interface to listen on. If not

     
···

       251
       260
        
               };

     

       252
       261
        
               httpPort = mkOption {

     

       253
       262
        
                 default = 30636;

     

       263
       263
       +
                 type = types.port;

     

       254
       264
        
                 description = ''

     

       255
       265
        
                   Specifies the listen port for the HTTP service that returns the

     

       256
       266
        
                   status page.

     
···

       258
       268
        
               };

     

       259
       269
        
               syncMode = mkOption {

     

       260
       270
        
                 default = "FSYNC";

     

       271
       271
       +
                 type = types.enum [ "ASYNC" "SYNC_WRITE_METADATA" "SYNC_WRITE" "FDATASYNC" "ASYNC" ];

     

       261
       272
        
                 example = "FDATASYNC";

     

       262
       273
        
                 description = ''

     

       263
       274
        
                   The sync mode influences how operations are committed to the disk

     
···

       367
       378
        
       

     

       368
       379
        
               uuid = mkOption {

     

       369
       380
        
                 example = "eacb6bab-f444-4ebf-a06a-3f72d7465e42";

     

       381
       381
       +
                 type = types.str;

     

       370
       382
        
                 description = ''

     

       371
       383
        
                   Must be set to a unique identifier, preferably a UUID according to

     

       372
       384
        
                   RFC 4122. UUIDs can be generated with `uuidgen` command, found in

     
···

       375
       387
        
               };

     

       376
       388
        
               port = mkOption {

     

       377
       389
        
                 default = 32640;

     

       390
       390
       +
                 type = types.port;

     

       378
       391
        
                 description = ''

     

       379
       392
        
                   The port to listen on for incoming connections (TCP and UDP).

     

       380
       393
        
                 '';

     

       381
       394
        
               };

     

       382
       395
        
               address = mkOption {

     

       383
       396
        
                 example = "127.0.0.1";

     

       397
       397
       +
                 type = types.str;

     

       384
       398
        
                 default = "";

     

       385
       399
        
                 description = ''

     

       386
       400
        
                   If specified, it defines the interface to listen on. If not

     
···

       389
       403
        
               };

     

       390
       404
        
               httpPort = mkOption {

     

       391
       405
        
                 default = 30640;

     

       406
       406
       +
                 type = types.port;

     

       392
       407
        
                 description = ''

     

       393
       408
        
                   Specifies the listen port for the HTTP service that returns the

     

       394
       409
        
                   status page.

+2

nixos/modules/services/network-filesystems/yandex-disk.nix

···

       46
       46
        
       

     

       47
       47
        
             user = mkOption {

     

       48
       48
        
               default = null;

     

       49
       49
       +
               type = types.nullOr types.str;

     

       49
       50
        
               description = ''

     

       50
       51
        
                 The user the yandex-disk daemon should run as.

     

       51
       52
        
               '';

     

       52
       53
        
             };

     

       53
       54
        
       

     

       54
       55
        
             directory = mkOption {

     

       56
       56
       +
               type = types.path;

     

       55
       57
        
               default = "/home/Yandex.Disk";

     

       56
       58
        
               description = "The directory to use for Yandex.Disk storage";

     

       57
       59
        
             };

+34 -2

nixos/modules/services/networking/bind.nix

···

       8
       8
        
       

     

       9
       9
        
         bindUser = "named";

     

       10
       10
        
       

     

       11
       11
       +
         bindZoneOptions = {

     

       12
       12
       +
           name = mkOption {

     

       13
       13
       +
             type = types.str;

     

       14
       14
       +
             description = "Name of the zone.";

     

       15
       15
       +
           };

     

       16
       16
       +
           master = mkOption {

     

       17
       17
       +
             description = "Master=false means slave server";

     

       18
       18
       +
             type = types.bool;

     

       19
       19
       +
           };

     

       20
       20
       +
           file = mkOption {

     

       21
       21
       +
             type = types.either types.str types.path;

     

       22
       22
       +
             description = "Zone file resource records contain columns of data, separated by whitespace, that define the record.";

     

       23
       23
       +
           };

     

       24
       24
       +
           masters = mkOption {

     

       25
       25
       +
             type = types.listOf types.str;

     

       26
       26
       +
             description = "List of servers for inclusion in stub and secondary zones.";

     

       27
       27
       +
           };

     

       28
       28
       +
           slaves = mkOption {

     

       29
       29
       +
             type = types.listOf types.str;

     

       30
       30
       +
             description = "Addresses who may request zone transfers.";

     

       31
       31
       +
             default = [];

     

       32
       32
       +
           };

     

       33
       33
       +
           extraConfig = mkOption {

     

       34
       34
       +
             type = types.str;

     

       35
       35
       +
             description = "Extra zone config to be appended at the end of the zone section.";

     

       36
       36
       +
             default = "";

     

       37
       37
       +
           };

     

       38
       38
       +
         };

     

       39
       39
       +
       

     

       11
       40
        
         confFile = pkgs.writeText "named.conf"

     

       12
       41
        
           ''

     

       13
       42
        
             include "/etc/bind/rndc.key";

     
···

       72
       101
        
       

     

       73
       102
        
             cacheNetworks = mkOption {

     

       74
       103
        
               default = ["127.0.0.0/24"];

     

       104
       104
       +
               type = types.listOf types.str;

     

       75
       105
        
               description = "

     

       76
       106
        
                 What networks are allowed to use us as a resolver.  Note

     

       77
       107
        
                 that this is for recursive queries -- all networks are

     
···

       83
       113
        
       

     

       84
       114
        
             blockedNetworks = mkOption {

     

       85
       115
        
               default = [];

     

       116
       116
       +
               type = types.listOf types.str;

     

       86
       117
        
               description = "

     

       87
       118
        
                 What networks are just blocked.

     

       88
       119
        
               ";

     
···

       90
       121
        
       

     

       91
       122
        
             ipv4Only = mkOption {

     

       92
       123
        
               default = false;

     

       124
       124
       +
               type = types.bool;

     

       93
       125
        
               description = "

     

       94
       126
        
                 Only use ipv4, even if the host supports ipv6.

     

       95
       127
        
               ";

     
···

       97
       129
        
       

     

       98
       130
        
             forwarders = mkOption {

     

       99
       131
        
               default = config.networking.nameservers;

     

       132
       132
       +
               type = types.listOf types.str;

     

       100
       133
        
               description = "

     

       101
       134
        
                 List of servers we should forward requests to.

     

       102
       135
        
               ";

     
···

       120
       153
        
       

     

       121
       154
        
             zones = mkOption {

     

       122
       155
        
               default = [];

     

       156
       156
       +
               type = types.listOf (types.submodule [ { options = bindZoneOptions; } ]);

     

       123
       157
        
               description = "

     

       124
       158
        
                 List of zones we claim authority over.

     

       125
       125
       -
                   master=false means slave server; slaves means addresses

     

       126
       126
       -
                  who may request zone transfer.

     

       127
       159
        
               ";

     

       128
       160
        
               example = [{

     

       129
       161
        
                 name = "example.com";

+8

nixos/modules/services/networking/ircd-hybrid/default.nix

···

       40
       40
        
       

     

       41
       41
        
             serverName = mkOption {

     

       42
       42
        
               default = "hades.arpa";

     

       43
       43
       +
               type = types.str;

     

       43
       44
        
               description = "

     

       44
       45
        
                 IRCD server name.

     

       45
       46
        
               ";

     
···

       47
       48
        
       

     

       48
       49
        
             sid = mkOption {

     

       49
       50
        
               default = "0NL";

     

       51
       51
       +
               type = types.str;

     

       50
       52
        
               description = "

     

       51
       53
        
                 IRCD server unique ID in a net of servers.

     

       52
       54
        
               ";

     
···

       54
       56
        
       

     

       55
       57
        
             description = mkOption {

     

       56
       58
        
               default = "Hybrid-7 IRC server.";

     

       59
       59
       +
               type = types.str;

     

       57
       60
        
               description = "

     

       58
       61
        
                 IRCD server description.

     

       59
       62
        
               ";

     
···

       62
       65
        
             rsaKey = mkOption {

     

       63
       66
        
               default = null;

     

       64
       67
        
               example = literalExample "/root/certificates/irc.key";

     

       68
       68
       +
               type = types.nullOr types.path;

     

       65
       69
        
               description = "

     

       66
       70
        
                 IRCD server RSA key.

     

       67
       71
        
               ";

     
···

       70
       74
        
             certificate = mkOption {

     

       71
       75
        
               default = null;

     

       72
       76
        
               example = literalExample "/root/certificates/irc.pem";

     

       77
       77
       +
               type = types.nullOr types.path;

     

       73
       78
        
               description = "

     

       74
       79
        
                 IRCD server SSL certificate. There are some limitations - read manual.

     

       75
       80
        
               ";

     
···

       77
       82
        
       

     

       78
       83
        
             adminEmail = mkOption {

     

       79
       84
        
               default = "<bit-bucket@example.com>";

     

       85
       85
       +
               type = types.str;

     

       80
       86
        
               example = "<name@domain.tld>";

     

       81
       87
        
               description = "

     

       82
       88
        
                 IRCD server administrator e-mail.

     
···

       86
       92
        
             extraIPs = mkOption {

     

       87
       93
        
               default = [];

     

       88
       94
        
               example = ["127.0.0.1"];

     

       95
       95
       +
               type = types.listOf types.str;

     

       89
       96
        
               description = "

     

       90
       97
        
                 Extra IP's to bind.

     

       91
       98
        
               ";

     
···

       93
       100
        
       

     

       94
       101
        
             extraPort = mkOption {

     

       95
       102
        
               default = "7117";

     

       103
       103
       +
               type = types.str;

     

       96
       104
        
               description = "

     

       97
       105
        
                 Extra port to avoid filtering.

     

       98
       106
        
               ";

+3 -1

nixos/modules/services/networking/mailpile.nix

···

       21
       21
        
             enable = mkEnableOption "Mailpile the mail client";

     

       22
       22
        
       

     

       23
       23
        
             hostname = mkOption {

     

       24
       24
       +
               type = types.str;

     

       24
       25
        
               default = "localhost";

     

       25
       26
        
               description = "Listen to this hostname or ip.";

     

       26
       27
        
             };

     

       27
       28
        
             port = mkOption {

     

       28
       28
       -
               default = "33411";

     

       29
       29
       +
               type = types.port;

     

       30
       30
       +
               default = 33411;

     

       29
       31
        
               description = "Listen on this port.";

     

       30
       32
        
             };

     

       31
       33
        
           };

+2 -1

nixos/modules/services/networking/prayer.nix

···

       44
       44
        
             enable = mkEnableOption "the prayer webmail http server";

     

       45
       45
        
       

     

       46
       46
        
             port = mkOption {

     

       47
       47
       -
               default = "2080";

     

       47
       47
       +
               default = 2080;

     

       48
       48
       +
               type = types.port;

     

       48
       49
        
               description = ''

     

       49
       50
        
                 Port the prayer http server is listening to.

     

       50
       51
        
               '';

+4

nixos/modules/services/networking/quassel.nix

···

       45
       45
        
             };

     

       46
       46
        
       

     

       47
       47
        
             interfaces = mkOption {

     

       48
       48
       +
               type = types.listOf types.str;

     

       48
       49
        
               default = [ "127.0.0.1" ];

     

       49
       50
        
               description = ''

     

       50
       51
        
                 The interfaces the Quassel daemon will be listening to.  If `[ 127.0.0.1 ]',

     
···

       54
       55
        
             };

     

       55
       56
        
       

     

       56
       57
        
             portNumber = mkOption {

     

       58
       58
       +
               type = types.port;

     

       57
       59
        
               default = 4242;

     

       58
       60
        
               description = ''

     

       59
       61
        
                 The port number the Quassel daemon will be listening to.

     
···

       62
       64
        
       

     

       63
       65
        
             dataDir = mkOption {

     

       64
       66
        
               default = "/home/${user}/.config/quassel-irc.org";

     

       67
       67
       +
               type = types.str;

     

       65
       68
        
               description = ''

     

       66
       69
        
                 The directory holding configuration files, the SQlite database and the SSL Cert.

     

       67
       70
        
               '';

     
···

       69
       72
        
       

     

       70
       73
        
             user = mkOption {

     

       71
       74
        
               default = null;

     

       75
       75
       +
               type = types.nullOr types.str;

     

       72
       76
        
               description = ''

     

       73
       77
        
                 The existing user the Quassel daemon should run as. If left empty, a default "quassel" user will be created.

     

       74
       78
        
               '';

+1

nixos/modules/services/networking/radvd.nix

···

       33
       33
        
           };

     

       34
       34
        
       

     

       35
       35
        
           services.radvd.config = mkOption {

     

       36
       36
       +
             type = types.lines;

     

       36
       37
        
             example =

     

       37
       38
        
               ''

     

       38
       39
        
                 interface eth0 {

+2

nixos/modules/services/networking/shairport-sync.nix

···

       28
       28
        
             };

     

       29
       29
        
       

     

       30
       30
        
             arguments = mkOption {

     

       31
       31
       +
               type = types.str;

     

       31
       32
        
               default = "-v -o pa";

     

       32
       33
        
               description = ''

     

       33
       34
        
                 Arguments to pass to the daemon. Defaults to a local pulseaudio

     
···

       36
       37
        
             };

     

       37
       38
        
       

     

       38
       39
        
             user = mkOption {

     

       40
       40
       +
               type = types.str;

     

       39
       41
        
               default = "shairport";

     

       40
       42
        
               description = ''

     

       41
       43
        
                 User account name under which to run shairport-sync. The account

+6

nixos/modules/services/networking/ssh/lshd.nix

···

       29
       29
        
       

     

       30
       30
        
             portNumber = mkOption {

     

       31
       31
        
               default = 22;

     

       32
       32
       +
               type = types.port;

     

       32
       33
        
               description = ''

     

       33
       34
        
                 The port on which to listen for connections.

     

       34
       35
        
               '';

     
···

       36
       37
        
       

     

       37
       38
        
             interfaces = mkOption {

     

       38
       39
        
               default = [];

     

       40
       40
       +
               type = types.listOf types.str;

     

       39
       41
        
               description = ''

     

       40
       42
        
                 List of network interfaces where listening for connections.

     

       41
       43
        
                 When providing the empty list, `[]', lshd listens on all

     
···

       46
       48
        
       

     

       47
       49
        
             hostKey = mkOption {

     

       48
       50
        
               default = "/etc/lsh/host-key";

     

       51
       51
       +
               type = types.str;

     

       49
       52
        
               description = ''

     

       50
       53
        
                 Path to the server's private key.  Note that this key must

     

       51
       54
        
                 have been created, e.g., using "lsh-keygen --server |

     
···

       79
       82
        
       

     

       80
       83
        
             loginShell = mkOption {

     

       81
       84
        
               default = null;

     

       85
       85
       +
               type = types.nullOr types.str;

     

       82
       86
        
               description = ''

     

       83
       87
        
                 If non-null, override the default login shell with the

     

       84
       88
        
                 specified value.

     
···

       88
       92
        
       

     

       89
       93
        
             srpKeyExchange = mkOption {

     

       90
       94
        
               default = false;

     

       95
       95
       +
               type = types.bool;

     

       91
       96
        
               description = ''

     

       92
       97
        
                 Whether to enable SRP key exchange and user authentication.

     

       93
       98
        
               '';

     
···

       106
       111
        
             };

     

       107
       112
        
       

     

       108
       113
        
             subsystems = mkOption {

     

       114
       114
       +
               type = types.listOf types.path;

     

       109
       115
        
               description = ''

     

       110
       116
        
                 List of subsystem-path pairs, where the head of the pair

     

       111
       117
        
                 denotes the subsystem name, and the tail denotes the path to

+1

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

···

       180
       180
        
             };

     

       181
       181
        
       

     

       182
       182
        
             name = mkOption {

     

       183
       183
       +
               type = types.str;

     

       183
       184
        
               default = "MediaWiki";

     

       184
       185
        
               example = "Foobar Wiki";

     

       185
       186
        
               description = "Name of the wiki.";

+1

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

···

       404
       404
        
       

     

       405
       405
        
             logError = mkOption {

     

       406
       406
        
               default = "stderr";

     

       407
       407
       +
               type = types.str;

     

       407
       408
        
               description = "

     

       408
       409
        
                 Configures logging.

     

       409
       410
        
                 The first parameter defines a file that will store the log. The

+2

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

···

       28
       28
        
               description = "Group account under which unit runs.";

     

       29
       29
        
             };

     

       30
       30
        
             stateDir = mkOption {

     

       31
       31
       +
               type = types.path;

     

       31
       32
        
               default = "/var/spool/unit";

     

       32
       33
        
               description = "Unit data directory.";

     

       33
       34
        
             };

     

       34
       35
        
             logDir = mkOption {

     

       36
       36
       +
               type = types.path;

     

       35
       37
        
               default = "/var/log/unit";

     

       36
       38
        
               description = "Unit log directory.";

     

       37
       39
        
             };

+1

nixos/modules/services/x11/desktop-managers/cinnamon.nix

···

       25
       25
        
       

     

       26
       26
        
             sessionPath = mkOption {

     

       27
       27
        
               default = [];

     

       28
       28
       +
               type = types.listOf types.package;

     

       28
       29
        
               example = literalExample "[ pkgs.gnome3.gpaste ]";

     

       29
       30
        
               description = ''

     

       30
       31
        
                 Additional list of packages to be added to the session search path.

+1

nixos/modules/services/x11/desktop-managers/gnome3.nix

···

       118
       118
        
       

     

       119
       119
        
             sessionPath = mkOption {

     

       120
       120
        
               default = [];

     

       121
       121
       +
               type = types.listOf types.package;

     

       121
       122
        
               example = literalExample "[ pkgs.gnome3.gpaste ]";

     

       122
       123
        
               description = ''

     

       123
       124
        
                 Additional list of packages to be added to the session search path.

+1

nixos/modules/services/x11/desktop-managers/pantheon.nix

···

       42
       42
        
       

     

       43
       43
        
             sessionPath = mkOption {

     

       44
       44
        
               default = [];

     

       45
       45
       +
               type = types.listOf types.package;

     

       45
       46
        
               example = literalExample "[ pkgs.gnome3.gpaste ]";

     

       46
       47
        
               description = ''

     

       47
       48
        
                 Additional list of packages to be added to the session search path.

+1

nixos/modules/services/x11/display-managers/lightdm-greeters/gtk.nix

···

       88
       88
        
             cursorTheme = {

     

       89
       89
        
       

     

       90
       90
        
               package = mkOption {

     

       91
       91
       +
                 type = types.package;

     

       91
       92
        
                 default = pkgs.gnome3.adwaita-icon-theme;

     

       92
       93
        
                 defaultText = "pkgs.gnome3.adwaita-icon-theme";

     

       93
       94
        
                 description = ''

+1

nixos/modules/services/x11/window-managers/exwm.nix

···

       21
       21
        
             enable = mkEnableOption "exwm";

     

       22
       22
        
             loadScript = mkOption {

     

       23
       23
        
               default = "(require 'exwm)";

     

       24
       24
       +
               type = types.lines;

     

       24
       25
        
               example = literalExample ''

     

       25
       26
        
                 (require 'exwm)

     

       26
       27
        
                 (exwm-enable)

+1

nixos/modules/services/x11/window-managers/xmonad.nix

···

       43
       43
        
             haskellPackages = mkOption {

     

       44
       44
        
               default = pkgs.haskellPackages;

     

       45
       45
        
               defaultText = "pkgs.haskellPackages";

     

       46
       46
       +
               type = types.package;

     

       46
       47
        
               example = literalExample "pkgs.haskell.packages.ghc784";

     

       47
       48
        
               description = ''

     

       48
       49
        
                 haskellPackages used to build Xmonad and other packages.

+1

nixos/modules/services/x11/xserver.nix

···

       441
       441
        
       

     

       442
       442
        
             serverFlagsSection = mkOption {

     

       443
       443
        
               default = "";

     

       444
       444
       +
               type = types.lines;

     

       444
       445
        
               example =

     

       445
       446
        
                 ''

     

       446
       447
        
                 Option "BlankTime" "0"

+4 -1

nixos/modules/virtualisation/xen-dom0.nix

···

       57
       57
        
       

     

       58
       58
        
           virtualisation.xen.bootParams =

     

       59
       59
        
             mkOption {

     

       60
       60
       -
               default = "";

     

       60
       60
       +
               default = [];

     

       61
       61
       +
               type = types.listOf types.str;

     

       61
       62
        
               description =

     

       62
       63
        
                 ''

     

       63
       64
        
                   Parameters passed to the Xen hypervisor at boot time.

     
···

       68
       69
        
             mkOption {

     

       69
       70
        
               default = 0;

     

       70
       71
        
               example = 512;

     

       72
       72
       +
               type = types.addCheck types.int (n: n >= 0);

     

       71
       73
        
               description =

     

       72
       74
        
                 ''

     

       73
       75
        
                   Amount of memory (in MiB) allocated to Domain 0 on boot.

     
···

       78
       80
        
           virtualisation.xen.bridge = {

     

       79
       81
        
               name = mkOption {

     

       80
       82
        
                 default = "xenbr0";

     

       83
       83
       +
                 type = types.str;

     

       81
       84
        
                 description = ''

     

       82
       85
        
                     Name of bridge the Xen domUs connect to.

     

       83
       86
        
                   '';

+1

nixos/tests/all-tests.nix

···

       190
       190
        
         kernel-latest = handleTest ./kernel-latest.nix {};

     

       191
       191
        
         kernel-lts = handleTest ./kernel-lts.nix {};

     

       192
       192
        
         kernel-testing = handleTest ./kernel-testing.nix {};

     

       193
       193
       +
         kernel-latest-ath-user-regd = handleTest ./kernel-latest-ath-user-regd.nix {};

     

       193
       194
        
         keycloak = discoverTests (import ./keycloak.nix);

     

       194
       195
        
         keymap = handleTest ./keymap.nix {};

     

       195
       196
        
         knot = handleTest ./knot.nix {};

+17

nixos/tests/kernel-latest-ath-user-regd.nix

···

       1
       1
       +
       import ./make-test-python.nix ({ pkgs, ...} : {

     

       2
       2
       +
         name = "kernel-latest-ath-user-regd";

     

       3
       3
       +
         meta = with pkgs.lib.maintainers; {

     

       4
       4
       +
           maintainers = [ veehaitch ];

     

       5
       5
       +
         };

     

       6
       6
       +
       

     

       7
       7
       +
         machine = { pkgs, ... }:

     

       8
       8
       +
           {

     

       9
       9
       +
             boot.kernelPackages = pkgs.linuxPackages_latest;

     

       10
       10
       +
             networking.wireless.athUserRegulatoryDomain = true;

     

       11
       11
       +
           };

     

       12
       12
       +
       

     

       13
       13
       +
         testScript =

     

       14
       14
       +
           ''

     

       15
       15
       +
             assert "CONFIG_ATH_USER_REGD=y" in machine.succeed("zcat /proc/config.gz")

     

       16
       16
       +
           '';

     

       17
       17
       +
       })

+5 -25

pkgs/applications/graphics/ImageMagick/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchFromGitHub, fetchpatch, pkg-config, libtool

     

       1
       1
       +
       { lib, stdenv, fetchFromGitHub, pkg-config, libtool

     

       2
       2
        
       , bzip2, zlib, libX11, libXext, libXt, fontconfig, freetype, ghostscript, libjpeg, djvulibre

     

       3
       3
        
       , lcms2, openexr, libpng, librsvg, libtiff, libxml2, openjpeg, libwebp, fftw, libheif, libde265

     

       4
       4
        
       , ApplicationServices

     
···

       12
       12
        
           else if stdenv.hostPlatform.system == "aarch64-linux" then "aarch64"

     

       13
       13
        
           else if stdenv.hostPlatform.system == "powerpc64le-linux" then "ppc64le"

     

       14
       14
        
           else throw "ImageMagick is not supported on this platform.";

     

       15
       15
       -
       

     

       16
       16
       -
         cfg = {

     

       17
       17
       -
           version = "6.9.11-29";

     

       18
       18
       -
           sha256 = "0adjdpi91ya0g3v7y503n95833m25aibkim5swg5lnwjrba407hg";

     

       19
       19
       -
           patches = [];

     

       20
       20
       -
         }

     

       21
       21
       -
           # Freeze version on mingw so we don't need to port the patch too often.

     

       22
       22
       -
           # FIXME: This version has multiple security vulnerabilities

     

       23
       23
       -
           // lib.optionalAttrs (stdenv.hostPlatform.isMinGW) {

     

       24
       24
       -
               version = "6.9.2-0";

     

       25
       25
       -
               sha256 = "17ir8bw1j7g7srqmsz3rx780sgnc21zfn0kwyj78iazrywldx8h7";

     

       26
       26
       -
               patches = [(fetchpatch {

     

       27
       27
       -
                 name = "mingw-build.patch";

     

       28
       28
       -
                 url = "https://raw.githubusercontent.com/Alexpux/MINGW-packages/"

     

       29
       29
       -
                   + "01ca03b2a4ef/mingw-w64-imagemagick/002-build-fixes.patch";

     

       30
       30
       -
                 sha256 = "1pypszlcx2sf7wfi4p37w1y58ck2r8cd5b2wrrwr9rh87p7fy1c0";

     

       31
       31
       -
               })];

     

       32
       32
       -
             };

     

       33
       15
        
       in

     

       34
       16
        
       

     

       35
       35
       -
       stdenv.mkDerivation {

     

       17
       17
       +
       stdenv.mkDerivation rec {

     

       36
       18
        
         pname = "imagemagick";

     

       37
       37
       -
         inherit (cfg) version;

     

       19
       19
       +
         version = "6.9.11-60";

     

       38
       20
        
       

     

       39
       21
        
         src = fetchFromGitHub {

     

       40
       22
        
           owner = "ImageMagick";

     

       41
       23
        
           repo = "ImageMagick6";

     

       42
       42
       -
           rev = cfg.version;

     

       43
       43
       -
           inherit (cfg) sha256;

     

       24
       24
       +
           rev = version;

     

       25
       25
       +
           sha256 = "12810882a0kf4zlgyi290z9bjs921m05njbljkjfw6s1hf0mncl0";

     

       44
       26
        
         };

     

       45
       45
       -
       

     

       46
       46
       -
         patches = cfg.patches;

     

       47
       27
        
       

     

       48
       28
        
         outputs = [ "out" "dev" "doc" ]; # bin/ isn't really big

     

       49
       29
        
         outputMan = "out"; # it's tiny

+2 -2

pkgs/applications/misc/pdfsam-basic/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "pdfsam-basic";

     

       5
       5
       -
         version = "4.2.1";

     

       5
       5
       +
         version = "4.2.2";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "https://github.com/torakiki/pdfsam/releases/download/v${version}/pdfsam_${version}-1_amd64.deb";

     

       9
       9
       -
           sha256 = "0d7pvl87ybkvcxk69fr35fz0w447hy2pm65bhvlril16ljm2izja";

     

       9
       9
       +
           sha256 = "sha256-fbcU3NZdQ8NR5tLjEJyOPneVWNMBddLdttLeVwIUtpg=";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         unpackPhase = ''

+23 -15

pkgs/applications/misc/perkeep/default.nix

···

       1
       1
       -
       { buildGoPackage, fetchurl, fetchFromGitHub, lib }:

     

       1
       1
       +
       { buildGoModule, fetchurl, fetchFromGitHub, lib }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         gouiJS = fetchurl {

     
···

       11
       11
        
           sha256 = "09hd7p0xscqnh612jbrjvh3njmlm4292zd5sbqx2lg0aw688q8p2";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
       in buildGoPackage rec {

     

       15
       15
       -
         name = "perkeep-${version}";

     

       16
       16
       -
         version = "unstable-2020-03-23";

     

       14
       14
       +
         packages = [

     

       15
       15
       +
           "perkeep.org/server/perkeepd"

     

       16
       16
       +
           "perkeep.org/cmd/pk"

     

       17
       17
       +
           "perkeep.org/cmd/pk-get"

     

       18
       18
       +
           "perkeep.org/cmd/pk-put"

     

       19
       19
       +
           "perkeep.org/cmd/pk-mount"

     

       20
       20
       +
         ];

     

       21
       21
       +
       

     

       22
       22
       +
       in buildGoModule rec {

     

       23
       23
       +
         pname = "perkeep";

     

       24
       24
       +
         version = "0.11";

     

       17
       25
        
       

     

       18
       26
        
         src = fetchFromGitHub {

     

       19
       27
        
           owner = "perkeep";

     

       20
       28
        
           repo = "perkeep";

     

       21
       21
       -
           rev = "c2e31370ddefd86b6112a5d891100ea3382a4254";

     

       22
       22
       -
           sha256 = "0jf02k20ms7h60wglcq6dj3vqi9rlfww7db5iplgwznbij70c1i4";

     

       29
       29
       +
           rev = version;

     

       30
       30
       +
           sha256 = "07j5gplk4kcrbazyg4m4bwggzlz5gk89h90r14jvfcpms7v5nrll";

     

       23
       31
        
         };

     

       24
       32
        
       

     

       25
       25
       -
         goPackagePath = "perkeep.org";

     

       33
       33
       +
         vendorSha256 = "1af9a6r9qfrak0n5xyv9z8n7gn7xw2sdjn4s9bwwidkrdm81iq6b";

     

       34
       34
       +
         deleteVendor = true; # Vendor is out of sync with go.mod

     

       26
       35
        
       

     

       27
       36
        
         buildPhase = ''

     

       28
       28
       -
           cd "$NIX_BUILD_TOP/go/src/$goPackagePath"

     

       37
       37
       +
           cd "$NIX_BUILD_TOP/source"

     

       29
       38
        
       

     

       30
       39
        
           # Skip network fetches

     

       31
       31
       -
           sed -i '/fetchAllJS/a if true { return nil }' make.go

     

       32
       40
        
           cp ${publisherJS} app/publisher/publisher.js

     

       33
       41
        
           cp ${gouiJS} server/perkeepd/ui/goui.js

     

       34
       42
        
       

     

       35
       35
       -
           go run make.go

     

       43
       43
       +
           go run make.go -offline=true -targets=${lib.concatStringsSep "," packages}

     

       36
       44
        
         '';

     

       37
       45
        
       

     

       38
       38
       -
         # devcam is only useful when developing perkeep, we should not install it as

     

       39
       39
       -
         # part of this derivation.

     

       46
       46
       +
         # genfileembed gets built regardless of -targets, to embed static

     

       47
       47
       +
         # content into the Perkeep binaries. Remove it in post-install to

     

       48
       48
       +
         # avoid polluting paths.

     

       40
       49
        
         postInstall = ''

     

       41
       41
       -
           rm -f $out/bin/devcam

     

       50
       50
       +
           rm -f $out/bin/genfileembed

     

       42
       51
        
         '';

     

       43
       52
        
       

     

       44
       53
        
         meta = with lib; {

     

       45
       54
        
           description = "A way of storing, syncing, sharing, modelling and backing up content (née Camlistore)";

     

       46
       55
        
           homepage = "https://perkeep.org";

     

       47
       56
        
           license = licenses.asl20;

     

       48
       48
       -
           maintainers = with maintainers; [ cstrahan kalbasit ];

     

       49
       49
       -
           platforms = platforms.unix;

     

       57
       57
       +
           maintainers = with maintainers; [ cstrahan danderson kalbasit ];

     

       50
       58
        
         };

     

       51
       59
        
       }

+3 -1

pkgs/applications/networking/instant-messengers/zoom-us/update.sh

···

       3
       3
        
       

     

       4
       4
        
       set -eu -o pipefail

     

       5
       5
        
       

     

       6
       6
       -
       version="$(curl -Ls https://zoom.us/download\?os\=linux | pup '.linux-ver-text text{}' | cut -d' ' -f2)"

     

       6
       6
       +
       version="$(curl -Ls https://zoom.us/download\?os\=linux | \

     

       7
       7
       +
         pup '.linux-ver-text text{}' | \

     

       8
       8
       +
         awk -F'[ ().]' '{printf $2"."$3"."$6"."$7"\n"}')"

     

       7
       9
        
       

     

       8
       10
        
       update-source-version zoom-us "$version"

+2 -2

pkgs/applications/networking/irc/weechat/default.nix

···

       27
       27
        
         in

     

       28
       28
        
           assert lib.all (p: p.enabled -> ! (builtins.elem null p.buildInputs)) plugins;

     

       29
       29
        
           stdenv.mkDerivation rec {

     

       30
       30
       -
             version = "3.0";

     

       30
       30
       +
             version = "3.0.1";

     

       31
       31
        
             pname = "weechat";

     

       32
       32
        
       

     

       33
       33
        
             src = fetchurl {

     

       34
       34
        
               url = "https://weechat.org/files/src/weechat-${version}.tar.bz2";

     

       35
       35
       -
               sha256 = "0ciddvyhyp38fnfsi1plj3z8d76f28lbzbxib2857vw7rzyqfcky";

     

       35
       35
       +
               sha256 = "0f50kib8l99vlp9wqszq2r2g5panzphsgs7viga8lyc83v229b33";

     

       36
       36
        
             };

     

       37
       37
        
       

     

       38
       38
        
             outputs = [ "out" "man" ] ++ map (p: p.name) enabledPlugins;

+86 -16

pkgs/applications/networking/remote/vmware-horizon-client/default.nix

···

       1
       1
       -
       { lib, stdenv, buildFHSUserEnv, fetchurl, makeWrapper, makeDesktopItem, libxslt, atk

     

       2
       2
       -
       , fontconfig, freetype, gdk-pixbuf, glib, gtk2, libudev0-shim, libxml2

     

       3
       3
       -
       , pango, pixman, libX11, libXext, libXinerama, libXrandr , libXrender

     

       4
       4
       -
       , libXtst, libXcursor, libXi, libxkbfile , libXScrnSaver, zlib, liberation_ttf

     

       5
       5
       -
       , libtiff, dbus, at-spi2-atk, harfbuzz, gtk3-x11, libuuid, pcsclite

     

       1
       1
       +
       { stdenv

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , at-spi2-atk

     

       4
       4
       +
       , atk

     

       5
       5
       +
       , buildFHSUserEnv

     

       6
       6
       +
       , dbus

     

       7
       7
       +
       , fetchurl

     

       8
       8
       +
       , fontconfig

     

       9
       9
       +
       , freetype

     

       10
       10
       +
       , gdk-pixbuf

     

       11
       11
       +
       , glib

     

       12
       12
       +
       , gsettings-desktop-schemas

     

       13
       13
       +
       , gtk2

     

       14
       14
       +
       , gtk3-x11

     

       15
       15
       +
       , harfbuzz

     

       16
       16
       +
       , liberation_ttf

     

       17
       17
       +
       , libjpeg

     

       18
       18
       +
       , libtiff

     

       19
       19
       +
       , libudev0-shim

     

       20
       20
       +
       , libuuid

     

       21
       21
       +
       , libX11

     

       22
       22
       +
       , libXcursor

     

       23
       23
       +
       , libXext

     

       24
       24
       +
       , libXi

     

       25
       25
       +
       , libXinerama

     

       26
       26
       +
       , libxkbfile

     

       27
       27
       +
       , libxml2

     

       28
       28
       +
       , libXrandr

     

       29
       29
       +
       , libXrender

     

       30
       30
       +
       , libXScrnSaver

     

       31
       31
       +
       , libxslt

     

       32
       32
       +
       , libXtst

     

       33
       33
       +
       , makeDesktopItem

     

       34
       34
       +
       , makeWrapper

     

       35
       35
       +
       , pango

     

       36
       36
       +
       , pcsclite

     

       37
       37
       +
       , pixman

     

       38
       38
       +
       , zlib

     

       6
       39
        
       }:

     

       7
       7
       -
       

     

       8
       40
        
       let

     

       9
       9
       -
         version = "2006";

     

       41
       41
       +
         version = "2012";

     

       10
       42
        
       

     

       11
       43
        
         sysArch =

     

       12
       44
        
           if stdenv.hostPlatform.system == "x86_64-linux" then "x64"

     

       13
       45
        
           else throw "Unsupported system: ${stdenv.hostPlatform.system}";

     

       14
       14
       -
           # The downloaded archive also contains i386 and ARM binaries, but these have not been tested.

     

       46
       46
       +
         # The downloaded archive also contains i386 and ARM binaries, but these have not been tested.

     

       15
       47
        
       

     

       16
       48
        
         vmwareHorizonClientFiles = stdenv.mkDerivation {

     

       17
       49
        
           name = "vmwareHorizonClientFiles";

     

       18
       50
        
           inherit version;

     

       19
       51
        
           src = fetchurl {

     

       20
       20
       -
             url = https://download3.vmware.com/software/view/viewclients/CART21FQ2/vmware-view-client-linux-2006-8.0.0-16522670.tar.gz;

     

       21
       21
       -
             sha256 = "8c46d49fea42f8c1f7cf32a5f038f5a47d2b304743b1e4f4c68c658621b0e79c";

     

       52
       52
       +
             url = "https://download3.vmware.com/software/view/viewclients/CART21FQ4/VMware-Horizon-Client-Linux-2012-8.1.0-17349998.tar.gz";

     

       53
       53
       +
             sha256 = "0afda1f3116e75a4e7f89990d8ee60ccea5f3bb8a2360652162fa11c795724ce";

     

       22
       54
        
           };

     

       23
       55
        
           buildInputs = [ makeWrapper ];

     

       24
       56
        
           installPhase = ''

     
···

       30
       62
        
             # when it cannot detect a new enough version already present on the system.

     

       31
       63
        
             # The checks are distribution-specific and do not function correctly on NixOS.

     

       32
       64
        
             # Deleting the bundled library is the simplest way to force it to use our version.

     

       33
       33
       -
             rm -f "$out/lib/vmware/gcc/libstdc++.so.6"

     

       65
       65
       +
             rm "$out/lib/vmware/gcc/libstdc++.so.6"

     

       66
       66
       +
       

     

       67
       67
       +
             # This libjpeg library interferes with Chromium, so we will be using ours instead.

     

       68
       68
       +
             rm $out/lib/vmware/libjpeg.*

     

       34
       69
        
       

     

       35
       70
        
             # Force the default GTK theme (Adwaita) because Horizon is prone to

     

       36
       71
        
             # UI usability issues when using non-default themes, such as Adwaita-dark.

     

       37
       72
        
             makeWrapper "$out/bin/vmware-view" "$out/bin/vmware-view_wrapper" \

     

       38
       73
        
                 --set GTK_THEME Adwaita \

     

       74
       74
       +
                 --suffix XDG_DATA_DIRS : "${gsettings-desktop-schemas}/share/gsettings-schemas/${gsettings-desktop-schemas.name}" \

     

       39
       75
        
                 --suffix LD_LIBRARY_PATH : "$out/lib/vmware/view/crtbora:$out/lib/vmware"

     

       40
       76
        
           '';

     

       41
       77
        
         };

     
···

       46
       82
        
           runScript = "${vmwareHorizonClientFiles}/bin/vmware-view_wrapper";

     

       47
       83
        
       

     

       48
       84
        
           targetPkgs = pkgs: [

     

       49
       49
       -
             pcsclite dbus vmwareHorizonClientFiles atk fontconfig freetype gdk-pixbuf glib gtk2

     

       50
       50
       -
             libudev0-shim libxml2 pango pixman liberation_ttf libX11 libXext libXinerama

     

       51
       51
       -
             libXrandr libXrender libXtst libXcursor libXi libxkbfile at-spi2-atk libXScrnSaver

     

       52
       52
       -
             zlib libtiff harfbuzz gtk3-x11 libuuid

     

       85
       85
       +
             at-spi2-atk

     

       86
       86
       +
             atk

     

       87
       87
       +
             dbus

     

       88
       88
       +
             fontconfig

     

       89
       89
       +
             freetype

     

       90
       90
       +
             gdk-pixbuf

     

       91
       91
       +
             glib

     

       92
       92
       +
             gtk2

     

       93
       93
       +
             gtk3-x11

     

       94
       94
       +
             harfbuzz

     

       95
       95
       +
             liberation_ttf

     

       96
       96
       +
             libjpeg

     

       97
       97
       +
             libtiff

     

       98
       98
       +
             libudev0-shim

     

       99
       99
       +
             libuuid

     

       100
       100
       +
             libX11

     

       101
       101
       +
             libXcursor

     

       102
       102
       +
             libXext

     

       103
       103
       +
             libXi

     

       104
       104
       +
             libXinerama

     

       105
       105
       +
             libxkbfile

     

       106
       106
       +
             libxml2

     

       107
       107
       +
             libXrandr

     

       108
       108
       +
             libXrender

     

       109
       109
       +
             libXScrnSaver

     

       110
       110
       +
             libXtst

     

       111
       111
       +
             pango

     

       112
       112
       +
             pcsclite

     

       113
       113
       +
             pixman

     

       114
       114
       +
             vmwareHorizonClientFiles

     

       115
       115
       +
             zlib

     

       53
       116
        
           ];

     

       54
       117
        
         };

     

       55
       118
        
       

     
···

       61
       124
        
           mimeType = "x-scheme-handler/vmware-view";

     

       62
       125
        
         };

     

       63
       126
        
       

     

       64
       64
       -
       in stdenv.mkDerivation {

     

       127
       127
       +
       in

     

       128
       128
       +
       stdenv.mkDerivation {

     

       65
       129
        
         name = "vmware-view";

     

       130
       130
       +
       

     

       66
       131
        
         dontUnpack = true;

     

       132
       132
       +
       

     

       67
       133
        
         installPhase = ''

     

       68
       134
        
           mkdir -p $out/bin $out/share/applications

     

       69
       135
        
           cp "${desktopItem}"/share/applications/* $out/share/applications/

     

       70
       136
        
           ln -s "${vmwareFHSUserEnv}/bin/vmware-view" "$out/bin/"

     

       71
       137
        
         '';

     

       138
       138
       +
       

     

       139
       139
       +
         unwrapped = vmwareHorizonClientFiles;

     

       140
       140
       +
       

     

       141
       141
       +
         passthru.updateScript = ./update.sh;

     

       72
       142
        
       

     

       73
       143
        
         meta = with lib; {

     

       74
       144
        
           description = "Allows you to connect to your VMware Horizon virtual desktop";

+27

pkgs/applications/networking/remote/vmware-horizon-client/update.sh

···

       1
       1
       +
       #!/usr/bin/env nix-shell

     

       2
       2
       +
       #!nix-shell -p curl -p jq -p common-updater-scripts -i bash

     

       3
       3
       +
       set -e

     

       4
       4
       +
       

     

       5
       5
       +
       entryPointURL='https://my.vmware.com/channel/public/api/v1.0/products/getRelatedDLGList?locale=en_US&category=desktop_end_user_computing&product=vmware_horizon_clients&version=horizon_8&dlgType=PRODUCT_BINARY'

     

       6
       6
       +
       

     

       7
       7
       +
       function getTarballMetaUrl {

     

       8
       8
       +
           curl "$entryPointURL" | jq -r '

     

       9
       9
       +
               .dlgEditionsLists | .[] | select(.name | contains("Client for Linux")) |

     

       10
       10
       +
               .dlgList | .[] | select(.name | contains("tarball version")) |

     

       11
       11
       +
               @uri "https://my.vmware.com/channel/public/api/v1.0/dlg/details?locale=en_US&downloadGroup=\(.code)&productId=\(.productId)&rPId=\(.releasePackageId)"

     

       12
       12
       +
           '

     

       13
       13
       +
       }

     

       14
       14
       +
       

     

       15
       15
       +
       meta="$( curl "$(getTarballMetaUrl)" | jq ".downloadFiles | .[]" )"

     

       16
       16
       +
       

     

       17
       17
       +
       ver="$( echo "$meta" | jq -r .version )"

     

       18
       18
       +
       url="$( echo "$meta" | jq -r .thirdPartyDownloadUrl )"

     

       19
       19
       +
       sum="$( echo "$meta" | jq -r .sha256checksum )"

     

       20
       20
       +
       

     

       21
       21
       +
       echo

     

       22
       22
       +
       echo "version: $ver"

     

       23
       23
       +
       echo "tar url: $url"

     

       24
       24
       +
       echo " sha256: $sum"

     

       25
       25
       +
       

     

       26
       26
       +
       cd "$(dirname "$0")/../../../../.."

     

       27
       27
       +
       update-source-version vmware-horizon-client.unwrapped "$ver" "$sum" "$url"

+2 -2

pkgs/applications/office/portfolio/default.nix

···

       24
       24
        
       in

     

       25
       25
        
       stdenv.mkDerivation rec {

     

       26
       26
        
         pname = "PortfolioPerformance";

     

       27
       27
       -
         version = "0.50.2";

     

       27
       27
       +
         version = "0.50.3";

     

       28
       28
        
       

     

       29
       29
        
         src = fetchurl {

     

       30
       30
        
           url = "https://github.com/buchen/portfolio/releases/download/${version}/PortfolioPerformance-${version}-linux.gtk.x86_64.tar.gz";

     

       31
       31
       -
           sha256 = "sha256-n5tLYrqqM0KUQrlJWZtKGClKONAz3EXBAlEqIrdPBpI=";

     

       31
       31
       +
           sha256 = "sha256-8sFBxcs3tnIQQ4S39aF8r9SGm9VOHPpgQYyLkUaOscw=";

     

       32
       32
        
         };

     

       33
       33
        
       

     

       34
       34
        
         nativeBuildInputs = [

+3 -3

pkgs/applications/science/chemistry/molden/default.nix

···

       5
       5
        
         pname = "molden";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
       -
           url = "ftp://ftp.cmbi.ru.nl/pub/molgraph/molden/molden${version}.tar.gz";

     

       8
       8
       +
           url = "ftp://ftp.cmbi.umcn.nl/pub/molgraph/molden/molden${version}.tar.gz";

     

       9
       9
        
           sha256 = "02qi16pz2wffn3cc47dpjqhfafzwfmb79waw4nnhfyir8a4h3cq1";

     

       10
       10
        
         };

     

       11
       11
        
       

     
···

       31
       31
        
       

     

       32
       32
        
         meta = with lib; {

     

       33
       33
        
            description = "Display and manipulate molecular structures";

     

       34
       34
       -
            homepage = "http://www.cmbi.ru.nl/molden/";

     

       34
       34
       +
            homepage = "http://www3.cmbi.umcn.nl/molden/";

     

       35
       35
        
            license = {

     

       36
       36
        
              fullName = "Free for academic/non-profit use";

     

       37
       37
       -
              url = "http://www.cmbi.ru.nl/molden/CopyRight.html";

     

       37
       37
       +
              url = "http://www3.cmbi.umcn.nl/molden/CopyRight.html";

     

       38
       38
        
              free = false;

     

       39
       39
        
            };

     

       40
       40
        
            platforms = platforms.linux;

pkgs/desktops/xfce/art/xfce4-icon-theme.nix pkgs/desktops/xfce/art/xfce4-icon-theme/default.nix

pkgs/desktops/xfce/art/xfwm4-themes.nix pkgs/desktops/xfce/art/xfwm4-themes/default.nix

+19 -19

pkgs/desktops/xfce/default.nix

···

       96
       96
        
       

     

       97
       97
        
         #### ART

     

       98
       98
        
       

     

       99
       99
       -
         xfce4-icon-theme = callPackage ./art/xfce4-icon-theme.nix { };

     

       99
       99
       +
         xfce4-icon-theme = callPackage ./art/xfce4-icon-theme { };

     

       100
       100
        
       

     

       101
       101
       -
         xfwm4-themes = callPackage ./art/xfwm4-themes.nix { };

     

       101
       101
       +
         xfwm4-themes = callPackage ./art/xfwm4-themes { };

     

       102
       102
        
       

     

       103
       103
        
         #### PANEL PLUGINS

     

       104
       104
        
       

     
···

       110
       110
        
       

     

       111
       111
        
         xfce4-cpufreq-plugin = callPackage ./panel-plugins/xfce4-cpufreq-plugin { };

     

       112
       112
        
       

     

       113
       113
       -
         xfce4-cpugraph-plugin = callPackage ./panel-plugins/xfce4-cpugraph-plugin.nix { };

     

       113
       113
       +
         xfce4-cpugraph-plugin = callPackage ./panel-plugins/xfce4-cpugraph-plugin { };

     

       114
       114
        
       

     

       115
       115
        
         xfce4-datetime-plugin = callPackage ./panel-plugins/xfce4-datetime-plugin { };

     

       116
       116
        
       

     

       117
       117
       -
         xfce4-dockbarx-plugin = callPackage ./panel-plugins/xfce4-dockbarx-plugin.nix { };

     

       117
       117
       +
         xfce4-dockbarx-plugin = callPackage ./panel-plugins/xfce4-dockbarx-plugin { };

     

       118
       118
        
       

     

       119
       119
       -
         xfce4-embed-plugin = callPackage ./panel-plugins/xfce4-embed-plugin.nix { };

     

       119
       119
       +
         xfce4-embed-plugin = callPackage ./panel-plugins/xfce4-embed-plugin { };

     

       120
       120
        
       

     

       121
       121
       -
         xfce4-eyes-plugin = callPackage ./panel-plugins/xfce4-eyes-plugin.nix { };

     

       121
       121
       +
         xfce4-eyes-plugin = callPackage ./panel-plugins/xfce4-eyes-plugin { };

     

       122
       122
        
       

     

       123
       123
       -
         xfce4-fsguard-plugin = callPackage ./panel-plugins/xfce4-fsguard-plugin.nix { };

     

       123
       123
       +
         xfce4-fsguard-plugin = callPackage ./panel-plugins/xfce4-fsguard-plugin { };

     

       124
       124
        
       

     

       125
       125
       -
         xfce4-genmon-plugin = callPackage ./panel-plugins/xfce4-genmon-plugin.nix { };

     

       125
       125
       +
         xfce4-genmon-plugin = callPackage ./panel-plugins/xfce4-genmon-plugin { };

     

       126
       126
        
       

     

       127
       127
       -
         xfce4-hardware-monitor-plugin = callPackage ./panel-plugins/xfce4-hardware-monitor-plugin.nix { };

     

       127
       127
       +
         xfce4-hardware-monitor-plugin = callPackage ./panel-plugins/xfce4-hardware-monitor-plugin { };

     

       128
       128
        
       

     

       129
       129
       -
         xfce4-i3-workspaces-plugin = callPackage ./panel-plugins/xfce4-i3-workspaces-plugin.nix { };

     

       129
       129
       +
         xfce4-i3-workspaces-plugin = callPackage ./panel-plugins/xfce4-i3-workspaces-plugin { };

     

       130
       130
        
       

     

       131
       131
       -
         xfce4-namebar-plugin = callPackage ./panel-plugins/xfce4-namebar-plugin.nix { };

     

       131
       131
       +
         xfce4-namebar-plugin = callPackage ./panel-plugins/xfce4-namebar-plugin { };

     

       132
       132
        
       

     

       133
       133
        
         xfce4-netload-plugin = callPackage ./panel-plugins/xfce4-netload-plugin { };

     

       134
       134
        
       

     

       135
       135
       -
         xfce4-notes-plugin = callPackage ./panel-plugins/xfce4-notes-plugin.nix { };

     

       135
       135
       +
         xfce4-notes-plugin = callPackage ./panel-plugins/xfce4-notes-plugin { };

     

       136
       136
        
       

     

       137
       137
       -
         xfce4-mailwatch-plugin = callPackage ./panel-plugins/xfce4-mailwatch-plugin.nix { };

     

       137
       137
       +
         xfce4-mailwatch-plugin = callPackage ./panel-plugins/xfce4-mailwatch-plugin { };

     

       138
       138
        
       

     

       139
       139
       -
         xfce4-mpc-plugin = callPackage ./panel-plugins/xfce4-mpc-plugin.nix { };

     

       139
       139
       +
         xfce4-mpc-plugin = callPackage ./panel-plugins/xfce4-mpc-plugin { };

     

       140
       140
        
       

     

       141
       141
       -
         xfce4-sensors-plugin = callPackage ./panel-plugins/xfce4-sensors-plugin.nix { };

     

       141
       141
       +
         xfce4-sensors-plugin = callPackage ./panel-plugins/xfce4-sensors-plugin { };

     

       142
       142
        
       

     

       143
       143
       -
         xfce4-systemload-plugin = callPackage ./panel-plugins/xfce4-systemload-plugin.nix { };

     

       143
       143
       +
         xfce4-systemload-plugin = callPackage ./panel-plugins/xfce4-systemload-plugin { };

     

       144
       144
        
       

     

       145
       145
       -
         xfce4-timer-plugin = callPackage ./panel-plugins/xfce4-timer-plugin.nix { };

     

       145
       145
       +
         xfce4-timer-plugin = callPackage ./panel-plugins/xfce4-timer-plugin { };

     

       146
       146
        
       

     

       147
       147
        
         xfce4-verve-plugin = callPackage ./panel-plugins/xfce4-verve-plugin { };

     

       148
       148
        
       

     

       149
       149
        
         xfce4-xkb-plugin = callPackage ./panel-plugins/xfce4-xkb-plugin { };

     

       150
       150
        
       

     

       151
       151
       -
         xfce4-weather-plugin = callPackage ./panel-plugins/xfce4-weather-plugin.nix { };

     

       151
       151
       +
         xfce4-weather-plugin = callPackage ./panel-plugins/xfce4-weather-plugin { };

     

       152
       152
        
       

     

       153
       153
        
         xfce4-whiskermenu-plugin = callPackage ./panel-plugins/xfce4-whiskermenu-plugin { };

     

       154
       154
        
       

     

       155
       155
       -
         xfce4-windowck-plugin = callPackage ./panel-plugins/xfce4-windowck-plugin.nix { };

     

       155
       155
       +
         xfce4-windowck-plugin = callPackage ./panel-plugins/xfce4-windowck-plugin { };

     

       156
       156
        
       

     

       157
       157
        
         xfce4-pulseaudio-plugin = callPackage ./panel-plugins/xfce4-pulseaudio-plugin { };

     

       158
       158

+21 -7

pkgs/desktops/xfce/panel-plugins/xfce4-cpugraph-plugin.nix pkgs/desktops/xfce/panel-plugins/xfce4-cpugraph-plugin/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchurl, pkg-config, intltool, glib, exo, libXtst, xorgproto, libxfce4util, xfce4-panel, libxfce4ui, xfconf, gtk3, hicolor-icon-theme, xfce }:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , pkg-config

     

       5
       5
       +
       , intltool

     

       6
       6
       +
       , glib

     

       7
       7
       +
       , exo

     

       8
       8
       +
       , libXtst

     

       9
       9
       +
       , xorgproto

     

       10
       10
       +
       , libxfce4util

     

       11
       11
       +
       , xfce4-panel

     

       12
       12
       +
       , libxfce4ui

     

       13
       13
       +
       , xfconf

     

       14
       14
       +
       , gtk3

     

       15
       15
       +
       , hicolor-icon-theme

     

       16
       16
       +
       , xfce

     

       17
       17
       +
       }:

     

       2
       18
        
       

     

       3
       19
        
       let

     

       4
       20
        
         category = "panel-plugins";

     

       5
       5
       -
       in

     

       6
       6
       -
       

     

       7
       7
       -
       stdenv.mkDerivation rec {

     

       21
       21
       +
       in stdenv.mkDerivation rec {

     

       8
       22
        
         pname  = "xfce4-cpugraph-plugin";

     

       9
       9
       -
         version = "1.1.0";

     

       23
       23
       +
         version = "1.2.1";

     

       10
       24
        
       

     

       11
       25
        
         src = fetchurl {

     

       12
       26
        
           url = "mirror://xfce/src/${category}/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.bz2";

     

       13
       13
       -
           sha256 = "193bj1p54l4zrvgdjj0pvjn161d6dn82jh9invcy09sqwlj0mkiy";

     

       27
       27
       +
           sha256 = "YVrfmr2RQXpEMZ2OTa3GAS+iKjd48vN5cXUS3Lfvkko=";

     

       14
       28
        
         };

     

       15
       29
        
       

     

       16
       30
        
         nativeBuildInputs = [

     
···

       42
       56
        
           description = "CPU graph show for Xfce panel";

     

       43
       57
        
           license = licenses.gpl2Plus;

     

       44
       58
        
           platforms = platforms.linux;

     

       45
       45
       -
           maintainers = [ maintainers.AndersonTorres ];

     

       59
       59
       +
           maintainers = [ ];

     

       46
       60
        
         };

     

       47
       61
        
       }

pkgs/desktops/xfce/panel-plugins/xfce4-dockbarx-plugin.nix pkgs/desktops/xfce/panel-plugins/xfce4-dockbarx-plugin/default.nix

+14 -7

pkgs/desktops/xfce/panel-plugins/xfce4-embed-plugin.nix pkgs/desktops/xfce/panel-plugins/xfce4-embed-plugin/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchurl, pkg-config, intltool, libxfce4util, xfce4-panel, libxfce4ui, gtk2, xfce }:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , pkg-config

     

       5
       5
       +
       , intltool

     

       6
       6
       +
       , libxfce4util

     

       7
       7
       +
       , xfce4-panel

     

       8
       8
       +
       , libxfce4ui

     

       9
       9
       +
       , gtk2

     

       10
       10
       +
       , xfce

     

       11
       11
       +
       }:

     

       2
       12
        
       

     

       3
       13
        
       let

     

       4
       14
        
         category = "panel-plugins";

     

       5
       5
       -
       in

     

       6
       6
       -
       

     

       7
       7
       -
       with lib;

     

       8
       8
       -
       stdenv.mkDerivation rec {

     

       15
       15
       +
       in stdenv.mkDerivation rec {

     

       9
       16
        
         pname  = "xfce4-embed-plugin";

     

       10
       17
        
         version = "1.6.0";

     

       11
       18
        
       

     
···

       32
       39
        
           versionLister = xfce.archiveLister category pname;

     

       33
       40
        
         };

     

       34
       41
        
       

     

       35
       35
       -
         meta = {

     

       42
       42
       +
         meta = with lib;{

     

       36
       43
        
           homepage = "https://docs.xfce.org/panel-plugins/xfce4-embed-plugin";

     

       37
       44
        
           description = "Embed arbitrary app windows on Xfce panel";

     

       38
       45
        
           license = licenses.gpl2Plus;

     

       39
       46
        
           platforms = platforms.linux;

     

       40
       40
       -
           maintainers = [ maintainers.AndersonTorres ];

     

       47
       47
       +
           maintainers = [ ];

     

       41
       48
        
         };

     

       42
       49
        
       }

+14 -5

pkgs/desktops/xfce/panel-plugins/xfce4-eyes-plugin.nix pkgs/desktops/xfce/panel-plugins/xfce4-eyes-plugin/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchurl, pkg-config, intltool, libxfce4util, xfce4-panel, libxfce4ui, xfconf, gtk3, xfce }:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , pkg-config

     

       5
       5
       +
       , intltool

     

       6
       6
       +
       , libxfce4util

     

       7
       7
       +
       , xfce4-panel

     

       8
       8
       +
       , libxfce4ui

     

       9
       9
       +
       , xfconf

     

       10
       10
       +
       , gtk3

     

       11
       11
       +
       , xfce

     

       12
       12
       +
       }:

     

       2
       13
        
       

     

       3
       14
        
       let

     

       4
       15
        
         category = "panel-plugins";

     

       5
       5
       -
       in

     

       6
       6
       -
       

     

       7
       7
       -
       stdenv.mkDerivation rec {

     

       16
       16
       +
       in stdenv.mkDerivation rec {

     

       8
       17
        
         pname  = "xfce4-eyes-plugin";

     

       9
       18
        
         version = "4.5.1";

     

       10
       19
        
       

     
···

       37
       46
        
           description = "Rolling eyes (following mouse pointer) plugin for the Xfce panel";

     

       38
       47
        
           license = licenses.gpl2Plus;

     

       39
       48
        
           platforms = platforms.linux;

     

       40
       40
       -
           maintainers = [ maintainers.AndersonTorres ];

     

       49
       49
       +
           maintainers = [ ];

     

       41
       50
        
         };

     

       42
       51
        
       }

+16 -7

pkgs/desktops/xfce/panel-plugins/xfce4-fsguard-plugin.nix pkgs/desktops/xfce/panel-plugins/xfce4-fsguard-plugin/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchurl, pkg-config, intltool, libxfce4util, xfce4-panel, libxfce4ui, xfconf, gtk3, xfce }:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , pkg-config

     

       5
       5
       +
       , intltool

     

       6
       6
       +
       , libxfce4util

     

       7
       7
       +
       , xfce4-panel

     

       8
       8
       +
       , libxfce4ui

     

       9
       9
       +
       , xfconf

     

       10
       10
       +
       , gtk3

     

       11
       11
       +
       , xfce

     

       12
       12
       +
       }:

     

       2
       13
        
       

     

       3
       14
        
       let

     

       4
       15
        
         category = "panel-plugins";

     

       5
       5
       -
       in

     

       6
       6
       -
       

     

       7
       7
       -
       stdenv.mkDerivation rec {

     

       16
       16
       +
       in stdenv.mkDerivation rec {

     

       8
       17
        
         pname  = "xfce4-fsguard-plugin";

     

       9
       9
       -
         version = "1.1.1";

     

       18
       18
       +
         version = "1.1.2";

     

       10
       19
        
       

     

       11
       20
        
         src = fetchurl {

     

       12
       21
        
           url = "mirror://xfce/src/${category}/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.bz2";

     

       13
       13
       -
           sha256 = "05nmfkrmifm76bsywqmbjd1qdvzagv5cbvnwbkb57156j055vl6n";

     

       22
       22
       +
           sha256 = "Z9jmohmnEXxZaTrbxZw5puujHj8YpUmRie9O8otVQQU=";

     

       14
       23
        
         };

     

       15
       24
        
       

     

       16
       25
        
         nativeBuildInputs = [

     
···

       37
       46
        
           description = "Filesystem usage monitor plugin for the Xfce panel";

     

       38
       47
        
           license = licenses.bsd2;

     

       39
       48
        
           platforms = platforms.linux;

     

       40
       40
       -
           maintainers = [ maintainers.AndersonTorres ];

     

       49
       49
       +
           maintainers = [ ];

     

       41
       50
        
         };

     

       42
       51
        
       }

+15 -7

pkgs/desktops/xfce/panel-plugins/xfce4-genmon-plugin.nix pkgs/desktops/xfce/panel-plugins/xfce4-genmon-plugin/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchurl, pkg-config, intltool, libxfce4util, xfce4-panel, libxfce4ui, gtk3, xfce }:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , pkg-config

     

       5
       5
       +
       , intltool

     

       6
       6
       +
       , libxfce4util

     

       7
       7
       +
       , xfce4-panel

     

       8
       8
       +
       , libxfce4ui

     

       9
       9
       +
       , gtk3

     

       10
       10
       +
       , xfce

     

       11
       11
       +
       }:

     

       2
       12
        
       

     

       3
       13
        
       let

     

       4
       14
        
         category = "panel-plugins";

     

       5
       5
       -
       in

     

       6
       6
       -
       

     

       7
       7
       -
       stdenv.mkDerivation rec {

     

       15
       15
       +
       in stdenv.mkDerivation rec {

     

       8
       16
        
         pname  = "xfce4-genmon-plugin";

     

       9
       9
       -
         version = "4.0.2";

     

       17
       17
       +
         version = "4.1.1";

     

       10
       18
        
       

     

       11
       19
        
         src = fetchurl {

     

       12
       20
        
           url = "mirror://xfce/src/${category}/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.bz2";

     

       13
       13
       -
           sha256 = "1ai3pwgv61nv7i2dyrvncnc63r8kdjbkp40vp51vzak1dx924v15";

     

       21
       21
       +
           sha256 = "shGf0P8Z+ik7l+yXsN6OJBeZ4IuGIYUVFnxWi9m1ATU=";

     

       14
       22
        
         };

     

       15
       23
        
       

     

       16
       24
        
         nativeBuildInputs = [

     
···

       36
       44
        
           description = "Generic monitor plugin for the Xfce panel";

     

       37
       45
        
           license = licenses.gpl2Plus;

     

       38
       46
        
           platforms = platforms.linux;

     

       39
       39
       -
           maintainers = [ maintainers.AndersonTorres ];

     

       47
       47
       +
           maintainers = [ ];

     

       40
       48
        
         };

     

       41
       49
        
       }

pkgs/desktops/xfce/panel-plugins/xfce4-hardware-monitor-plugin.nix pkgs/desktops/xfce/panel-plugins/xfce4-hardware-monitor-plugin/default.nix

pkgs/desktops/xfce/panel-plugins/xfce4-i3-workspaces-plugin.nix pkgs/desktops/xfce/panel-plugins/xfce4-i3-workspaces-plugin/default.nix

pkgs/desktops/xfce/panel-plugins/xfce4-mailwatch-plugin.nix pkgs/desktops/xfce/panel-plugins/xfce4-mailwatch-plugin/default.nix

pkgs/desktops/xfce/panel-plugins/xfce4-mpc-plugin.nix pkgs/desktops/xfce/panel-plugins/xfce4-mpc-plugin/default.nix

pkgs/desktops/xfce/panel-plugins/xfce4-namebar-plugin.nix pkgs/desktops/xfce/panel-plugins/xfce4-namebar-plugin/default.nix

+18 -7

pkgs/desktops/xfce/panel-plugins/xfce4-notes-plugin.nix pkgs/desktops/xfce/panel-plugins/xfce4-notes-plugin/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchurl, fetchpatch, pkg-config, intltool, libxfce4util, xfce4-panel, libxfce4ui, xfconf, gtk2, libunique, xfce }:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , fetchpatch

     

       5
       5
       +
       , pkg-config

     

       6
       6
       +
       , intltool

     

       7
       7
       +
       , libxfce4util

     

       8
       8
       +
       , xfce4-panel

     

       9
       9
       +
       , libxfce4ui

     

       10
       10
       +
       , xfconf

     

       11
       11
       +
       , gtk2

     

       12
       12
       +
       , libunique

     

       13
       13
       +
       , xfce

     

       14
       14
       +
       }:

     

       2
       15
        
       

     

       3
       16
        
       let

     

       4
       17
        
         category = "panel-plugins";

     

       5
       5
       -
       in

     

       6
       6
       -
       

     

       7
       7
       -
       stdenv.mkDerivation rec {

     

       18
       18
       +
       in stdenv.mkDerivation rec {

     

       8
       19
        
         pname  = "xfce4-notes-plugin";

     

       9
       9
       -
         version = "1.8.1";

     

       20
       20
       +
         version = "1.9.0";

     

       10
       21
        
       

     

       11
       22
        
         src = fetchurl {

     

       12
       23
        
           url = "mirror://xfce/src/${category}/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.bz2";

     

       13
       13
       -
           sha256 = "1cjlvvcsigyh40xa26b2vc5zylgss0nlaw72sablzhii2kkw7907";

     

       24
       24
       +
           sha256 = "E/kJyUi2Oflt5kz3k+t0yxd5WJIB05M+/yFO6PNasIg=";

     

       14
       25
        
         };

     

       15
       26
        
       

     

       16
       27
        
         nativeBuildInputs = [

     
···

       40
       51
        
           description = "Sticky notes plugin for Xfce panel";

     

       41
       52
        
           license = licenses.gpl2Plus;

     

       42
       53
        
           platforms = platforms.linux;

     

       43
       43
       -
           maintainers = [ maintainers.AndersonTorres ];

     

       54
       54
       +
           maintainers = [ ];

     

       44
       55
        
         };

     

       45
       56
        
       }

pkgs/desktops/xfce/panel-plugins/xfce4-sensors-plugin.nix pkgs/desktops/xfce/panel-plugins/xfce4-sensors-plugin/default.nix

+15 -7

pkgs/desktops/xfce/panel-plugins/xfce4-systemload-plugin.nix pkgs/desktops/xfce/panel-plugins/xfce4-systemload-plugin/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchurl, pkg-config, intltool, libxfce4util, xfce4-panel, libxfce4ui, gtk3, xfce }:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , pkg-config

     

       5
       5
       +
       , intltool

     

       6
       6
       +
       , libxfce4util

     

       7
       7
       +
       , xfce4-panel

     

       8
       8
       +
       , libxfce4ui

     

       9
       9
       +
       , gtk3

     

       10
       10
       +
       , xfce

     

       11
       11
       +
       }:

     

       2
       12
        
       

     

       3
       13
        
       let

     

       4
       14
        
         category = "panel-plugins";

     

       5
       5
       -
       in

     

       6
       6
       -
       

     

       7
       7
       -
       stdenv.mkDerivation rec {

     

       15
       15
       +
       in stdenv.mkDerivation rec {

     

       8
       16
        
         pname  = "xfce4-systemload-plugin";

     

       9
       9
       -
         version = "1.2.3";

     

       17
       17
       +
         version = "1.2.4";

     

       10
       18
        
       

     

       11
       19
        
         src = fetchurl {

     

       12
       20
        
           url = "mirror://xfce/src/${category}/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.bz2";

     

       13
       13
       -
           sha256 = "0x87a8h5l3ashz1ksfaxcpn9a392jzlsbx5n5pga8g90fp2hf905";

     

       21
       21
       +
           sha256 = "BTG435I8ujvo0GTLi2OLlU33SRXlpEciiZlReEd4mDU=";

     

       14
       22
        
         };

     

       15
       23
        
       

     

       16
       24
        
         nativeBuildInputs = [

     
···

       36
       44
        
           description = "System load plugin for Xfce panel";

     

       37
       45
        
           license = licenses.bsd2;

     

       38
       46
        
           platforms = platforms.linux;

     

       39
       39
       -
           maintainers = [ maintainers.AndersonTorres ];

     

       47
       47
       +
           maintainers = [ ];

     

       40
       48
        
         };

     

       41
       49
        
       }

pkgs/desktops/xfce/panel-plugins/xfce4-timer-plugin.nix pkgs/desktops/xfce/panel-plugins/xfce4-timer-plugin/default.nix

+13 -5

pkgs/desktops/xfce/panel-plugins/xfce4-verve-plugin/default.nix

···

       1
       1
       -
       { lib, mkXfceDerivation, gtk3, libxfce4ui, pcre, libxfce4util, xfce4-panel, xfconf }:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , mkXfceDerivation

     

       3
       3
       +
       , gtk3

     

       4
       4
       +
       , libxfce4ui

     

       5
       5
       +
       , pcre

     

       6
       6
       +
       , libxfce4util

     

       7
       7
       +
       , xfce4-panel

     

       8
       8
       +
       , xfconf

     

       9
       9
       +
       }:

     

       2
       10
        
       

     

       3
       11
        
       mkXfceDerivation {

     

       4
       12
        
         category = "panel-plugins";

     

       5
       13
        
         pname = "xfce4-verve-plugin";

     

       6
       6
       -
         version = "2.0.0";

     

       14
       14
       +
         version = "2.0.1";

     

       7
       15
        
         rev-prefix = "";

     

       8
       8
       -
         sha256 = "09vpa6m0ah7pgmra094c16vb79xrcwva808g6zpawwrhcwz85lcz";

     

       16
       16
       +
         sha256 = "YwUOSTZMoHsWWmi/ajQv/fX8a0IJoc3re3laVEmnX/M=";

     

       9
       17
        
       

     

       10
       18
        
         buildInputs = [ gtk3 libxfce4ui pcre libxfce4util xfce4-panel ];

     

       11
       19
        
       

     

       12
       20
        
         hardeningDisable = [ "format" ];

     

       13
       21
        
       

     

       14
       14
       -
         meta = {

     

       22
       22
       +
         meta = with lib; {

     

       15
       23
        
           description = "A command-line plugin";

     

       16
       16
       -
           maintainers = with lib.maintainers; [ AndersonTorres ];

     

       24
       24
       +
           maintainers = with maintainers; [ ];

     

       17
       25
        
         };

     

       18
       26
        
       }

pkgs/desktops/xfce/panel-plugins/xfce4-weather-plugin.nix pkgs/desktops/xfce/panel-plugins/xfce4-weather-plugin/default.nix

pkgs/desktops/xfce/panel-plugins/xfce4-windowck-plugin.nix pkgs/desktops/xfce/panel-plugins/xfce4-windowck-plugin/default.nix

+26 -5

pkgs/desktops/xfce/panel-plugins/xfce4-xkb-plugin/default.nix

···

       1
       1
       -
       { lib, mkXfceDerivation, gtk3, librsvg, libwnck3, libxklavier, garcon, libxfce4ui, libxfce4util, xfce4-panel, xfconf }:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , mkXfceDerivation

     

       3
       3
       +
       , gtk3

     

       4
       4
       +
       , librsvg

     

       5
       5
       +
       , libwnck3

     

       6
       6
       +
       , libxklavier

     

       7
       7
       +
       , garcon

     

       8
       8
       +
       , libxfce4ui

     

       9
       9
       +
       , libxfce4util

     

       10
       10
       +
       , xfce4-panel

     

       11
       11
       +
       , xfconf

     

       12
       12
       +
       }:

     

       2
       13
        
       

     

       3
       14
        
       mkXfceDerivation {

     

       4
       15
        
         category = "panel-plugins";

     

       5
       16
        
         pname = "xfce4-xkb-plugin";

     

       6
       6
       -
         version = "0.8.1";

     

       17
       17
       +
         version = "0.8.2";

     

       7
       18
        
         rev-prefix = "";

     

       8
       8
       -
         sha256 = "1gyky4raynp2ggdnq0g96c6646fjm679fzipcsmf1q0aymr8d5ky";

     

       19
       19
       +
         sha256 = "xmCoNMxykeaThYEJo6BcbraFo9CruFZL6YPjovzb6hg=";

     

       9
       20
        
       

     

       10
       10
       -
         buildInputs = [ garcon gtk3 librsvg libxfce4ui libxfce4util libxklavier libwnck3 xfce4-panel xfconf ];

     

       21
       21
       +
         buildInputs = [

     

       22
       22
       +
           garcon

     

       23
       23
       +
           gtk3

     

       24
       24
       +
           librsvg

     

       25
       25
       +
           libxfce4ui

     

       26
       26
       +
           libxfce4util

     

       27
       27
       +
           libxklavier

     

       28
       28
       +
           libwnck3

     

       29
       29
       +
           xfce4-panel

     

       30
       30
       +
           xfconf

     

       31
       31
       +
         ];

     

       11
       32
        
       

     

       12
       33
        
         meta = with lib; {

     

       13
       34
        
           description = "Allows you to setup and use multiple keyboard layouts";

     

       14
       14
       -
           maintainers = [ maintainers.AndersonTorres ];

     

       35
       35
       +
           maintainers = [ ];

     

       15
       36
        
         };

     

       16
       37
        
       }

+7 -1

pkgs/development/compilers/crystal/default.nix

···

       255
       255
        
           extraBuildInputs = [ git ];

     

       256
       256
        
         };

     

       257
       257
        
       

     

       258
       258
       -
         crystal = crystal_0_35;

     

       258
       258
       +
         crystal_0_36 = generic {

     

       259
       259
       +
           version = "0.36.0";

     

       260
       260
       +
           sha256  = "0s7g13mrh2jrxxrrrg4hy3gi49rp7fmpn9zg9kj4nbc8w8yir20r";

     

       261
       261
       +
           binary = crystal_0_35;

     

       262
       262
       +
         };

     

       263
       263
       +
       

     

       264
       264
       +
         crystal = crystal_0_36;

     

       259
       265
        
       

     

       260
       266
        
         crystal2nix = callPackage ./crystal2nix.nix {};

     

       261
       267
        
       }

+27

pkgs/development/libraries/cxxopts/default.nix

···

       1
       1
       +
       { cmake, fetchFromGitHub, icu, lib, pkg-config, stdenv, enableUnicodeHelp ? true }:

     

       2
       2
       +
       

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       4
       4
       +
         name = "cxxopts";

     

       5
       5
       +
         version = "2.2.1";

     

       6
       6
       +
       

     

       7
       7
       +
         src = fetchFromGitHub {

     

       8
       8
       +
           owner = "jarro2783";

     

       9
       9
       +
           repo = name;

     

       10
       10
       +
           rev = "v${version}";

     

       11
       11
       +
           sha256 = "0d3y747lsh1wkalc39nxd088rbypxigm991lk3j91zpn56whrpha";

     

       12
       12
       +
         };

     

       13
       13
       +
       

     

       14
       14
       +
         buildInputs = lib.optional enableUnicodeHelp [ icu.dev ];

     

       15
       15
       +
         cmakeFlags = lib.optional enableUnicodeHelp [ "-DCXXOPTS_USE_UNICODE_HELP=TRUE" ];

     

       16
       16
       +
         nativeBuildInputs = [ cmake ] ++ lib.optional enableUnicodeHelp [ pkg-config ];

     

       17
       17
       +
       

     

       18
       18
       +
         doCheck = true;

     

       19
       19
       +
       

     

       20
       20
       +
         meta = with lib; {

     

       21
       21
       +
           homepage = "https://github.com/jarro2783/cxxopts";

     

       22
       22
       +
           description = "Lightweight C++ GNU-style option parser library";

     

       23
       23
       +
           license = licenses.mit;

     

       24
       24
       +
           maintainers = [ maintainers.spease ];

     

       25
       25
       +
           platforms = platforms.all;

     

       26
       26
       +
         };

     

       27
       27
       +
       }

+3 -25

pkgs/development/libraries/gdal/2.4.0.nix pkgs/development/libraries/gdal/2.4.nix

···

       1
       1
       -
       { lib, stdenv, fetchurl, fetchpatch, unzip, libjpeg, libtiff, zlib

     

       1
       1
       +
       { lib, stdenv, fetchurl, unzip, libjpeg, libtiff, zlib

     

       2
       2
        
       , postgresql, libmysqlclient, libgeotiff, pythonPackages, proj, geos, openssl

     

       3
       3
        
       , libpng, sqlite, libspatialite, poppler, hdf4, qhull, giflib, expat

     

       4
       4
        
       , libiconv, libxml2

     
···

       9
       9
        
       

     

       10
       10
        
       stdenv.mkDerivation rec {

     

       11
       11
        
         pname = "gdal";

     

       12
       12
       -
         version = "2.4.0";

     

       12
       12
       +
         version = "2.4.4";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchurl {

     

       15
       15
        
           url = "https://download.osgeo.org/gdal/${version}/${pname}-${version}.tar.xz";

     

       16
       16
       -
           sha256 = "09qgy36z0jc9w05373m4n0vm4j54almdzql6z9p9zr9pdp61syf3";

     

       16
       16
       +
           sha256 = "1n6w0m2603q9cldlz0wyscp75ci561dipc36jqbf3mjmylybv0x3";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
       -
         patches = [

     

       20
       20
       -
           (fetchpatch {

     

       21
       21
       -
             name = "CVE-2019-17545.patch";

     

       22
       22
       -
             url = "https://github.com/OSGeo/gdal/commit/8cd2d2eb6327cf782a74dae263ffa6f89f46c93d.patch";

     

       23
       23
       -
             stripLen = 1;

     

       24
       24
       -
             sha256 = "06h88a659jcqf6ps1m91qy78s6s9krbkwnz28f5qh7032vlp6qpw";

     

       25
       25
       -
           })

     

       26
       26
       -
         ];

     

       27
       27
       -
       

     

       28
       19
        
         buildInputs = [ unzip libjpeg libtiff libgeotiff libpng proj openssl sqlite

     

       29
       20
        
           libspatialite poppler hdf4 qhull giflib expat libxml2 proj ]

     

       30
       21
        
         ++ (with pythonPackages; [ python numpy wrapPython ])

     
···

       60
       51
        
             #ifdef swap\

     

       61
       52
        
             #undef swap\

     

       62
       53
        
             #endif' ogr/ogrsf_frmts/mysql/ogr_mysql.h

     

       63
       63
       -
           # poppler 0.73.0 support

     

       64
       64
       -
           patch -lp2 <${

     

       65
       65
       -
             fetchpatch {

     

       66
       66
       -
               url = "https://github.com/OSGeo/gdal/commit/29f4dfbcac2de718043f862166cd639ab578b552.diff";

     

       67
       67
       -
               sha256 = "1h2rsjjrgwqfgqzppmzv5jgjs1dbbg8pvfmay0j9y0618qp3r734";

     

       68
       68
       -
             }

     

       69
       69
       -
           } || true

     

       70
       70
       -
           patch -p2 <${

     

       71
       71
       -
             fetchpatch {

     

       72
       72
       -
               url = "https://github.com/OSGeo/gdal/commit/19967e682738977e11e1d0336e0178882c39cad2.diff";

     

       73
       73
       -
               sha256 = "12yqd77226i6xvzgqmxiac5ghdinixh8k2crg1r2gnhc0xlc3arj";

     

       74
       74
       -
             }

     

       75
       75
       -
           }

     

       76
       54
        
         '';

     

       77
       55
        
       

     

       78
       56
        
         # - Unset CC and CXX as they confuse libtool.

+10 -3

pkgs/development/libraries/libwebsockets/default.nix

···

       32
       32
        
               throughput in both directions.

     

       33
       33
        
             '';

     

       34
       34
        
             homepage = "https://libwebsockets.org/";

     

       35
       35
       -
             license = licenses.lgpl21;

     

       35
       35
       +
             # Relicensed from LGPLv2.1+ to MIT with 4.0. Licensing situation

     

       36
       36
       +
             # is tricky, see https://github.com/warmcat/libwebsockets/blob/main/LICENSE

     

       37
       37
       +
             license = with licenses; [ mit publicDomain bsd3 asl20 ];

     

       36
       38
        
             platforms = platforms.all;

     

       37
       39
        
           };

     

       38
       40
        
         };

     
···

       50
       52
        
         };

     

       51
       53
        
       

     

       52
       54
        
         libwebsockets_4_0 = generic {

     

       53
       53
       -
           version = "4.0.1";

     

       54
       54
       -
           sha256 = "1pf7km0w5q7dqlwcwqizdpfqgg10prfq8g2c093f5nghwsfv8mmf";

     

       55
       55
       +
           version = "4.0.21";

     

       56
       56
       +
           sha256 = "01k05x4711ngin598jr9dag4ml3m7hi6pkgr4dsb02ryh1kc6146";

     

       57
       57
       +
         };

     

       58
       58
       +
       

     

       59
       59
       +
         libwebsockets_4_1 = generic {

     

       60
       60
       +
           version = "4.1.6";

     

       61
       61
       +
           sha256 = "0x56v4hsx92vm1zibfmnqb5g3v23kzciffn3fjlsc3sly2pknhsg";

     

       55
       62
        
         };

     

       56
       63
        
       }

+7 -7

pkgs/development/libraries/opendkim/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchurl, pkg-config, libbsd, openssl, libmilter

     

       1
       1
       +
       { lib, stdenv, fetchFromGitHub, pkg-config, libbsd, openssl, libmilter

     

       2
       2
        
       , autoreconfHook, perl, makeWrapper }:

     

       3
       3
        
       

     

       4
       4
        
       stdenv.mkDerivation rec {

     

       5
       5
        
         pname = "opendkim";

     

       6
       6
       -
         version = "2.10.3";

     

       6
       6
       +
         version = "2.11.0-Beta2";

     

       7
       7
        
       

     

       8
       8
       -
         src = fetchurl {

     

       9
       9
       -
           url = "mirror://sourceforge/opendkim/files/${pname}-${version}.tar.gz";

     

       10
       10
       -
           sha256 = "06v8bqhh604sz9rh5bvw278issrwjgc4h1wx2pz9a84lpxbvm823";

     

       8
       8
       +
         src = fetchFromGitHub {

     

       9
       9
       +
           owner = "trusteddomainproject";

     

       10
       10
       +
           repo = "OpenDKIM";

     

       11
       11
       +
           rev = "rel-opendkim-${lib.replaceChars ["."] ["-"] version}";

     

       12
       12
       +
           sha256 = "0nx3in8sa6xna4vfacj8g60hfzk61jpj2ldag80xzxip9c3rd2pw";

     

       11
       13
        
         };

     

       12
       14
        
       

     

       13
       15
        
         configureFlags= [

     
···

       19
       21
        
         nativeBuildInputs = [ autoreconfHook pkg-config makeWrapper ];

     

       20
       22
        
       

     

       21
       23
        
         buildInputs = [ libbsd openssl libmilter perl ];

     

       22
       22
       -
       

     

       23
       23
       -
         patches = [ ./openssl-1.1.patch ];

     

       24
       24
        
       

     

       25
       25
        
         postInstall = ''

     

       26
       26
        
           wrapProgram $out/sbin/opendkim-genkey \

-81

pkgs/development/libraries/opendkim/openssl-1.1.patch

···

       1
       1
       -
       --- a/configure.ac

     

       2
       2
       -
       +++ b/configure.ac

     

       3
       3
       -
       @@ -864,26 +864,28 @@

     

       4
       4
       -
        	AC_SEARCH_LIBS([ERR_peek_error], [crypto], ,

     

       5
       5
       -
        	               AC_MSG_ERROR([libcrypto not found]))

     

       6
       6
       -
        

     

       7
       7
       -
       -	AC_SEARCH_LIBS([SSL_library_init], [ssl], ,

     

       8
       8
       -
       -		[

     

       9
       9
       -
       -			if test x"$enable_shared" = x"yes"

     

       10
       10
       -
       -			then

     

       11
       11
       -
       -				AC_MSG_ERROR([Cannot build shared opendkim

     

       12
       12
       -
       -				              against static openssl libraries.

     

       13
       13
       -
       -				              Configure with --disable-shared

     

       14
       14
       -
       -				              to get this working or obtain a

     

       15
       15
       -
       -				              shared libssl library for

     

       16
       16
       -
       -				              opendkim to use.])

     

       17
       17
       -
       -			fi

     

       18
       18
       -
       -

     

       19
       19
       -
       -			# avoid caching issue - last result of SSL_library_init

     

       20
       20
       -
       -			# shouldn't be cached for this next check

     

       21
       21
       -
       -			unset ac_cv_search_SSL_library_init

     

       22
       22
       -
       -			LIBCRYPTO_LIBS="$LIBCRYPTO_LIBS -ldl"

     

       23
       23
       -
       -			AC_SEARCH_LIBS([SSL_library_init], [ssl], ,

     

       24
       24
       -
       -			               AC_MSG_ERROR([libssl not found]), [-ldl])

     

       25
       25
       -
       -		]

     

       26
       26
       -
       -	)

     

       27
       27
       -
       +

     

       28
       28
       -
       +	AC_LINK_IFELSE(

     

       29
       29
       -
       +		       [AC_LANG_PROGRAM([[#include <openssl/ssl.h>]],

     

       30
       30
       -
       +					[[SSL_library_init();]])],

     

       31
       31
       -
       +					[od_have_ossl="yes";],

     

       32
       32
       -
       +					[od_have_ossl="no";])

     

       33
       33
       -
       +	if test x"$od_have_ossl" = x"no"

     

       34
       34
       -
       +	then

     

       35
       35
       -
       +		if test x"$enable_shared" = x"yes"

     

       36
       36
       -
       +		then

     

       37
       37
       -
       +			AC_MSG_ERROR([Cannot build shared opendkim

     

       38
       38
       -
       +			              against static openssl libraries.

     

       39
       39
       -
       +			              Configure with --disable-shared

     

       40
       40
       -
       +			              to get this working or obtain a

     

       41
       41
       -
       +			              shared libssl library for

     

       42
       42
       -
       +			              opendkim to use.])

     

       43
       43
       -
       +		fi

     

       44
       44
       -
       +

     

       45
       45
       -
       +		LIBCRYPTO_LIBS="$LIBCRYPTO_LIBS -ldl"

     

       46
       46
       -
       +		AC_SEARCH_LIBS([SSL_library_init], [ssl], ,

     

       47
       47
       -
       +		               AC_MSG_ERROR([libssl not found]), [-ldl])

     

       48
       48
       -
       +	fi

     

       49
       49
       -
        

     

       50
       50
       -
        	AC_CHECK_DECL([SHA256_DIGEST_LENGTH],

     

       51
       51
       -
                              AC_DEFINE([HAVE_SHA256], 1,

     

       52
       52
       -
       --- a/opendkim/opendkim-crypto.c

     

       53
       53
       -
       +++ b/opendkim/opendkim-crypto.c

     

       54
       54
       -
       @@ -222,7 +222,11 @@

     

       55
       55
       -
        	{

     

       56
       56
       -
        		assert(pthread_setspecific(id_key, ptr) == 0);

     

       57
       57
       -
        

     

       58
       58
       -
       +#if OPENSSL_VERSION_NUMBER >= 0x10100000

     

       59
       59
       -
       +		OPENSSL_thread_stop();

     

       60
       60
       -
       +#else

     

       61
       61
       -
        		ERR_remove_state(0);

     

       62
       62
       -
       +#endif

     

       63
       63
       -
        

     

       64
       64
       -
        		free(ptr);

     

       65
       65
       -
        

     

       66
       66
       -
       @@ -392,11 +396,15 @@

     

       67
       67
       -
        {

     

       68
       68
       -
        	if (crypto_init_done)

     

       69
       69
       -
        	{

     

       70
       70
       -
       +#if OPENSSL_VERSION_NUMBER >= 0x10100000

     

       71
       71
       -
       +		OPENSSL_thread_stop();

     

       72
       72
       -
       +#else

     

       73
       73
       -
        		CRYPTO_cleanup_all_ex_data();

     

       74
       74
       -
        		CONF_modules_free();

     

       75
       75
       -
        		EVP_cleanup();

     

       76
       76
       -
        		ERR_free_strings();

     

       77
       77
       -
        		ERR_remove_state(0);

     

       78
       78
       -
       +#endif

     

       79
       79
       -
        

     

       80
       80
       -
        		if (nmutexes > 0)

     

       81
       81
       -
        		{

+2 -2

pkgs/development/ocaml-modules/elpi/default.nix

···

       17
       17
        
       

     

       18
       18
        
         minimumOCamlVersion = "4.04";

     

       19
       19
        
       

     

       20
       20
       -
         buildInputs = [ perl ncurses ppxlib ];

     

       20
       20
       +
         buildInputs = [ perl ncurses ];

     

       21
       21
        
       

     

       22
       22
       -
         propagatedBuildInputs = [ camlp5 ppx_deriving re ];

     

       22
       22
       +
         propagatedBuildInputs = [ camlp5 ppxlib ppx_deriving re ];

     

       23
       23
        
       

     

       24
       24
        
         meta = {

     

       25
       25
        
           description = "Embeddable λProlog Interpreter";

+2 -2

pkgs/development/ocaml-modules/jingoo/default.nix

···

       1
       1
        
       { lib, buildDunePackage, fetchFromGitHub

     

       2
       2
       -
       , menhir, ppx_deriving, re, uutf, uucp, ounit2 }:

     

       2
       2
       +
       , menhir, ppxlib, ppx_deriving, re, uutf, uucp, ounit2 }:

     

       3
       3
        
       

     

       4
       4
        
       buildDunePackage rec {

     

       5
       5
        
         pname = "jingoo";

     
···

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         buildInputs = [ menhir ];

     

       20
       20
       -
         propagatedBuildInputs = [ ppx_deriving re uutf uucp ];

     

       20
       20
       +
         propagatedBuildInputs = [ ppxlib ppx_deriving re uutf uucp ];

     

       21
       21
        
         checkInputs = [ ounit2 ];

     

       22
       22
        
         doCheck = true;

     

       23
       23

+3

pkgs/development/ocaml-modules/jwto/default.nix

···

       1
       1
        
       { lib, buildDunePackage, fetchFromGitHub, alcotest, cryptokit, fmt, yojson

     

       2
       2
       +
       , ppxlib

     

       2
       3
        
       , base64, re, ppx_deriving }:

     

       3
       4
        
       

     

       4
       5
        
       buildDunePackage rec {

     
···

       15
       16
        
           rev = version;

     

       16
       17
        
           sha256 = "1p799zk8j9c0002xzi2x7ndj1bzqf14744ampcqndrjnsi7mq71s";

     

       17
       18
        
         };

     

       19
       19
       +
       

     

       20
       20
       +
         buildInputs = [ ppxlib ];

     

       18
       21
        
       

     

       19
       22
        
         propagatedBuildInputs =

     

       20
       23
        
           [ cryptokit fmt yojson base64 re ppx_deriving ];

+1

pkgs/development/ocaml-modules/lens/default.nix

···

       24
       24
        
           maintainers = with maintainers; [

     

       25
       25
        
             kazcw

     

       26
       26
        
           ];

     

       27
       27
       +
           broken = true; # Not compatible with ppx_deriving ≥ 5.0

     

       27
       28
        
         };

     

       28
       29
        
       }

+4 -3

pkgs/development/ocaml-modules/mirage-nat/default.nix

···

       2
       2
        
       , ipaddr, cstruct, lwt, rresult, logs, lru

     

       3
       3
        
       , tcpip, ethernet, stdlib-shims

     

       4
       4
        
       , alcotest, mirage-clock-unix

     

       5
       5
       -
       , ppx_deriving

     

       5
       5
       +
       , ppxlib, ppx_deriving

     

       6
       6
        
       }:

     

       7
       7
        
       

     

       8
       8
        
       buildDunePackage rec {

     
···

       19
       19
        
           sha256 = "0cy95j184hi8fm1h6z6x1brjfrmbq3zjy2mqz99m8ys9vwkb63ma";

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
       -
         nativeBuildInputs = [

     

       23
       23
       -
           ppx_deriving

     

       22
       22
       +
         buildInputs = [

     

       23
       23
       +
           ppxlib

     

       24
       24
        
         ];

     

       25
       25
        
       

     

       26
       26
        
         propagatedBuildInputs = [

     
···

       33
       33
        
           tcpip

     

       34
       34
        
           ethernet

     

       35
       35
        
           stdlib-shims

     

       36
       36
       +
           ppx_deriving

     

       36
       37
        
         ];

     

       37
       38
        
       

     

       38
       39
        
         doCheck = true;

+4

pkgs/development/ocaml-modules/nocrypto/default.nix

···

       15
       15
        
         '';

     

       16
       16
        
       in

     

       17
       17
        
       

     

       18
       18
       +
       if !versionAtLeast ocaml.version "4.08"

     

       19
       19
       +
       then throw "nocrypto is not available for OCaml ${ocaml.version}"

     

       20
       20
       +
       else

     

       21
       21
       +
       

     

       18
       22
        
       stdenv.mkDerivation rec {

     

       19
       23
        
         name = "ocaml${ocaml.version}-nocrypto-${version}";

     

       20
       24
        
         version = "0.5.4";

+1 -1

pkgs/development/ocaml-modules/pgocaml/default.nix

···

       12
       12
        
           sha256 = "1rdypc83nap9j2ml9r6n1pzgf79gk1yffwyi6fmcrl7zmy01cg0n";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
       -
         minimumOCamlVersion = "4.07";

     

       15
       15
       +
         minimumOCamlVersion = "4.08";

     

       16
       16
        
         useDune2 = true;

     

       17
       17
        
       

     

       18
       18
        
         propagatedBuildInputs = [ calendar csv hex ppx_deriving ppx_sexp_conv re rresult sexplib ];

+22 -8

pkgs/development/ocaml-modules/ppx_deriving/default.nix

···

       1
       1
       -
       { lib, fetchzip, buildDunePackage

     

       2
       2
       -
       , cppo, ppxfind, ppx_tools, ppx_derivers, result, ounit, ocaml-migrate-parsetree

     

       1
       1
       +
       { lib, fetchurl, buildDunePackage

     

       2
       2
       +
       , cppo, ppxlib, ppx_derivers, result, ounit, ocaml-migrate-parsetree

     

       3
       3
        
       }:

     

       4
       4
       +
       

     

       5
       5
       +
       let params =

     

       6
       6
       +
         if lib.versionAtLeast ppxlib.version "0.15"

     

       7
       7
       +
         then {

     

       8
       8
       +
           version = "5.1";

     

       9
       9
       +
           sha256 = "1i64fd7qrfzbam5hfbl01r0sx4iihsahcwqj13smmrjlnwi3nkxh";

     

       10
       10
       +
         } else {

     

       11
       11
       +
           version = "5.0";

     

       12
       12
       +
           sha256 = "0fkzrn4pdyvf1kl0nwvhqidq01pnq3ql8zk1jd56hb0cxaw851w3";

     

       13
       13
       +
         }

     

       14
       14
       +
       ; in

     

       4
       15
        
       

     

       5
       16
        
       buildDunePackage rec {

     

       6
       17
        
         pname = "ppx_deriving";

     

       7
       7
       -
         version = "4.5";

     

       18
       18
       +
         inherit (params) version;

     

       8
       19
        
       

     

       9
       9
       -
         src = fetchzip {

     

       10
       10
       -
           url = "https://github.com/ocaml-ppx/ppx_deriving/archive/v${version}.tar.gz";

     

       11
       11
       -
           sha256 = "1v2xldag54n0xk69vv3j4nln9bzkkpq3rildq118sydzsc9v239z";

     

       20
       20
       +
         useDune2 = true;

     

       21
       21
       +
       

     

       22
       22
       +
         src = fetchurl {

     

       23
       23
       +
           url = "https://github.com/ocaml-ppx/ppx_deriving/releases/download/v${version}/ppx_deriving-v${version}.tbz";

     

       24
       24
       +
           inherit (params) sha256;

     

       12
       25
        
         };

     

       13
       26
        
       

     

       14
       14
       -
         buildInputs = [ ppxfind cppo ounit ];

     

       15
       15
       -
         propagatedBuildInputs = [ ocaml-migrate-parsetree ppx_derivers ppx_tools result ];

     

       27
       27
       +
         buildInputs = [ ppxlib cppo ];

     

       28
       28
       +
         propagatedBuildInputs = [ ocaml-migrate-parsetree ppx_derivers result ];

     

       16
       29
        
       

     

       17
       30
        
         doCheck = true;

     

       31
       31
       +
         checkInputs = [ ounit ];

     

       18
       32
        
       

     

       19
       33
        
         meta = with lib; {

     

       20
       34
        
           description = "deriving is a library simplifying type-driven code generation on OCaml >=4.02.";

+1

pkgs/development/ocaml-modules/ppx_deriving_protobuf/default.nix

···

       23
       23
        
           description = "A Protocol Buffers codec generator for OCaml";

     

       24
       24
        
           license = licenses.mit;

     

       25
       25
        
           maintainers = [ maintainers.vyorkin ];

     

       26
       26
       +
           broken = true;

     

       26
       27
        
         };

     

       27
       28
        
       }

+8 -7

pkgs/development/ocaml-modules/ppx_deriving_yojson/default.nix

···

       1
       1
       -
       { lib, buildDunePackage, fetchFromGitHub, ppxfind, ounit

     

       1
       1
       +
       { lib, buildDunePackage, fetchFromGitHub, ppxlib, ounit

     

       2
       2
        
       , ppx_deriving, yojson

     

       3
       3
        
       }:

     

       4
       4
        
       

     

       5
       5
        
       buildDunePackage rec {

     

       6
       6
        
         pname = "ppx_deriving_yojson";

     

       7
       7
       -
         version = "3.5.3";

     

       7
       7
       +
         version = "3.6.1";

     

       8
       8
        
       

     

       9
       9
       -
         minimumOCamlVersion = "4.04";

     

       9
       9
       +
         useDune2 = true;

     

       10
       10
       +
       

     

       11
       11
       +
         minimumOCamlVersion = "4.07";

     

       10
       12
        
       

     

       11
       13
        
         src = fetchFromGitHub {

     

       12
       14
        
           owner = "ocaml-ppx";

     

       13
       15
        
           repo = "ppx_deriving_yojson";

     

       14
       16
        
           rev = "v${version}";

     

       15
       15
       -
           sha256 = "030638gp39mr4hkilrjhd98q4s8gjqxifm6fy6bwqrg74hmrl2y5";

     

       17
       17
       +
           sha256 = "1icz5h6p3pfj7my5gi7wxpflrb8c902dqa17f9w424njilnpyrbk";

     

       16
       18
        
         };

     

       17
       19
        
       

     

       18
       18
       -
         buildInputs = [ ppxfind ounit ];

     

       19
       19
       -
       

     

       20
       20
       -
         propagatedBuildInputs = [ ppx_deriving yojson ];

     

       20
       20
       +
         propagatedBuildInputs = [ ppxlib ppx_deriving yojson ];

     

       21
       21
        
       

     

       22
       22
        
         doCheck = true;

     

       23
       23
       +
         checkInputs = [ ounit ];

     

       23
       24
        
       

     

       24
       25
        
         meta = {

     

       25
       26
        
           description = "A Yojson codec generator for OCaml >= 4.04";

+1 -1

pkgs/development/ocaml-modules/ppx_tools/default.nix

···

       4
       4
        
         let v6_3 = {

     

       5
       5
        
           version = "6.3";

     

       6
       6
        
           sha256 = "1skf4njvkifwx0qlsrc0jn891gvvcp5ryd6kkpx56hck7nnxv8x6";

     

       7
       7
       -
           useDune2 = lib.versionAtLeast ocaml.version "4.12";

     

       7
       7
       +
           useDune2 = true;

     

       8
       8
        
           buildInputs = [cppo];

     

       9
       9
        
         }; in

     

       10
       10
        
       {

+5 -7

pkgs/development/ocaml-modules/visitors/default.nix

···

       1
       1
       -
       { lib, buildDunePackage, fetchFromGitLab, ppx_tools, ppx_deriving, result, cppo }:

     

       1
       1
       +
       { lib, buildDunePackage, fetchFromGitLab, ppxlib, ppx_deriving, result }:

     

       2
       2
        
       

     

       3
       3
        
       buildDunePackage rec {

     

       4
       4
        
         pname = "visitors";

     

       5
       5
       -
         version = "20200210";

     

       5
       5
       +
         version = "20210127";

     

       6
       6
        
       

     

       7
       7
        
         useDune2 = true;

     

       8
       8
        
       

     

       9
       9
       -
         minimumOCamlVersion = "4.02.3";

     

       9
       9
       +
         minimumOCamlVersion = "4.07";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchFromGitLab {

     

       12
       12
        
           owner = "fpottier";

     

       13
       13
        
           repo = pname;

     

       14
       14
        
           rev = version;

     

       15
       15
        
           domain = "gitlab.inria.fr";

     

       16
       16
       -
           sha256 = "12i099h1hc1walabiwqbinnpgcxkc1wn72913v7v6vvyif21rb5a";

     

       16
       16
       +
           sha256 = "0b73h7d4yv04a0b5x2i222jknbcgf9vvxzfjxzy2jwanxz9d873z";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
       -
         buildInputs = [ cppo ];

     

       20
       20
       -
       

     

       21
       21
       -
         propagatedBuildInputs = [ ppx_tools ppx_deriving result ];

     

       19
       19
       +
         propagatedBuildInputs = [ ppxlib ppx_deriving result ];

     

       22
       20
        
       

     

       23
       21
        
         meta = with lib; {

     

       24
       22
        
           homepage = "https://gitlab.inria.fr/fpottier/visitors";

+2 -2

pkgs/development/php-packages/pdo_sqlsrv/default.nix

···

       3
       3
        
       buildPecl {

     

       4
       4
        
         pname = "pdo_sqlsrv";

     

       5
       5
        
       

     

       6
       6
       -
         version = "5.8.1";

     

       7
       7
       -
         sha256 = "06ba4x34fgs092qq9w62y2afsm1nyasqiprirk4951ax9v5vcir0";

     

       6
       6
       +
         version = "5.9.0";

     

       7
       7
       +
         sha256 = "0n4cnkldvyp1lrpj18ky2ii2dcaa51dsmh8cspixm7w76dxl3khg";

     

       8
       8
        
       

     

       9
       9
        
         internalDeps = [ php.extensions.pdo ];

     

       10
       10

+2 -2

pkgs/development/php-packages/sqlsrv/default.nix

···

       3
       3
        
       buildPecl {

     

       4
       4
        
         pname = "sqlsrv";

     

       5
       5
        
       

     

       6
       6
       -
         version = "5.8.1";

     

       7
       7
       -
         sha256 = "0c9a6ghch2537vi0274vx0mn6nb1xg2qv7nprnf3xdfqi5ww1i9r";

     

       6
       6
       +
         version = "5.9.0";

     

       7
       7
       +
         sha256 = "1css440b4qrbblmcswd5wdr2v1rjxlj2iicbmvjq9fg81028w40a";

     

       8
       8
        
       

     

       9
       9
        
         buildInputs = [

     

       10
       10
        
           pkgs.unixODBC

+2 -2

pkgs/development/python-modules/adafruit-platformdetect/default.nix

···

       6
       6
        
       

     

       7
       7
        
       buildPythonPackage rec {

     

       8
       8
        
         pname = "Adafruit-PlatformDetect";

     

       9
       9
       -
         version = "2.27.1";

     

       9
       9
       +
         version = "2.28.0";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchPypi {

     

       12
       12
        
           inherit pname version;

     

       13
       13
       -
           sha256 = "0rnmy74rjjcyni5sr8h1djffpj7wngn2wqckl5vknp2smaihp34l";

     

       13
       13
       +
           sha256 = "aa272605fd8a2ddcc6e5dd8151d628f76a9468c97ba7e4e315d6bc78b9bfb8f8";

     

       14
       14
        
         };

     

       15
       15
        
       

     

       16
       16
        
         nativeBuildInputs = [ setuptools-scm ];

+2 -2

pkgs/development/python-modules/deprecated/default.nix

···

       3
       3
        
       

     

       4
       4
        
       buildPythonPackage rec {

     

       5
       5
        
         pname = "Deprecated";

     

       6
       6
       -
         version = "1.2.10";

     

       6
       6
       +
         version = "1.2.11";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchPypi {

     

       9
       9
        
           inherit pname version;

     

       10
       10
       -
           sha256 = "0x3zkmykcyjn8k57g8lcf89fxw8q7hvvcj6xkwb0f2zrnmpscnsj";

     

       10
       10
       +
           sha256 = "471ec32b2755172046e28102cd46c481f21c6036a0ec027521eba8521aa4ef35";

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
         propagatedBuildInputs = [ wrapt ];

+2 -2

pkgs/development/python-modules/django_reversion/default.nix

···

       6
       6
        
       

     

       7
       7
        
       buildPythonPackage rec {

     

       8
       8
        
         pname = "django-reversion";

     

       9
       9
       -
         version = "3.0.8";

     

       9
       9
       +
         version = "3.0.9";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchPypi {

     

       12
       12
        
           inherit pname version;

     

       13
       13
       -
           sha256 = "49e9930f90322dc6a2754dd26144285cfcc1c5bd0c1c39ca95d5602c5054ae32";

     

       13
       13
       +
           sha256 = "a5af55f086a3f9c38be2f049c251e06005b9ed48ba7a109473736b1fc95a066f";

     

       14
       14
        
         };

     

       15
       15
        
       

     

       16
       16
        
         # tests assume the availability of a mysql/postgresql database

+6 -2

pkgs/development/python-modules/dufte/default.nix

···

       11
       11
        
       

     

       12
       12
        
       buildPythonPackage rec {

     

       13
       13
        
         pname = "dufte";

     

       14
       14
       -
         version = "0.2.9";

     

       14
       14
       +
         version = "0.2.12";

     

       15
       15
        
         disabled = !isPy3k;

     

       16
       16
        
       

     

       17
       17
        
         src = fetchPypi {

     

       18
       18
        
           inherit pname version;

     

       19
       19
       -
           sha256 = "0nkaczipbsm8c14j9svxry2wigmn5iharibb6b8g062sjaph8x17";

     

       19
       19
       +
           sha256 = "0ag1d7h1wijkc7v2vpgkbqjlnpiwd4nh8zhxiby0989bpmlp3jr3";

     

       20
       20
        
         };

     

       21
       21
        
         format = "pyproject";

     

       22
       22
        
       

     
···

       34
       34
        
         '';

     

       35
       35
        
         checkInputs = [ pytestCheckHook ];

     

       36
       36
        
         pythonImportsCheck = [ "dufte" ];

     

       37
       37
       +
         pytestFlagsArray = [

     

       38
       38
       +
           # we don't have the "exdown" package (yet)

     

       39
       39
       +
           "--ignore=test/test_readme.py"

     

       40
       40
       +
         ];

     

       37
       41
        
       

     

       38
       42
        
         meta = with lib; {

     

       39
       43
        
           description = "Clean matplotlib plots";

+42

pkgs/development/python-modules/imap-tools/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , buildPythonPackage

     

       3
       3
       +
       , isPy27

     

       4
       4
       +
       , fetchFromGitHub

     

       5
       5
       +
       , pytestCheckHook

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       buildPythonPackage rec {

     

       9
       9
       +
         pname = "imap-tools";

     

       10
       10
       +
         version = "0.37.0";

     

       11
       11
       +
       

     

       12
       12
       +
         disabled = isPy27;

     

       13
       13
       +
       

     

       14
       14
       +
         src = fetchFromGitHub {

     

       15
       15
       +
           owner = "ikvk";

     

       16
       16
       +
           repo = "imap_tools";

     

       17
       17
       +
           rev = "v${version}";

     

       18
       18
       +
           sha256 = "1501lk3fjxqmzxffahbj33y795gwl96yqvk3fs86cchm6vz2gnkk";

     

       19
       19
       +
         };

     

       20
       20
       +
       

     

       21
       21
       +
         checkInputs = [

     

       22
       22
       +
           pytestCheckHook

     

       23
       23
       +
         ];

     

       24
       24
       +
       

     

       25
       25
       +
         disabledTests = [

     

       26
       26
       +
           # tests require a network connection

     

       27
       27
       +
           "test_action"

     

       28
       28
       +
           "test_folders"

     

       29
       29
       +
           "test_connectio"

     

       30
       30
       +
           "test_attributes"

     

       31
       31
       +
           "test_live"

     

       32
       32
       +
         ];

     

       33
       33
       +
       

     

       34
       34
       +
         pythonImportsCheck = [ "imap_tools" ];

     

       35
       35
       +
       

     

       36
       36
       +
         meta = with lib; {

     

       37
       37
       +
           description = "Work with email and mailbox by IMAP";

     

       38
       38
       +
           homepage = "https://github.com/ikvk/imap_tools";

     

       39
       39
       +
           license = licenses.asl20;

     

       40
       40
       +
           maintainers = with maintainers; [ dotlambda ];

     

       41
       41
       +
         };

     

       42
       42
       +
       }

+2 -2

pkgs/development/python-modules/mautrix/default.nix

···

       4
       4
        
       

     

       5
       5
        
       buildPythonPackage rec {

     

       6
       6
        
         pname = "mautrix";

     

       7
       7
       -
         version = "0.8.9";

     

       7
       7
       +
         version = "0.8.11";

     

       8
       8
        
       

     

       9
       9
        
         src = fetchPypi {

     

       10
       10
        
           inherit pname version;

     

       11
       11
       -
           sha256 = "13669a0150370c96cabcff859fb4d17f4a539dc7c707ff0c99c00612e24f5447";

     

       11
       11
       +
           sha256 = "d1958b9bd8c2631ccd6ebd4a54e35e5190dae2c0daeb786aec02f263b2c2e0b1";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         propagatedBuildInputs = [

+21

pkgs/development/python-modules/npyscreen/default.nix

···

       1
       1
       +
       { lib, buildPythonPackage, fetchPypi }:

     

       2
       2
       +
       

     

       3
       3
       +
       buildPythonPackage rec {

     

       4
       4
       +
         pname = "npyscreen";

     

       5
       5
       +
         version = "4.10.5";

     

       6
       6
       +
       

     

       7
       7
       +
         src = fetchPypi {

     

       8
       8
       +
          inherit pname version;

     

       9
       9
       +
          sha256 = "0vhjwn0dan3zmffvh80dxb4x67jysvvf1imp6pk4dsfslpwy0bk2";

     

       10
       10
       +
         };

     

       11
       11
       +
       

     

       12
       12
       +
         # Tests are outdated

     

       13
       13
       +
         doCheck = false;

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with lib; {

     

       16
       16
       +
           description = "Framework for developing console applications using Python and curses";

     

       17
       17
       +
           homepage = "http://www.npcole.com/npyscreen/";

     

       18
       18
       +
           maintainers = with maintainers; [ dump_stack ];

     

       19
       19
       +
           license = licenses.bsd3;

     

       20
       20
       +
         };

     

       21
       21
       +
       }

+30

pkgs/development/python-modules/sphinx-autobuild/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , buildPythonPackage

     

       4
       4
       +
       , fetchPypi

     

       5
       5
       +
       , sphinx

     

       6
       6
       +
       , livereload

     

       7
       7
       +
       }:

     

       8
       8
       +
       

     

       9
       9
       +
       buildPythonPackage rec {

     

       10
       10
       +
         pname = "sphinx-autobuild";

     

       11
       11
       +
         version = "2020.9.1";

     

       12
       12
       +
       

     

       13
       13
       +
         src = fetchPypi {

     

       14
       14
       +
           inherit pname version;

     

       15
       15
       +
           sha256 = "1vbaf4vrxahylyp8zrlw5dx1d2faajp926c3pl5i1wlkp1yll62b";

     

       16
       16
       +
         };

     

       17
       17
       +
       

     

       18
       18
       +
         propagatedBuildInputs = [ sphinx livereload ];

     

       19
       19
       +
       

     

       20
       20
       +
         # No tests included.

     

       21
       21
       +
         doCheck = false;

     

       22
       22
       +
         pythonImportsCheck = [ "sphinx_autobuild" ];

     

       23
       23
       +
       

     

       24
       24
       +
         meta = with lib; {

     

       25
       25
       +
           description = "Rebuild Sphinx documentation on changes, with live-reload in the browser";

     

       26
       26
       +
           homepage = "https://github.com/executablebooks/sphinx-autobuild";

     

       27
       27
       +
           license = with licenses; [ mit ];

     

       28
       28
       +
           maintainer = with maintainers; [holgerpeters];

     

       29
       29
       +
         };

     

       30
       30
       +
       }

+12

pkgs/misc/vim-plugins/generated.nix

···

       2194
       2194
        
           meta.homepage = "https://github.com/junegunn/limelight.vim/";

     

       2195
       2195
        
         };

     

       2196
       2196
        
       

     

       2197
       2197
       +
         lispdocs-nvim = buildVimPluginFrom2Nix {

     

       2198
       2198
       +
           pname = "lispdocs-nvim";

     

       2199
       2199
       +
           version = "2021-01-26";

     

       2200
       2200
       +
           src = fetchFromGitHub {

     

       2201
       2201
       +
             owner = "tami5";

     

       2202
       2202
       +
             repo = "lispdocs.nvim";

     

       2203
       2203
       +
             rev = "3c506bbffb2608f3671f0c41c28fb9f6626353d5";

     

       2204
       2204
       +
             sha256 = "0m4iscxwdglvlkxhzs9gzx1iqvnvgknqxgss5k00wr0nrax8q3pl";

     

       2205
       2205
       +
           };

     

       2206
       2206
       +
           meta.homepage = "https://github.com/tami5/lispdocs.nvim/";

     

       2207
       2207
       +
         };

     

       2208
       2208
       +
       

     

       2197
       2209
        
         lsp-status-nvim = buildVimPluginFrom2Nix {

     

       2198
       2210
        
           pname = "lsp-status-nvim";

     

       2199
       2211
        
           version = "2021-01-05";

+1

pkgs/misc/vim-plugins/vim-plugin-names

···

       543
       543
        
       t9md/vim-choosewin

     

       544
       544
        
       t9md/vim-smalls

     

       545
       545
        
       takac/vim-hardtime

     

       546
       546
       +
       tami5/lispdocs.nvim

     

       546
       547
        
       tami5/sql.nvim

     

       547
       548
        
       tbodt/deoplete-tabnine

     

       548
       549
        
       ternjs/tern_for_vim

+1 -1

pkgs/os-specific/linux/batman-adv/default.nix

···

       25
       25
        
           homepage = "https://www.open-mesh.org/projects/batman-adv/wiki/Wiki";

     

       26
       26
        
           description = "B.A.T.M.A.N. routing protocol in a linux kernel module for layer 2";

     

       27
       27
        
           license = lib.licenses.gpl2;

     

       28
       28
       -
           maintainers = with lib.maintainers; [ fpletz ];

     

       28
       28
       +
           maintainers = with lib.maintainers; [ fpletz hexa ];

     

       29
       29
        
           platforms = with lib.platforms; linux;

     

       30
       30
        
         };

     

       31
       31
        
       }

+4 -4

pkgs/os-specific/linux/batman-adv/version.nix

···

       1
       1
        
       {

     

       2
       2
       -
         version = "2020.4";

     

       2
       2
       +
         version = "2021.0";

     

       3
       3
        
       

     

       4
       4
        
         sha256 = {

     

       5
       5
       -
           batman-adv = "1cxr0zmn9nzisawkrfk0gzd9fx0pg6261c889kz47hwp4f545v6d";

     

       6
       6
       -
           alfred = "1ay69nifzghpbvy11fdca5cllkn852h6rg045lci4vzgqf7b2bd2";

     

       7
       7
       -
           batctl = "05rrpfbpdhxn5zgdps849qls2ifis6a94cjryb60d4y1nc2n0d7w";

     

       5
       5
       +
           batman-adv = "1898y0m8sgca0dmhyfkpmx2g6qc0b1xvh5nm7cvnhwl9h2jrp62s";

     

       6
       6
       +
           alfred = "0jr4wbz81ijd03ssfxb9mqlj3zbx2k495lsl0np262hyla6w0qm0";

     

       7
       7
       +
           batctl = "1r01a8zxivq4slwc81dgg9qknqsli8qw17csfj95321gjpqqpv4w";

     

       8
       8
        
         };

     

       9
       9
        
       }

+3 -3

pkgs/servers/monitoring/telegraf/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "telegraf";

     

       5
       5
       -
         version = "1.17.0";

     

       5
       5
       +
         version = "1.17.2";

     

       6
       6
        
       

     

       7
       7
        
         excludedPackages = "test";

     

       8
       8
        
       

     
···

       12
       12
        
           owner = "influxdata";

     

       13
       13
        
           repo = "telegraf";

     

       14
       14
        
           rev = "v${version}";

     

       15
       15
       -
           sha256 = "1j3wi398vcvlnf1q335hhbw6bq69qclak92sg2na05cl4snw68y0";

     

       15
       15
       +
           sha256 = "sha256-R0RYiVVS1ce2xabPBTEmOxBNlknP4iXkbVy412whrFw=";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
       -
         vendorSha256 = "0vb1gvmj7pmz4dljyk91smkn8japmv7mc3mgb0s1imvxala8qq83";

     

       18
       18
       +
         vendorSha256 = "sha256-3cELah9i2rY563QQOYt7ke0HEUR1By74vTgl+UbOHwc=";

     

       19
       19
        
       

     

       20
       20
        
         buildFlagsArray = [ ''-ldflags=

     

       21
       21
        
           -w -s -X main.version=${version}

+2 -2

pkgs/tools/security/ccid/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "ccid";

     

       5
       5
       -
         version = "1.4.33";

     

       5
       5
       +
         version = "1.4.34";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "https://ccid.apdu.fr/files/${pname}-${version}.tar.bz2";

     

       9
       9
       -
           sha256 = "0974h2v9wq0j0ajw3c7yckaw8wqcppb2npfhfhmv9phijy9xlmjj";

     

       9
       9
       +
           sha256 = "sha256-5vdkW1mpooROtLGn7/USlg1/BKRlSvAvf9L4re1dtAo=";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         postPatch = ''

+6 -2

pkgs/top-level/all-packages.nix

···

       5954
       5954
        
         inherit (callPackages ../development/libraries/libwebsockets { })

     

       5955
       5955
        
           libwebsockets_3_1

     

       5956
       5956
        
           libwebsockets_3_2

     

       5957
       5957
       -
           libwebsockets_4_0;

     

       5957
       5957
       +
           libwebsockets_4_0

     

       5958
       5958
       +
           libwebsockets_4_1;

     

       5958
       5959
        
         libwebsockets = libwebsockets_3_2;

     

       5959
       5960
        
       

     

       5960
       5961
        
         licensee = callPackage ../tools/package-management/licensee { };

     
···

       9562
       9563
        
           crystal_0_33

     

       9563
       9564
        
           crystal_0_34

     

       9564
       9565
        
           crystal_0_35

     

       9566
       9566
       +
           crystal_0_36

     

       9565
       9567
        
           crystal;

     

       9566
       9568
        
       

     

       9567
       9569
        
         crystal2nix = callPackage ../development/compilers/crystal2nix { };

     
···

       13336
       13338
        
       

     

       13337
       13339
        
         cxx-prettyprint = callPackage ../development/libraries/cxx-prettyprint { };

     

       13338
       13340
        
       

     

       13341
       13341
       +
         cxxopts = callPackage ../development/libraries/cxxopts { };

     

       13342
       13342
       +
       

     

       13339
       13343
        
         cxxtest = python2Packages.callPackage ../development/libraries/cxxtest { };

     

       13340
       13344
        
       

     

       13341
       13345
        
         cypress = callPackage ../development/web/cypress { };

     
···

       13689
       13693
        
       

     

       13690
       13694
        
         gdal_1_11 = callPackage ../development/libraries/gdal/gdal-1_11.nix { };

     

       13691
       13695
        
       

     

       13692
       13692
       -
         gdal_2 = callPackage ../development/libraries/gdal/2.4.0.nix { };

     

       13696
       13696
       +
         gdal_2 = callPackage ../development/libraries/gdal/2.4.nix { };

     

       13693
       13697
        
       

     

       13694
       13698
        
         gdcm = callPackage ../development/libraries/gdcm { };

     

       13695
       13699

+1 -4

pkgs/top-level/ocaml-packages.nix

···

       979
       979
        
       

     

       980
       980
        
           ppx_derivers = callPackage ../development/ocaml-modules/ppx_derivers {};

     

       981
       981
        
       

     

       982
       982
       -
           ppx_deriving =

     

       983
       983
       -
             if lib.versionAtLeast ocaml.version "4.02"

     

       984
       984
       -
             then callPackage ../development/ocaml-modules/ppx_deriving {}

     

       985
       985
       -
             else null;

     

       982
       982
       +
           ppx_deriving = callPackage ../development/ocaml-modules/ppx_deriving {};

     

       986
       983
        
       

     

       987
       984
        
           ppx_deriving_protobuf = callPackage ../development/ocaml-modules/ppx_deriving_protobuf {};

     

       988
       985

+1 -1

pkgs/top-level/perl-packages.nix

···

       12220
       12220
        
              url = "mirror://cpan/authors/id/P/PJ/PJACKLAM/Math-BigInt-Lite-0.19.tar.gz";

     

       12221
       12221
        
              sha256 = "06hm4vgihxr7m4jrq558phnnxy4am6ifba447j0h4p6jym5h7xih";

     

       12222
       12222
        
            };

     

       12223
       12223
       -
       

     

       12223
       12223
       +
            propagatedBuildInputs = [ MathBigInt ];

     

       12224
       12224
        
            meta = {

     

       12225
       12225
        
              license = with lib.licenses; [ artistic1 gpl1Plus ];

     

       12226
       12226
        
            };

+6

pkgs/top-level/python-packages.nix

···

       3102
       3102
        
       

     

       3103
       3103
        
         imaplib2 = callPackage ../development/python-modules/imaplib2 { };

     

       3104
       3104
        
       

     

       3105
       3105
       +
         imap-tools = callPackage ../development/python-modules/imap-tools { };

     

       3106
       3106
       +
       

     

       3105
       3107
        
         imbalanced-learn = if isPy27 then

     

       3106
       3108
        
           callPackage ../development/python-modules/imbalanced-learn/0.4.nix { }

     

       3107
       3109
        
         else

     
···

       4432
       4434
        
         nototools = callPackage ../data/fonts/noto-fonts/tools.nix { };

     

       4433
       4435
        
       

     

       4434
       4436
        
         nplusone = callPackage ../development/python-modules/nplusone { };

     

       4437
       4437
       +
       

     

       4438
       4438
       +
         npyscreen = callPackage ../development/python-modules/npyscreen { };

     

       4435
       4439
        
       

     

       4436
       4440
        
         ntc-templates = callPackage ../development/python-modules/ntc-templates { };

     

       4437
       4441
        
       

     
···

       7340
       7344
        
           callPackage ../development/python-modules/sphinx/2.nix { };

     

       7341
       7345
        
       

     

       7342
       7346
        
         sphinx-argparse = callPackage ../development/python-modules/sphinx-argparse { };

     

       7347
       7347
       +
       

     

       7348
       7348
       +
         sphinx-autobuild = callPackage ../development/python-modules/sphinx-argparse { };

     

       7343
       7349
        
       

     

       7344
       7350
        
         sphinx-jinja = callPackage ../development/python-modules/sphinx-jinja { };

     

       7345
       7351