commit bec27fabee7ff51a4788840479b1730ed1b64427 · pyrox.dev/nixpkgs

+1 -1

nixos/lib/eval-config.nix

···

       31
       31
        
       , prefix ? []

     

       32
       32
        
       , lib ? import ../../lib

     

       33
       33
        
       , extraModules ? let e = builtins.getEnv "NIXOS_EXTRA_MODULE_PATH";

     

       34
       34
       -
                        in if e == "" then [] else [(import e)]

     

       34
       34
       +
                        in lib.optional (e != "") (import e)

     

       35
       35
        
       }:

     

       36
       36
        
       

     

       37
       37
        
       let pkgs_ = pkgs;

+1 -3

nixos/modules/installer/netboot/netboot.nix

···

       39
       39
        
       

     

       40
       40
        
           # !!! Hack - attributes expected by other modules.

     

       41
       41
        
           environment.systemPackages = [ pkgs.grub2_efi ]

     

       42
       42
       -
             ++ (if pkgs.stdenv.hostPlatform.system == "aarch64-linux"

     

       43
       43
       -
                 then []

     

       44
       44
       -
                 else [ pkgs.grub2 pkgs.syslinux ]);

     

       42
       42
       +
             ++ (lib.optionals (pkgs.stdenv.hostPlatform.system != "aarch64-linux") [pkgs.grub2 pkgs.syslinux]);

     

       45
       43
        
       

     

       46
       44
        
           fileSystems."/" = mkImageMediaOverride

     

       47
       45
        
             { fsType = "tmpfs";

+1 -1

nixos/modules/services/misc/zoneminder.nix

···

       351
       351
        
                 CacheDirectory = dirs cacheDirs;

     

       352
       352
        
                 RuntimeDirectory = dirName;

     

       353
       353
        
                 ReadWriteDirectories = lib.mkIf useCustomDir [ cfg.storageDir ];

     

       354
       354
       -
                 StateDirectory = dirs (if useCustomDir then [] else libDirs);

     

       354
       354
       +
                 StateDirectory = dirs (lib.optional (!useCustomDir) libDirs);

     

       355
       355
        
                 LogsDirectory = dirName;

     

       356
       356
        
                 PrivateTmp = true;

     

       357
       357
        
                 ProtectSystem = "strict";

+2 -2

nixos/modules/services/search/kibana.nix

···

       130
       130
        
       

     

       131
       131
        
                 This defaults to the singleton list [ca] when the {option}`ca` option is defined.

     

       132
       132
        
               '';

     

       133
       133
       -
               default = if cfg.elasticsearch.ca == null then [] else [ca];

     

       133
       133
       +
               default = lib.optional (cfg.elasticsearch.ca != null) ca;

     

       134
       134
        
               defaultText = literalExpression ''

     

       135
       135
       -
                 if config.${opt.elasticsearch.ca} == null then [ ] else [ ca ]

     

       135
       135
       +
                 lib.optional (config.${opt.elasticsearch.ca} != null) ca

     

       136
       136
        
               '';

     

       137
       137
        
               type = types.listOf types.path;

     

       138
       138
        
             };

+1 -1

nixos/modules/services/security/kanidm.nix

···

       17
       17
        
             # If the new path is a prefix to some existing path, we need to filter it out

     

       18
       18
        
             filteredPaths = lib.filter (p: !lib.hasPrefix (builtins.toString newPath) (builtins.toString p)) merged;

     

       19
       19
        
             # If a prefix of the new path is already in the list, do not add it

     

       20
       20
       -
             filteredNew = if hasPrefixInList filteredPaths newPath then [] else [ newPath ];

     

       20
       20
       +
             filteredNew = lib.optional (!hasPrefixInList filteredPaths newPath) newPath;

     

       21
       21
        
           in filteredPaths ++ filteredNew) [];

     

       22
       22
        
       

     

       23
       23
        
         defaultServiceConfig = {

+2 -2

nixos/modules/services/web-apps/restya-board.nix

···

       263
       263
        
             serviceConfig.RemainAfterExit = true;

     

       264
       264
        
       

     

       265
       265
        
             wantedBy = [ "multi-user.target" ];

     

       266
       266
       -
             requires = if cfg.database.host == null then [] else [ "postgresql.service" ];

     

       267
       267
       -
             after = [ "network.target" ] ++ (if cfg.database.host == null then [] else [ "postgresql.service" ]);

     

       266
       266
       +
             requires = lib.optional (cfg.database.host != null) "postgresql.service";

     

       267
       267
       +
             after = [ "network.target" ] ++ (lib.optional (cfg.database.host != null) "postgresql.service");

     

       268
       268
        
       

     

       269
       269
        
             script = ''

     

       270
       270
        
               rm -rf "${runDir}"

+1 -1

nixos/tests/common/resolver.nix

···

       63
       63
        
                   matched = builtins.match "[ \t]+(${reHost})(.*)" str;

     

       64
       64
        
                   continue = lib.singleton (lib.head matched)

     

       65
       65
        
                           ++ matchAliases (lib.last matched);

     

       66
       66
       -
                 in if matched == null then [] else continue;

     

       66
       66
       +
                 in lib.optional (matched != null) continue;

     

       67
       67
        
       

     

       68
       68
        
                 matchLine = str: let

     

       69
       69
        
                   result = builtins.match "[ \t]*(${reIp})[ \t]+(${reHost})(.*)" str;

+1 -1

pkgs/build-support/nix-gitignore/default.nix

···

       45
       45
        
                 escs = "\\*?";

     

       46
       46
        
                 splitString =

     

       47
       47
        
                   let recurse = str : [(substring 0 1 str)] ++

     

       48
       48
       -
                                        (if str == "" then [] else (recurse (substring 1 (stringLength(str)) str) ));

     

       48
       48
       +
                                        (lib.optionals (str != "") (recurse (substring 1 (stringLength(str)) str) ));

     

       49
       49
        
                   in str : recurse str;

     

       50
       50
        
                 chars = s: filter (c: c != "" && !isList c) (splitString s);

     

       51
       51
        
                 escape = s: map (c: "\\" + c) (chars s);

+1 -2

pkgs/development/coq-modules/mathcomp-analysis/default.nix

···

       40
       40
        
         mathcomp_ = package: let

     

       41
       41
        
             classical-deps = [ mathcomp.algebra mathcomp-finmap ];

     

       42
       42
        
             analysis-deps = [ mathcomp.field mathcomp-bigenough ];

     

       43
       43
       -
             intra-deps = if package == "single" then []

     

       44
       44
       -
               else map mathcomp_ (head (splitList (lib.pred.equal package) packages));

     

       43
       43
       +
             intra-deps = lib.optionals (package != "single") (map mathcomp_ (head (splitList (lib.pred.equal package) packages)));

     

       45
       44
        
             pkgpath = if package == "single" then "."

     

       46
       45
        
               else if package == "analysis" then "theories" else "${package}";

     

       47
       46
        
             pname = if package == "single" then "mathcomp-analysis-single"

+1 -2

pkgs/development/coq-modules/mathcomp/default.nix

···

       55
       55
        
         packages = [ "ssreflect" "fingroup" "algebra" "solvable" "field" "character" "all" ];

     

       56
       56
        
       

     

       57
       57
        
         mathcomp_ = package: let

     

       58
       58
       -
             mathcomp-deps = if package == "single" then []

     

       59
       59
       -
               else map mathcomp_ (head (splitList (lib.pred.equal package) packages));

     

       58
       58
       +
             mathcomp-deps = lib.optionals (package != "single") (map mathcomp_ (head (splitList (lib.pred.equal package) packages)));

     

       60
       59
        
             pkgpath = if package == "single" then "mathcomp" else "mathcomp/${package}";

     

       61
       60
        
             pname = if package == "single" then "mathcomp" else "mathcomp-${package}";

     

       62
       61
        
             pkgallMake = ''

+1 -2

pkgs/development/coq-modules/metacoq/default.nix

···

       33
       33
        
         template-coq = metacoq_ "template-coq";

     

       34
       34
        
       

     

       35
       35
        
         metacoq_ = package: let

     

       36
       36
       -
             metacoq-deps = if package == "single" then []

     

       37
       37
       -
               else map metacoq_ (head (splitList (lib.pred.equal package) packages));

     

       36
       36
       +
             metacoq-deps = lib.optionals (package != "single") (map metacoq_ (head (splitList (lib.pred.equal package) packages)));

     

       38
       37
        
             pkgpath = if package == "single" then "./" else "./${package}";

     

       39
       38
        
             pname = if package == "all" then "metacoq" else "metacoq-${package}";

     

       40
       39
        
             pkgallMake = ''

+1 -1

pkgs/development/libraries/protobuf/generic-v3.nix

···

       33
       33
        
         nativeBuildInputs = [ autoreconfHook buildPackages.which buildPackages.stdenv.cc buildProtobuf ];

     

       34
       34
        
       

     

       35
       35
        
         buildInputs = [ zlib ];

     

       36
       36
       -
         configureFlags = if buildProtobuf == null then [] else [ "--with-protoc=${buildProtobuf}/bin/protoc" ];

     

       36
       36
       +
         configureFlags = lib.optional (buildProtobuf != null) "--with-protoc=${buildProtobuf}/bin/protoc";

     

       37
       37
        
       

     

       38
       38
        
         enableParallelBuilding = true;

     

       39
       39

+1 -1

pkgs/tools/system/netdata/default.nix

···

       65
       65
        
         # to bootstrap tools:

     

       66
       66
        
         #   https://github.com/NixOS/nixpkgs/pull/175719

     

       67
       67
        
         # We pick zlib.dev as a simple canary package with pkg-config input.

     

       68
       68
       -
         disallowedReferences = if withDebug then [] else [ zlib.dev ];

     

       68
       68
       +
         disallowedReferences = lib.optional (!withDebug) zlib.dev;

     

       69
       69
        
       

     

       70
       70
        
         donStrip = withDebug;

     

       71
       71
        
         env.NIX_CFLAGS_COMPILE = lib.optionalString withDebug "-O1 -ggdb -DNETDATA_INTERNAL_CHECKS=1";