commit b1ffe5e4c029c9f5675bcc42997413fd1b21fbf1 · pyrox.dev/nixpkgs

+32

lib/generators.nix

···

       90
       90
        
           * parsers as well.

     

       91
       91
        
           */

     

       92
       92
        
         toYAML = {}@args: toJSON args;

     

       93
       93
       +
       

     

       94
       94
       +
         # TODO we need some kind of pattern matching sometimes

     

       95
       95
       +
         /* Pretty print a value, akin to `builtins.trace`.

     

       96
       96
       +
           * Should probably be a builtin as well.

     

       97
       97
       +
           */

     

       98
       98
       +
         toPretty = {

     

       99
       99
       +
           /* If this option is true, attrsets like { __pretty = fn; val = …; }

     

       100
       100
       +
              will use fn to convert val to a pretty printed representation.

     

       101
       101
       +
              (This means fn is type Val -> String.) */

     

       102
       102
       +
           allowPrettyValues ? false

     

       103
       103
       +
         }@args: v: with builtins;

     

       104
       104
       +
           if      isInt      v then toString v

     

       105
       105
       +
           else if isBool     v then (if v == true then "true" else "false")

     

       106
       106
       +
           else if isString   v then "\"" + v + "\""

     

       107
       107
       +
           else if null ==    v then "null"

     

       108
       108
       +
           else if isFunction v then "<λ>"

     

       109
       109
       +
           else if isList     v then "[ "

     

       110
       110
       +
               + libStr.concatMapStringsSep " " (toPretty args) v

     

       111
       111
       +
             + " ]"

     

       112
       112
       +
           else if isAttrs    v then

     

       113
       113
       +
             # apply pretty values if allowed

     

       114
       114
       +
             if attrNames v == [ "__pretty" "val" ] && allowPrettyValues

     

       115
       115
       +
                then v.__pretty v.val

     

       116
       116
       +
             # TODO: there is probably a better representation?

     

       117
       117
       +
             else if v ? type && v.type == "derivation" then "<δ>"

     

       118
       118
       +
             else "{ "

     

       119
       119
       +
                 + libStr.concatStringsSep " " (libAttr.mapAttrsToList

     

       120
       120
       +
                     (name: value:

     

       121
       121
       +
                       "${toPretty args name} = ${toPretty args value};") v)

     

       122
       122
       +
               + " }"

     

       123
       123
       +
           else "toPretty: should never happen (v = ${v})";

     

       124
       124
       +
       

     

       93
       125
        
       }

+30

lib/tests/misc.nix

···

       285
       285
        
             expected = builtins.toJSON val;

     

       286
       286
        
         };

     

       287
       287
        
       

     

       288
       288
       +
         testToPretty = {

     

       289
       289
       +
           expr = mapAttrs (const (generators.toPretty {})) rec {

     

       290
       290
       +
             int = 42;

     

       291
       291
       +
             bool = true;

     

       292
       292
       +
             string = "fnord";

     

       293
       293
       +
             null_ = null;

     

       294
       294
       +
             function = x: x;

     

       295
       295
       +
             list = [ 3 4 function [ false ] ];

     

       296
       296
       +
             attrs = { foo = null; "foo bar" = "baz"; };

     

       297
       297
       +
             drv = derivation { name = "test"; system = builtins.currentSystem; };

     

       298
       298
       +
           };

     

       299
       299
       +
           expected = rec {

     

       300
       300
       +
             int = "42";

     

       301
       301
       +
             bool = "true";

     

       302
       302
       +
             string = "\"fnord\"";

     

       303
       303
       +
             null_ = "null";

     

       304
       304
       +
             function = "<λ>";

     

       305
       305
       +
             list = "[ 3 4 ${function} [ false ] ]";

     

       306
       306
       +
             attrs = "{ \"foo\" = null; \"foo bar\" = \"baz\"; }";

     

       307
       307
       +
             drv = "<δ>";

     

       308
       308
       +
           };

     

       309
       309
       +
         };

     

       310
       310
       +
       

     

       311
       311
       +
         testToPrettyAllowPrettyValues = {

     

       312
       312
       +
           expr = generators.toPretty { allowPrettyValues = true; }

     

       313
       313
       +
                    { __pretty = v: "«" + v + "»"; val = "foo"; };

     

       314
       314
       +
           expected  = "«foo»";

     

       315
       315
       +
         };

     

       316
       316
       +
       

     

       317
       317
       +
       

     

       288
       318
        
       # MISC

     

       289
       319
        
       

     

       290
       320
        
         testOverridableDelayableArgsTest = {