commit 86a29d0a96151995e28983edabd50b669309c37d · pyrox.dev/nixpkgs

+65 -4

ci/eval/compare/default.nix

···

       3
       3
        
         jq,

     

       4
       4
        
         runCommand,

     

       5
       5
        
         writeText,

     

       6
       6
       -
         supportedSystems,

     

       7
       6
        
         ...

     

       8
       7
        
       }:

     

       9
       8
        
       { beforeResultDir, afterResultDir }:

     

       10
       9
        
       let

     

       10
       10
       +
         /*

     

       11
       11
       +
           Derivation that computes which packages are affected (added, changed or removed) between two revisions of nixpkgs.

     

       12
       12
       +
           Note: "platforms" are "x86_64-linux", "aarch64-darwin", ...

     

       13
       13
       +
       

     

       14
       14
       +
           ---

     

       15
       15
       +
           Inputs:

     

       16
       16
       +
           - beforeResultDir, afterResultDir: The evaluation result from before and after the change.

     

       17
       17
       +
             They can be obtained by running `nix-build -A ci.eval.full` on both revisions.

     

       18
       18
       +
       

     

       19
       19
       +
           ---

     

       20
       20
       +
           Outputs:

     

       21
       21
       +
             - changed-paths.json: Various information about the changes:

     

       22
       22
       +
               {

     

       23
       23
       +
                 attrdiff: {

     

       24
       24
       +
                   added: ["package1"],

     

       25
       25
       +
                   changed: ["package2", "package3"],

     

       26
       26
       +
                   removed: ["package4"],

     

       27
       27
       +
                 },

     

       28
       28
       +
                 labels: [

     

       29
       29
       +
                   "10.rebuild-darwin: 1-10",

     

       30
       30
       +
                   "10.rebuild-linux: 1-10"

     

       31
       31
       +
                 ],

     

       32
       32
       +
                 rebuildsByKernel: {

     

       33
       33
       +
                   darwin: ["package1", "package2"],

     

       34
       34
       +
                   linux: ["package1", "package2", "package3"]

     

       35
       35
       +
                 },

     

       36
       36
       +
                 rebuildCountByKernel: {

     

       37
       37
       +
                   darwin: 2,

     

       38
       38
       +
                   linux: 3,

     

       39
       39
       +
                 },

     

       40
       40
       +
                 rebuildsByPlatform: {

     

       41
       41
       +
                   aarch64-darwin: ["package1", "package2"],

     

       42
       42
       +
                   aarch64-linux: ["package1", "package2"],

     

       43
       43
       +
                   x86_64-linux: ["package1", "package2", "package3"],

     

       44
       44
       +
                   x86_64-darwin: ["package1"],

     

       45
       45
       +
                 },

     

       46
       46
       +
               }

     

       47
       47
       +
             - step-summary.md: A markdown render of the changes

     

       48
       48
       +
       

     

       49
       49
       +
           ---

     

       50
       50
       +
           Implementation details:

     

       51
       51
       +
       

     

       52
       52
       +
           Helper functions can be found in ./utils.nix.

     

       53
       53
       +
           Two main "types" are important:

     

       54
       54
       +
       

     

       55
       55
       +
           - `packagePlatformPath`: A string of the form "<PACKAGE_PATH>.<PLATFORM>"

     

       56
       56
       +
             Example: "python312Packages.numpy.x86_64-linux"

     

       57
       57
       +
       

     

       58
       58
       +
           - `packagePlatformAttr`: An attrs representation of a packagePlatformPath:

     

       59
       59
       +
             Example: { name = "python312Packages.numpy"; platform = "x86_64-linux"; }

     

       60
       60
       +
         */

     

       11
       61
        
         inherit (import ./utils.nix { inherit lib; })

     

       12
       62
        
           diff

     

       13
       63
        
           groupByKernel

     

       64
       64
       +
           convertToPackagePlatformAttrs

     

       65
       65
       +
           groupByPlatform

     

       14
       66
        
           extractPackageNames

     

       15
       67
        
           getLabels

     

       16
       68
        
           uniqueStrings

     
···

       20
       72
        
         beforeAttrs = getAttrs beforeResultDir;

     

       21
       73
        
         afterAttrs = getAttrs afterResultDir;

     

       22
       74
        
       

     

       75
       75
       +
         # Attrs

     

       76
       76
       +
         # - keys: "added", "changed" and "removed"

     

       77
       77
       +
         # - values: lists of `packagePlatformPath`s

     

       23
       78
        
         diffAttrs = diff beforeAttrs afterAttrs;

     

       24
       79
        
       

     

       25
       80
        
         changed-paths =

     

       26
       81
        
           let

     

       27
       82
        
             rebuilds = uniqueStrings (diffAttrs.added ++ diffAttrs.changed);

     

       83
       83
       +
             rebuildsPackagePlatformAttrs = convertToPackagePlatformAttrs rebuilds;

     

       28
       84
        
       

     

       29
       29
       -
             rebuildsByKernel = groupByKernel rebuilds;

     

       85
       85
       +
             rebuildsByPlatform = groupByPlatform rebuildsPackagePlatformAttrs;

     

       86
       86
       +
             rebuildsByKernel = groupByKernel rebuildsPackagePlatformAttrs;

     

       30
       87
        
             rebuildCountByKernel = lib.mapAttrs (

     

       31
       88
        
               kernel: kernelRebuilds: lib.length kernelRebuilds

     

       32
       89
        
             ) rebuildsByKernel;

     

       33
       90
        
           in

     

       34
       91
        
           writeText "changed-paths.json" (

     

       35
       92
        
             builtins.toJSON {

     

       36
       36
       -
               attrdiff = lib.mapAttrs (_: v: extractPackageNames v) diffAttrs;

     

       37
       37
       -
               inherit rebuildsByKernel rebuildCountByKernel;

     

       93
       93
       +
               attrdiff = lib.mapAttrs (_: extractPackageNames) diffAttrs;

     

       94
       94
       +
               inherit

     

       95
       95
       +
                 rebuildsByPlatform

     

       96
       96
       +
                 rebuildsByKernel

     

       97
       97
       +
                 rebuildCountByKernel

     

       98
       98
       +
                 ;

     

       38
       99
        
               labels = getLabels rebuildCountByKernel;

     

       39
       100
        
             }

     

       40
       101
        
           );

+141 -60

ci/eval/compare/utils.nix

···

       3
       3
        
         # Borrowed from https://github.com/NixOS/nixpkgs/pull/355616

     

       4
       4
        
         uniqueStrings = list: builtins.attrNames (builtins.groupBy lib.id list);

     

       5
       5
        
       

     

       6
       6
       -
         _processSystemPath =

     

       7
       7
       -
           packageSystemPath:

     

       6
       6
       +
         /*

     

       7
       7
       +
           Converts a `packagePlatformPath` into a `packagePlatformAttr`

     

       8
       8
       +
       

     

       9
       9
       +
           Turns

     

       10
       10
       +
             "hello.aarch64-linux"

     

       11
       11
       +
           into

     

       12
       12
       +
             {

     

       13
       13
       +
               name = "hello";

     

       14
       14
       +
               platform = "aarch64-linux";

     

       15
       15
       +
             }

     

       16
       16
       +
         */

     

       17
       17
       +
         convertToPackagePlatformAttr =

     

       18
       18
       +
           packagePlatformPath:

     

       8
       19
        
           let

     

       9
       9
       -
             # python312Packages.torch.aarch64-linux -> ["python312Packages" "torch" "aarch64-linux"]

     

       10
       10
       -
             # splittedPath = lib.splitString "." attrName;

     

       11
       11
       -
             splittedPath = lib.splitString "." packageSystemPath;

     

       20
       20
       +
             # python312Packages.numpy.aarch64-linux -> ["python312Packages" "numpy" "aarch64-linux"]

     

       21
       21
       +
             splittedPath = lib.splitString "." packagePlatformPath;

     

       12
       22
        
       

     

       13
       13
       -
             # ["python312Packages" "torch" "aarch64-linux"] -> ["python312Packages" "torch"]

     

       23
       23
       +
             # ["python312Packages" "numpy" "aarch64-linux"] -> ["python312Packages" "numpy"]

     

       14
       24
        
             packagePath = lib.sublist 0 (lib.length splittedPath - 1) splittedPath;

     

       25
       25
       +
       

     

       26
       26
       +
             # "python312Packages.numpy"

     

       27
       27
       +
             name = lib.concatStringsSep "." packagePath;

     

       15
       28
        
           in

     

       16
       16
       -
           {

     

       17
       17
       -
             # "python312Packages.torch"

     

       18
       18
       -
             name = lib.concatStringsSep "." packagePath;

     

       29
       29
       +
           if name == "" then

     

       30
       30
       +
             null

     

       31
       31
       +
           else

     

       32
       32
       +
             {

     

       33
       33
       +
               # python312Packages.numpy

     

       34
       34
       +
               inherit name;

     

       35
       35
       +
       

     

       36
       36
       +
               # "aarch64-linux"

     

       37
       37
       +
               platform = lib.last splittedPath;

     

       38
       38
       +
             };

     

       39
       39
       +
       

     

       40
       40
       +
         /*

     

       41
       41
       +
           Converts a list of `packagePlatformPath`s into a list of `packagePlatformAttr`s

     

       42
       42
       +
       

     

       43
       43
       +
           Turns

     

       44
       44
       +
             [

     

       45
       45
       +
               "hello.aarch64-linux"

     

       46
       46
       +
               "hello.x86_64-linux"

     

       47
       47
       +
               "hello.aarch64-darwin"

     

       48
       48
       +
               "hello.x86_64-darwin"

     

       49
       49
       +
               "bye.x86_64-darwin"

     

       50
       50
       +
               "bye.aarch64-darwin"

     

       51
       51
       +
               "release-checks"  <- Will be dropped

     

       52
       52
       +
             ]

     

       53
       53
       +
           into

     

       54
       54
       +
             [

     

       55
       55
       +
               { name = "hello"; platform = "aarch64-linux"; }

     

       56
       56
       +
               { name = "hello"; platform = "x86_64-linux"; }

     

       57
       57
       +
               { name = "hello"; platform = "aarch64-darwin"; }

     

       58
       58
       +
               { name = "hello"; platform = "x86_64-darwin"; }

     

       59
       59
       +
               { name = "bye"; platform = "aarch64-darwin"; }

     

       60
       60
       +
               { name = "bye"; platform = "x86_64-darwin"; }

     

       61
       61
       +
             ]

     

       62
       62
       +
         */

     

       63
       63
       +
         convertToPackagePlatformAttrs =

     

       64
       64
       +
           packagePlatformPaths:

     

       65
       65
       +
           builtins.filter (x: x != null) (builtins.map convertToPackagePlatformAttr packagePlatformPaths);

     

       19
       66
        
       

     

       20
       20
       -
             # "aarch64-linux"

     

       21
       21
       -
             system = lib.last splittedPath;

     

       22
       22
       -
           };

     

       67
       67
       +
         /*

     

       68
       68
       +
           Converts a list of `packagePlatformPath`s directly to a list of (unique) package names

     

       23
       69
        
       

     

       24
       24
       -
         # Turns

     

       25
       25
       -
         # [

     

       26
       26
       -
         #   "hello.aarch64-linux"

     

       27
       27
       -
         #   "hello.x86_64-linux"

     

       28
       28
       -
         #   "hello.aarch64-darwin"

     

       29
       29
       -
         #   "hello.x86_64-darwin"

     

       30
       30
       -
         #   "bye.x86_64-darwin"

     

       31
       31
       -
         #   "bye.aarch64-darwin"

     

       32
       32
       -
         # ]

     

       33
       33
       -
         #

     

       34
       34
       -
         # into

     

       35
       35
       -
         #

     

       36
       36
       -
         # [

     

       37
       37
       -
         #   "hello"

     

       38
       38
       -
         #   "bye"

     

       39
       39
       -
         # ]

     

       70
       70
       +
           Turns

     

       71
       71
       +
             [

     

       72
       72
       +
               "hello.aarch64-linux"

     

       73
       73
       +
               "hello.x86_64-linux"

     

       74
       74
       +
               "hello.aarch64-darwin"

     

       75
       75
       +
               "hello.x86_64-darwin"

     

       76
       76
       +
               "bye.x86_64-darwin"

     

       77
       77
       +
               "bye.aarch64-darwin"

     

       78
       78
       +
             ]

     

       79
       79
       +
           into

     

       80
       80
       +
             [

     

       81
       81
       +
               "hello"

     

       82
       82
       +
               "bye"

     

       83
       83
       +
             ]

     

       84
       84
       +
         */

     

       40
       85
        
         extractPackageNames =

     

       41
       41
       -
           packageSystemPaths:

     

       42
       42
       -
           builtins.attrNames (

     

       43
       43
       -
             builtins.removeAttrs (builtins.groupBy (

     

       44
       44
       -
               packageSystemPath: (_processSystemPath packageSystemPath).name

     

       45
       45
       -
             ) packageSystemPaths) [ "" ]

     

       46
       46
       -
           );

     

       86
       86
       +
           packagePlatformPaths:

     

       87
       87
       +
           let

     

       88
       88
       +
             packagePlatformAttrs = convertToPackagePlatformAttrs (uniqueStrings packagePlatformPaths);

     

       89
       89
       +
           in

     

       90
       90
       +
           uniqueStrings (builtins.map (p: p.name) packagePlatformAttrs);

     

       91
       91
       +
       

     

       92
       92
       +
         /*

     

       93
       93
       +
           Computes the key difference between two attrs

     

       47
       94
        
       

     

       48
       48
       -
         # Computes a diff between two attrs

     

       49
       49
       -
         # {

     

       50
       50
       -
         #   added: [ <keys only in the second object> ],

     

       51
       51
       -
         #   removed: [ <keys only in the first object> ],

     

       52
       52
       -
         #   changed: [ <keys with different values between the two objects> ],

     

       53
       53
       -
         # }

     

       54
       54
       -
         #

     

       95
       95
       +
           {

     

       96
       96
       +
             added: [ <keys only in the second object> ],

     

       97
       97
       +
             removed: [ <keys only in the first object> ],

     

       98
       98
       +
             changed: [ <keys with different values between the two objects> ],

     

       99
       99
       +
           }

     

       100
       100
       +
         */

     

       55
       101
        
         diff =

     

       56
       102
        
           let

     

       57
       103
        
             filterKeys = cond: attrs: lib.attrNames (lib.filterAttrs cond attrs);

     
···

       69
       115
        
             ) old;

     

       70
       116
        
           };

     

       71
       117
        
       

     

       118
       118
       +
         /*

     

       119
       119
       +
           Group a list of `packagePlatformAttr`s by platforms

     

       120
       120
       +
       

     

       121
       121
       +
           Turns

     

       122
       122
       +
             [

     

       123
       123
       +
               { name = "hello"; platform = "aarch64-linux"; }

     

       124
       124
       +
               { name = "hello"; platform = "x86_64-linux"; }

     

       125
       125
       +
               { name = "hello"; platform = "aarch64-darwin"; }

     

       126
       126
       +
               { name = "hello"; platform = "x86_64-darwin"; }

     

       127
       127
       +
               { name = "bye"; platform = "aarch64-darwin"; }

     

       128
       128
       +
               { name = "bye"; platform = "x86_64-darwin"; }

     

       129
       129
       +
             ]

     

       130
       130
       +
           into

     

       131
       131
       +
             {

     

       132
       132
       +
               aarch64-linux = [ "hello" ];

     

       133
       133
       +
               x86_64-linux = [ "hello" ];

     

       134
       134
       +
               aarch64-darwin = [ "hello" "bye" ];

     

       135
       135
       +
               x86_64-darwin = [ "hello" "bye" ];

     

       136
       136
       +
             }

     

       137
       137
       +
         */

     

       138
       138
       +
         groupByPlatform =

     

       139
       139
       +
           packagePlatformAttrs:

     

       140
       140
       +
           let

     

       141
       141
       +
             packagePlatformAttrsByPlatform = builtins.groupBy (p: p.platform) packagePlatformAttrs;

     

       142
       142
       +
             extractPackageNames = map (p: p.name);

     

       143
       143
       +
           in

     

       144
       144
       +
           lib.mapAttrs (_: extractPackageNames) packagePlatformAttrsByPlatform;

     

       145
       145
       +
       

     

       72
       146
        
         # Turns

     

       73
       147
        
         # [

     

       74
       74
       -
         #   "hello.aarch64-linux"

     

       75
       75
       -
         #   "hello.x86_64-linux"

     

       76
       76
       -
         #   "hello.aarch64-darwin"

     

       77
       77
       -
         #   "hello.x86_64-darwin"

     

       78
       78
       -
         #   "bye.x86_64-darwin"

     

       79
       79
       -
         #   "bye.aarch64-darwin"

     

       148
       148
       +
         #   { name = "hello"; platform = "aarch64-linux"; }

     

       149
       149
       +
         #   { name = "hello"; platform = "x86_64-linux"; }

     

       150
       150
       +
         #   { name = "hello"; platform = "aarch64-darwin"; }

     

       151
       151
       +
         #   { name = "hello"; platform = "x86_64-darwin"; }

     

       152
       152
       +
         #   { name = "bye"; platform = "aarch64-darwin"; }

     

       153
       153
       +
         #   { name = "bye"; platform = "x86_64-darwin"; }

     

       80
       154
        
         # ]

     

       81
       155
        
         #

     

       82
       156
        
         # into

     

       83
       157
        
         #

     

       84
       158
        
         # {

     

       85
       85
       -
         #   linux = [

     

       86
       86
       -
         #     "hello"

     

       87
       87
       -
         #   ];

     

       88
       88
       -
         #   darwin = [

     

       89
       89
       -
         #     "hello"

     

       90
       90
       -
         #     "bye"

     

       91
       91
       -
         #   ];

     

       159
       159
       +
         #   linux = [ "hello" ];

     

       160
       160
       +
         #   darwin = [ "hello" "bye" ];

     

       92
       161
        
         # }

     

       93
       162
        
         groupByKernel =

     

       94
       94
       -
           systemPaths:

     

       163
       163
       +
           packagePlatformAttrs:

     

       95
       164
        
           let

     

       96
       96
       -
             systemPaths' = builtins.map _processSystemPath systemPaths;

     

       97
       97
       -
       

     

       98
       165
        
             filterKernel =

     

       99
       166
        
               kernel:

     

       100
       167
        
               builtins.attrNames (

     

       101
       101
       -
                 builtins.groupBy (systemPath: systemPath.name) (

     

       102
       102
       -
                   builtins.filter (systemPath: lib.hasSuffix kernel systemPath.system) systemPaths'

     

       168
       168
       +
                 builtins.groupBy (p: p.name) (

     

       169
       169
       +
                   builtins.filter (p: lib.hasSuffix kernel p.platform) packagePlatformAttrs

     

       103
       170
        
                 )

     

       104
       171
        
               );

     

       105
       172
        
           in

     

       106
       173
        
           lib.genAttrs [ "linux" "darwin" ] filterKernel;

     

       107
       174
        
       

     

       108
       108
       -
         getLabels = lib.mapAttrs (

     

       175
       175
       +
         /*

     

       176
       176
       +
           Maps an attrs of `kernel - rebuild counts` mappings to a list of labels

     

       177
       177
       +
       

     

       178
       178
       +
           Turns

     

       179
       179
       +
             {

     

       180
       180
       +
               linux = 56;

     

       181
       181
       +
               darwin = 8;

     

       182
       182
       +
             }

     

       183
       183
       +
           into

     

       184
       184
       +
             [

     

       185
       185
       +
               "10.rebuild-darwin: 1-10"

     

       186
       186
       +
               "10.rebuild-linux: 11-100"

     

       187
       187
       +
             ]

     

       188
       188
       +
         */

     

       189
       189
       +
         getLabels = lib.mapAttrsToList (

     

       109
       190
        
           kernel: rebuildCount:

     

       110
       191
        
           let

     

       111
       192
        
             number =

+2 -2

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

···

       348
       348
        
                   index = "index.php";

     

       349
       349
        
                   tryFiles = "$uri $uri/ /index.php?$query_string";

     

       350
       350
        
                 };

     

       351
       351
       -
                 "~ \.php$".extraConfig = ''

     

       351
       351
       +
                 "~ \\.php$".extraConfig = ''

     

       352
       352
        
                   fastcgi_pass unix:${config.services.phpfpm.pools."bookstack".socket};

     

       353
       353
        
                 '';

     

       354
       354
       -
                 "~ \.(js|css|gif|png|ico|jpg|jpeg)$" = {

     

       354
       354
       +
                 "~ \\.(js|css|gif|png|ico|jpg|jpeg)$" = {

     

       355
       355
        
                   extraConfig = "expires 365d;";

     

       356
       356
        
                 };

     

       357
       357
        
               };

+16

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

···

       37
       37
        
           RestrictNamespaces = true;

     

       38
       38
        
           RestrictRealtime = true;

     

       39
       39
        
           RestrictSUIDSGID = true;

     

       40
       40
       +
           UMask = "0077";

     

       40
       41
        
         };

     

       41
       42
        
         inherit (lib)

     

       42
       43
        
           types

     
···

       350
       351
        
               CacheDirectory = "immich";

     

       351
       352
        
               User = cfg.user;

     

       352
       353
        
               Group = cfg.group;

     

       354
       354
       +
             };

     

       355
       355
       +
           };

     

       356
       356
       +
       

     

       357
       357
       +
           systemd.tmpfiles.settings = {

     

       358
       358
       +
             immich = {

     

       359
       359
       +
               # Redundant to the `UMask` service config setting on new installs, but installs made in

     

       360
       360
       +
               # early 24.11 created world-readable media storage by default, which is a privacy risk. This

     

       361
       361
       +
               # fixes those installs.

     

       362
       362
       +
               "${cfg.mediaLocation}" = {

     

       363
       363
       +
                 e = {

     

       364
       364
       +
                   user = cfg.user;

     

       365
       365
       +
                   group = cfg.group;

     

       366
       366
       +
                   mode = "0700";

     

       367
       367
       +
                 };

     

       368
       368
       +
               };

     

       353
       369
        
             };

     

       354
       370
        
           };

     

       355
       371

+13 -8

nixos/modules/system/activation/activation-script.nix

···

       110
       110
        
             default = {};

     

       111
       111
        
       

     

       112
       112
        
             example = literalExpression ''

     

       113
       113
       -
               { stdio.text =

     

       114
       114
       -
                 '''

     

       115
       115
       -
                   # Needed by some programs.

     

       116
       116
       -
                   ln -sfn /proc/self/fd /dev/fd

     

       117
       117
       -
                   ln -sfn /proc/self/fd/0 /dev/stdin

     

       118
       118
       -
                   ln -sfn /proc/self/fd/1 /dev/stdout

     

       119
       119
       -
                   ln -sfn /proc/self/fd/2 /dev/stderr

     

       120
       120
       -
                 ''';

     

       113
       113
       +
               {

     

       114
       114
       +
                 stdio = {

     

       115
       115
       +
                   # Run after /dev has been mounted

     

       116
       116
       +
                   deps = [ "specialfs" ];

     

       117
       117
       +
                   text =

     

       118
       118
       +
                     '''

     

       119
       119
       +
                       # Needed by some programs.

     

       120
       120
       +
                       ln -sfn /proc/self/fd /dev/fd

     

       121
       121
       +
                       ln -sfn /proc/self/fd/0 /dev/stdin

     

       122
       122
       +
                       ln -sfn /proc/self/fd/1 /dev/stdout

     

       123
       123
       +
                       ln -sfn /proc/self/fd/2 /dev/stderr

     

       124
       124
       +
                     ''';

     

       125
       125
       +
                 };

     

       121
       126
        
               }

     

       122
       127
        
             '';

     

       123
       128

+2 -2

pkgs/applications/blockchains/elements/default.nix

···

       25
       25
        
       

     

       26
       26
        
       stdenv.mkDerivation rec {

     

       27
       27
        
         pname = if withGui then "elements" else "elementsd";

     

       28
       28
       -
         version = "23.2.1";

     

       28
       28
       +
         version = "23.2.4";

     

       29
       29
        
       

     

       30
       30
        
         src = fetchFromGitHub {

     

       31
       31
        
           owner = "ElementsProject";

     

       32
       32
        
           repo = "elements";

     

       33
       33
        
           rev = "elements-${version}";

     

       34
       34
       -
           sha256 = "sha256-qHtSgfZGZ4Beu5fsJAOZm8ejj7wfHBbOS6WAjOrCuw4=";

     

       34
       34
       +
           sha256 = "sha256-UNjYkEZBjGuhkwBxSkNXjBBcLQqoan/afCLhoR2lOY4=";

     

       35
       35
        
         };

     

       36
       36
        
       

     

       37
       37
        
         patches = [

+1 -1

pkgs/build-support/xen/default.nix

···

       94
       94
        
           ;

     

       95
       95
        
       

     

       96
       96
        
         # Mark versions older than minSupportedVersion as EOL.

     

       97
       97
       -
         minSupportedVersion = "4.16";

     

       97
       97
       +
         minSupportedVersion = "4.17";

     

       98
       98
        
       

     

       99
       99
        
         #TODO: fix paths instead.

     

       100
       100
        
         scriptEnvPath = makeSearchPathOutput "out" "bin" [

+43

pkgs/by-name/co/codesnap/package.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         rustPlatform,

     

       4
       4
       +
         fetchFromGitHub,

     

       5
       5
       +
         versionCheckHook,

     

       6
       6
       +
         nix-update-script,

     

       7
       7
       +
       }:

     

       8
       8
       +
       rustPlatform.buildRustPackage rec {

     

       9
       9
       +
         pname = "codesnap";

     

       10
       10
       +
         version = "0.8.2";

     

       11
       11
       +
       

     

       12
       12
       +
         src = fetchFromGitHub {

     

       13
       13
       +
           owner = "mistricky";

     

       14
       14
       +
           repo = "CodeSnap";

     

       15
       15
       +
           tag = "v${version}";

     

       16
       16
       +
           hash = "sha256-/eWqJ7CyHwYCOSoQHZ6047hWbVsp30JMXfeUeNci8xM=";

     

       17
       17
       +
         };

     

       18
       18
       +
       

     

       19
       19
       +
         cargoHash = "sha256-trthuKmI7V6HQHb+uu1RjZy4+qIP1anyqPdHwzEUuLs=";

     

       20
       20
       +
       

     

       21
       21
       +
         cargoBuildFlags = [

     

       22
       22
       +
           "-p"

     

       23
       23
       +
           "codesnap-cli"

     

       24
       24
       +
         ];

     

       25
       25
       +
         cargoTestFlags = cargoBuildFlags;

     

       26
       26
       +
       

     

       27
       27
       +
         nativeInstallCheckInputs = [

     

       28
       28
       +
           versionCheckHook

     

       29
       29
       +
         ];

     

       30
       30
       +
         versionCheckProgramArg = [ "--version" ];

     

       31
       31
       +
         doInstallCheck = true;

     

       32
       32
       +
       

     

       33
       33
       +
         passthru.updateScript = nix-update-script { };

     

       34
       34
       +
       

     

       35
       35
       +
         meta = {

     

       36
       36
       +
           description = "Command-line tool for generating beautiful code snippets";

     

       37
       37
       +
           homepage = "https://github.com/mistricky/CodeSnap";

     

       38
       38
       +
           changelog = "https://github.com/mistricky/CodeSnap/releases/tag/v${version}";

     

       39
       39
       +
           license = lib.licenses.mit;

     

       40
       40
       +
           maintainers = with lib.maintainers; [ nartsiss ];

     

       41
       41
       +
           mainProgram = "codesnap";

     

       42
       42
       +
         };

     

       43
       43
       +
       }

+16 -6

pkgs/by-name/fl/flood/package.nix

···

       2
       2
        
       , buildNpmPackage

     

       3
       3
        
       , fetchFromGitHub

     

       4
       4
        
       , nixosTests

     

       5
       5
       +
       , pnpm

     

       6
       6
       +
       , nix-update-script

     

       5
       7
        
       }:

     

       6
       8
        
       

     

       7
       9
        
       buildNpmPackage rec {

     

       8
       10
        
         pname = "flood";

     

       9
       9
       -
         version = "4.8.2";

     

       11
       11
       +
         version = "4.8.5";

     

       10
       12
        
       

     

       11
       13
        
         src = fetchFromGitHub {

     

       12
       14
        
           owner = "jesec";

     

       13
       15
        
           repo = pname;

     

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

     

       15
       15
       -
           hash = "sha256-Ejr0pmWIuYByzDS+iFTECO/aymzuJrJjaaW7HikNt2w=";

     

       17
       17
       +
           hash = "sha256-lm+vPo7V99OSUAVEvdiTNMlD/+iHGPIyPLc1WzO1aTU=";

     

       16
       18
        
         };

     

       17
       19
        
       

     

       18
       18
       -
         npmDepsHash = "sha256-md76I7W5QQvfbOmk5ODssMtJAVOj8nvaJ2PakEZ8WUA=";

     

       20
       20
       +
         npmConfigHook = pnpm.configHook;

     

       21
       21
       +
         npmDeps = pnpmDeps;

     

       22
       22
       +
         pnpmDeps = pnpm.fetchDeps {

     

       23
       23
       +
           inherit pname version src;

     

       24
       24
       +
           hash = "sha256-NuU9O3bEboxmuEuk1WSUeZRNgVK5cwFiUAN3+7vACGw=";

     

       25
       25
       +
         };

     

       19
       26
        
       

     

       20
       20
       -
         passthru.tests = {

     

       21
       21
       -
           inherit (nixosTests) flood;

     

       27
       27
       +
         passthru = {

     

       28
       28
       +
           tests = {

     

       29
       29
       +
             inherit (nixosTests) flood;

     

       30
       30
       +
           };

     

       31
       31
       +
           updateScript = nix-update-script { };

     

       22
       32
        
         };

     

       23
       33
        
       

     

       24
       34
        
         meta = with lib; {

     

       25
       35
        
           description = "Modern web UI for various torrent clients with a Node.js backend and React frontend";

     

       26
       36
        
           homepage = "https://flood.js.org";

     

       27
       37
        
           license = licenses.gpl3Only;

     

       28
       28
       -
           maintainers = with maintainers; [ thiagokokada winter ];

     

       38
       38
       +
           maintainers = with maintainers; [ thiagokokada winter ners ];

     

       29
       39
        
           mainProgram = "flood";

     

       30
       40
        
         };

     

       31
       41
        
       }

+47 -21

pkgs/by-name/mo/moneydance/package.nix

···

       1
       1
       -
       { lib, stdenv, fetchzip, makeWrapper, openjdk23, jvmFlags ? [ ] }:

     

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         stdenv,

     

       4
       4
       +
         buildPackages,

     

       5
       5
       +
         fetchzip,

     

       6
       6
       +
         makeWrapper,

     

       7
       7
       +
         openjdk23,

     

       8
       8
       +
         wrapGAppsHook3,

     

       9
       9
       +
         jvmFlags ? [ ],

     

       10
       10
       +
       }:

     

       2
       11
        
       let

     

       3
       12
        
         jdk = openjdk23.override {

     

       4
       13
        
           enableJavaFX = true;

     
···

       13
       22
        
           hash = "sha256-wwSb3CuhuXB4I9jq+TpLPbd1k9UzqQbAaZkGKgi+nns=";

     

       14
       23
        
         };

     

       15
       24
        
       

     

       16
       16
       -
         nativeBuildInputs = [ makeWrapper ];

     

       25
       25
       +
         # We must use wrapGAppsHook (since Java GUIs on Linux use GTK), but by

     

       26
       26
       +
         # default that uses makeBinaryWrapper which doesn't support flags that need

     

       27
       27
       +
         # quoting: <https://github.com/NixOS/nixpkgs/issues/330471>. Thanks to

     

       28
       28
       +
         # @Artturin for the tip to override the wrapper generator.

     

       29
       29
       +
         nativeBuildInputs = [

     

       30
       30
       +
           makeWrapper

     

       31
       31
       +
           (buildPackages.wrapGAppsHook3.override { makeWrapper = buildPackages.makeShellWrapper; })

     

       32
       32
       +
         ];

     

       17
       33
        
         buildInputs = [ jdk ];

     

       34
       34
       +
         dontWrapGApps = true;

     

       35
       35
       +
       

     

       36
       36
       +
         installPhase = ''

     

       37
       37
       +
           runHook preInstall

     

       38
       38
       +
       

     

       39
       39
       +
           mkdir -p $out/libexec $out/bin

     

       40
       40
       +
           cp -p $src/lib/* $out/libexec/

     

       41
       41
       +
       

     

       42
       42
       +
           runHook postInstall

     

       43
       43
       +
         '';

     

       18
       44
        
       

     

       19
       45
        
         # Note the double escaping in the call to makeWrapper. The escapeShellArgs

     

       20
       46
        
         # call quotes each element of the flags list as a word[1] and returns a

     
···

       24
       50
        
         #

     

       25
       51
        
         # 1. https://www.gnu.org/software/bash/manual/html_node/Word-Splitting.html

     

       26
       52
        
         # 2. https://github.com/NixOS/nixpkgs/blob/master/pkgs/build-support/setup-hooks/make-wrapper.sh

     

       27
       27
       -
         installPhase = let

     

       28
       28
       -
           finalJvmFlags = [

     

       29
       29
       -
             "-client"

     

       30
       30
       -
             "--add-modules"

     

       31
       31
       -
             "javafx.swing,javafx.controls,javafx.graphics"

     

       32
       32
       -
             "-classpath"

     

       33
       33
       -
             "${placeholder "out"}/libexec/*"

     

       34
       34
       -
           ] ++ jvmFlags ++ [ "Moneydance" ];

     

       35
       35
       -
         in ''

     

       36
       36
       -
           runHook preInstall

     

       37
       37
       -
       

     

       38
       38
       -
           mkdir -p $out/libexec $out/bin

     

       39
       39
       -
           cp -p $src/lib/* $out/libexec/

     

       40
       40
       -
           makeWrapper ${jdk}/bin/java $out/bin/moneydance \

     

       41
       41
       -
             --add-flags ${lib.escapeShellArg (lib.escapeShellArgs finalJvmFlags)}

     

       42
       42
       -
       

     

       43
       43
       -
           runHook postInstall

     

       44
       44
       -
         '';

     

       53
       53
       +
         postFixup =

     

       54
       54
       +
           let

     

       55
       55
       +
             finalJvmFlags = [

     

       56
       56
       +
               "-client"

     

       57
       57
       +
               "--add-modules"

     

       58
       58
       +
               "javafx.swing,javafx.controls,javafx.graphics"

     

       59
       59
       +
               "-classpath"

     

       60
       60
       +
               "${placeholder "out"}/libexec/*"

     

       61
       61
       +
             ] ++ jvmFlags ++ [ "Moneydance" ];

     

       62
       62
       +
           in

     

       63
       63
       +
           ''

     

       64
       64
       +
             # This is in postFixup because gappsWrapperArgs is generated in preFixup

     

       65
       65
       +
             makeWrapper ${jdk}/bin/java $out/bin/moneydance \

     

       66
       66
       +
               "''${gappsWrapperArgs[@]}" \

     

       67
       67
       +
               --add-flags ${lib.escapeShellArg (lib.escapeShellArgs finalJvmFlags)}

     

       68
       68
       +
           '';

     

       45
       69
        
       

     

       46
       46
       -
         passthru = { inherit jdk; };

     

       70
       70
       +
         passthru = {

     

       71
       71
       +
           inherit jdk;

     

       72
       72
       +
         };

     

       47
       73
        
       

     

       48
       74
        
         meta = {

     

       49
       75
        
           homepage = "https://infinitekind.com/moneydance";

+3 -3

pkgs/by-name/sq/squeezelite/package.nix

···

       40
       40
        
         pname = binName;

     

       41
       41
        
         # versions are specified in `squeezelite.h`

     

       42
       42
        
         # see https://github.com/ralph-irving/squeezelite/issues/29

     

       43
       43
       -
         version = "2.0.0.1504";

     

       43
       43
       +
         version = "2.0.0.1507";

     

       44
       44
        
       

     

       45
       45
        
         src = fetchFromGitHub {

     

       46
       46
        
           owner = "ralph-irving";

     

       47
       47
        
           repo = "squeezelite";

     

       48
       48
       -
           rev = "54e39690d9882d56c56fbdced4661abce7d8beff";

     

       49
       49
       -
           hash = "sha256-+NjCykWlru8y1Iy3uLvO87NcoFvcggCaEnajXRxKYno=";

     

       48
       48
       +
           rev = "279ac086053239323f5c4df965342e3be5d10671";

     

       49
       49
       +
           hash = "sha256-iMqBQJDy1pkGNHH2aFOtzBn9VK5x+Na4iD2vc3bppTc=";

     

       50
       50
        
         };

     

       51
       51
        
       

     

       52
       52
        
         buildInputs =

+2 -2

pkgs/by-name/ya/yamlscript/package.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGraalvmNativeImage rec {

     

       4
       4
        
         pname = "yamlscript";

     

       5
       5
       -
         version = "0.1.83";

     

       5
       5
       +
         version = "0.1.86";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "https://github.com/yaml/yamlscript/releases/download/${version}/yamlscript.cli-${version}-standalone.jar";

     

       9
       9
       -
           hash = "sha256-c38jNaQSFTQA6+P2joduGe2fqSZmNiokKVf91vkJtEA=";

     

       9
       9
       +
           hash = "sha256-GFLmEowy89eZDB7cEMTHRKfvGNlZ9CTARxAKLH/GuNg=";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         executable = "ys";

+4 -4

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

···

       22
       22
        
       

     

       23
       23
        
       buildPythonPackage rec {

     

       24
       24
        
         pname = "chex";

     

       25
       25
       -
         version = "0.1.87";

     

       25
       25
       +
         version = "0.1.88";

     

       26
       26
        
         pyproject = true;

     

       27
       27
        
       

     

       28
       28
        
         src = fetchFromGitHub {

     

       29
       29
        
           owner = "deepmind";

     

       30
       30
        
           repo = "chex";

     

       31
       31
       -
           rev = "refs/tags/v${version}";

     

       32
       32
       -
           hash = "sha256-TPh7XLWHk0y/VLXxHLANUiDmfveHPeMLks9QKf16doo=";

     

       31
       31
       +
           tag = "v${version}";

     

       32
       32
       +
           hash = "sha256-umRq+FZwyx1hz839ZibRTEFKjbBugrfUJuE8PagjqI4=";

     

       33
       33
        
         };

     

       34
       34
        
       

     

       35
       35
        
         build-system = [ setuptools ];

     
···

       52
       52
        
         ];

     

       53
       53
        
       

     

       54
       54
        
         meta = {

     

       55
       55
       -
           description = "Chex is a library of utilities for helping to write reliable JAX code";

     

       55
       55
       +
           description = "Library of utilities for helping to write reliable JAX code";

     

       56
       56
        
           homepage = "https://github.com/deepmind/chex";

     

       57
       57
        
           changelog = "https://github.com/google-deepmind/chex/releases/tag/v${version}";

     

       58
       58
        
           license = lib.licenses.asl20;

+2 -2

pkgs/servers/home-assistant/custom-components/moonraker/package.nix

···

       8
       8
        
       buildHomeAssistantComponent rec {

     

       9
       9
        
         owner = "marcolivierarsenault";

     

       10
       10
        
         domain = "moonraker";

     

       11
       11
       -
         version = "1.4.0";

     

       11
       11
       +
         version = "1.5.0";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchFromGitHub {

     

       14
       14
        
           owner = "marcolivierarsenault";

     

       15
       15
        
           repo = "moonraker-home-assistant";

     

       16
       16
        
           rev = "refs/tags/${version}";

     

       17
       17
       -
           hash = "sha256-wdbomvpRvadWjxi8c6D9dhdXmWnSuVxmEPZCX8WmC5M=";

     

       17
       17
       +
           hash = "sha256-LGpCT0a6mxbf0W6ucTIBhl9aNUd5/1dUk6M+CzRKuoU=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
        
         propagatedBuildInputs = [