commit efdf618330a22f837f0e5e446028e918a5b4dd8a · pyrox.dev/nixpkgs

+44

lib/asserts.nix

···

       1
       1
       +
       { lib }:

     

       2
       2
       +
       

     

       3
       3
       +
       rec {

     

       4
       4
       +
       

     

       5
       5
       +
         /* Print a trace message if pred is false.

     

       6
       6
       +
            Intended to be used to augment asserts with helpful error messages.

     

       7
       7
       +
       

     

       8
       8
       +
            Example:

     

       9
       9
       +
              assertMsg false "nope"

     

       10
       10
       +
              => false

     

       11
       11
       +
              stderr> trace: nope

     

       12
       12
       +
       

     

       13
       13
       +
              assert (assertMsg ("foo" == "bar") "foo is not bar, silly"); ""

     

       14
       14
       +
              stderr> trace: foo is not bar, silly

     

       15
       15
       +
              stderr> assert failed at …

     

       16
       16
       +
       

     

       17
       17
       +
            Type:

     

       18
       18
       +
              assertMsg :: Bool -> String -> Bool

     

       19
       19
       +
         */

     

       20
       20
       +
         # TODO(Profpatsch): add tests that check stderr

     

       21
       21
       +
         assertMsg = pred: msg:

     

       22
       22
       +
           if pred

     

       23
       23
       +
           then true

     

       24
       24
       +
           else builtins.trace msg false;

     

       25
       25
       +
       

     

       26
       26
       +
         /* Specialized `assertMsg` for checking if val is one of the elements

     

       27
       27
       +
            of a list. Useful for checking enums.

     

       28
       28
       +
       

     

       29
       29
       +
            Example:

     

       30
       30
       +
              let sslLibrary = "libressl"

     

       31
       31
       +
              in assertOneOf "sslLibrary" sslLibrary [ "openssl" "bearssl" ]

     

       32
       32
       +
              => false

     

       33
       33
       +
              stderr> trace: sslLibrary must be one of "openssl", "bearssl", but is: "libressl"

     

       34
       34
       +
       

     

       35
       35
       +
            Type:

     

       36
       36
       +
              assertOneOf :: String -> ComparableVal -> List ComparableVal -> Bool

     

       37
       37
       +
         */

     

       38
       38
       +
         assertOneOf = name: val: xs: assertMsg

     

       39
       39
       +
           (lib.elem val xs)

     

       40
       40
       +
           "${name} must be one of ${

     

       41
       41
       +
             lib.generators.toPretty {} xs}, but is: ${

     

       42
       42
       +
               lib.generators.toPretty {} val}";

     

       43
       43
       +
       

     

       44
       44
       +
       }

+5 -4

lib/default.nix

···

       38
       38
        
           systems = callLibs ./systems;

     

       39
       39
        
       

     

       40
       40
        
           # misc

     

       41
       41
       +
           asserts = callLibs ./asserts.nix;

     

       41
       42
        
           debug = callLibs ./debug.nix;

     

       42
       42
       -
       

     

       43
       43
        
           generators = callLibs ./generators.nix;

     

       44
       44
        
           misc = callLibs ./deprecated.nix;

     

       45
       45
       +
       

     

       45
       46
        
           # domain-specific

     

       46
       47
        
           fetchers = callLibs ./fetchers.nix;

     

       47
       48
        
       

     
···

       59
       60
        
           inherit (trivial) id const concat or and bitAnd bitOr bitXor bitNot

     

       60
       61
        
             boolToString mergeAttrs flip mapNullable inNixShell min max

     

       61
       62
        
             importJSON warn info nixpkgsVersion version mod compare

     

       62
       62
       -
             splitByAndCompare functionArgs setFunctionArgs isFunction

     

       63
       63
       -
             assertMsg assertOneOf;

     

       64
       64
       -
       

     

       63
       63
       +
             splitByAndCompare functionArgs setFunctionArgs isFunction;

     

       65
       64
        
           inherit (fixedPoints) fix fix' extends composeExtensions

     

       66
       65
        
             makeExtensible makeExtensibleWithCustomName;

     

       67
       66
        
           inherit (attrsets) attrByPath hasAttrByPath setAttrByPath

     
···

       118
       117
        
             unknownModule mkOption;

     

       119
       118
        
           inherit (types) isType setType defaultTypeMerge defaultFunctor

     

       120
       119
        
             isOptionType mkOptionType;

     

       120
       120
       +
           inherit (asserts)

     

       121
       121
       +
             assertMsg assertOneOf;

     

       121
       122
        
           inherit (debug) addErrorContextToAttrs traceIf traceVal traceValFn

     

       122
       123
        
             traceXMLVal traceXMLValMarked traceSeq traceSeqN traceValSeq

     

       123
       124
        
             traceValSeqFn traceValSeqN traceValSeqNFn traceShowVal

+2 -2

lib/lists.nix

···

       509
       509
        
              => 3

     

       510
       510
        
         */

     

       511
       511
        
         last = list:

     

       512
       512
       -
           assert assertMsg (list != []) "lists.last: list must not be empty!";

     

       512
       512
       +
           assert lib.assertMsg (list != []) "lists.last: list must not be empty!";

     

       513
       513
        
           elemAt list (length list - 1);

     

       514
       514
        
       

     

       515
       515
        
         /* Return all elements but the last

     
···

       519
       519
        
              => [ 1 2 ]

     

       520
       520
        
         */

     

       521
       521
        
         init = list:

     

       522
       522
       -
           assert assertMsg (list != []) "lists.init: list must not be empty!";

     

       522
       522
       +
           assert lib.assertMsg (list != []) "lists.init: list must not be empty!";

     

       523
       523
        
           take (length list - 1) list;

     

       524
       524
        
       

     

       525
       525

+1 -39

lib/trivial.nix

···

       171
       171
        
           builtins.fromJSON (builtins.readFile path);

     

       172
       172
        
       

     

       173
       173
        
       

     

       174
       174
       -
         ## Warnings and asserts

     

       174
       174
       +
         ## Warnings

     

       175
       175
        
       

     

       176
       176
        
         /* See https://github.com/NixOS/nix/issues/749. Eventually we'd like these

     

       177
       177
        
            to expand to Nix builtins that carry metadata so that Nix can filter out

     
···

       188
       188
        
         warn = msg: builtins.trace "WARNING: ${msg}";

     

       189
       189
        
         info = msg: builtins.trace "INFO: ${msg}";

     

       190
       190
        
       

     

       191
       191
       -
         /* Print a trace message if pred is false.

     

       192
       192
       -
            Intended to be used to augment asserts with helpful error messages.

     

       193
       193
       -
       

     

       194
       194
       -
            Example:

     

       195
       195
       -
              assertMsg false "nope"

     

       196
       196
       -
              => false

     

       197
       197
       -
              stderr> trace: nope

     

       198
       198
       -
       

     

       199
       199
       -
              assert (assertMsg ("foo" == "bar") "foo is not bar, silly"); ""

     

       200
       200
       -
              stderr> trace: foo is not bar, silly

     

       201
       201
       -
              stderr> assert failed at …

     

       202
       202
       -
       

     

       203
       203
       -
            Type:

     

       204
       204
       -
              assertMsg :: Bool -> String -> Bool

     

       205
       205
       -
         */

     

       206
       206
       -
         # TODO(Profpatsch): add tests that check stderr

     

       207
       207
       -
         assertMsg = pred: msg:

     

       208
       208
       -
           if pred

     

       209
       209
       -
           then true

     

       210
       210
       -
           else builtins.trace msg false;

     

       211
       211
       -
       

     

       212
       212
       -
         /* Specialized `assertMsg` for checking if val is one of the elements

     

       213
       213
       -
            of a list. Useful for checking enums.

     

       214
       214
       -
       

     

       215
       215
       -
            Example:

     

       216
       216
       -
              let sslLibrary = "libressl"

     

       217
       217
       -
              in assertOneOf "sslLibrary" sslLibrary [ "openssl" "bearssl" ]

     

       218
       218
       -
              => false

     

       219
       219
       -
              stderr> trace: sslLibrary must be one of "openssl", "bearssl", but is: "libressl"

     

       220
       220
       -
       

     

       221
       221
       -
            Type:

     

       222
       222
       -
              assertOneOf :: String -> ComparableVal -> List ComparableVal -> Bool

     

       223
       223
       -
         */

     

       224
       224
       -
         assertOneOf = name: val: xs: assertMsg

     

       225
       225
       -
           (lib.elem val xs)

     

       226
       226
       -
           "${name} must be one of ${

     

       227
       227
       -
             lib.generators.toPretty {} xs}, but is: ${

     

       228
       228
       -
               lib.generators.toPretty {} val}";

     

       229
       191
        
       

     

       230
       192
        
         ## Function annotations

     

       231
       193

+1 -1

lib/types.nix

···

       441
       441
        
           # Either value of type `finalType` or `coercedType`, the latter is

     

       442
       442
        
           # converted to `finalType` using `coerceFunc`.

     

       443
       443
        
           coercedTo = coercedType: coerceFunc: finalType:

     

       444
       444
       -
             assert assertMsg (coercedType.getSubModules == null)

     

       444
       444
       +
             assert lib.assertMsg (coercedType.getSubModules == null)

     

       445
       445
        
               "coercedTo: coercedType must not have submodules (it’s a ${

     

       446
       446
        
                 coercedType.description})";

     

       447
       447
        
             mkOptionType rec {