From 66b35ea2c63c50616b5456c830eda88c34544202 Mon Sep 17 00:00:00 2001 From: Gabriel Arazas Date: Sat, 2 Mar 2024 18:10:21 +0800 Subject: [PATCH] bahaghari: update library arguments It makes it confusing sometimes. Not worth keeping the design. --- subprojects/bahaghari/lib/default.nix | 2 +- subprojects/bahaghari/lib/hex.nix | 14 +++---- subprojects/bahaghari/lib/math.nix | 6 +-- subprojects/bahaghari/lib/tinted-theming.nix | 22 +++++----- subprojects/bahaghari/lib/trivial.nix | 41 +++++++++--------- subprojects/bahaghari/tests/lib/default.nix | 12 ++++-- subprojects/bahaghari/tests/lib/hex.nix | 28 ++++++------- subprojects/bahaghari/tests/lib/math.nix | 42 +++++++++---------- .../tests/lib/tinted-theming/default.nix | 30 ++++++------- .../bahaghari/tests/lib/trivial/default.nix | 36 ++++++++-------- 10 files changed, 120 insertions(+), 113 deletions(-) diff --git a/subprojects/bahaghari/lib/default.nix b/subprojects/bahaghari/lib/default.nix index 9dfbed58..54c21879 100644 --- a/subprojects/bahaghari/lib/default.nix +++ b/subprojects/bahaghari/lib/default.nix @@ -10,7 +10,7 @@ pkgs.lib.makeExtensible (self: let - callLibs = file: import file { lib = self; inherit pkgs; }; + callLibs = file: import file { inherit (pkgs) lib; inherit pkgs self; }; in { trivial = callLibs ./trivial.nix; diff --git a/subprojects/bahaghari/lib/hex.nix b/subprojects/bahaghari/lib/hex.nix index 5bc688f1..29edffc8 100644 --- a/subprojects/bahaghari/lib/hex.nix +++ b/subprojects/bahaghari/lib/hex.nix @@ -1,7 +1,7 @@ # A small utility library for manipulating hexadecimal numbers. It's made in 15 # minutes with a bunch of duct tape on it but it's working for its intended # purpose. -{ pkgs, lib }: +{ pkgs, lib, self }: let glyphList = @@ -24,7 +24,7 @@ let "F" ]; - baseSet = lib.generateBaseDigitType glyphList; + baseSet = self.generateBaseDigitType glyphList; in rec { /* Returns a convenient glyph set for creating your own conversion or @@ -41,7 +41,7 @@ rec { => [ "F" "10" "11" ] */ range = first: last: - builtins.map (n: baseSet.fromDec n) (pkgs.lib.lists.range first last); + builtins.map (n: baseSet.fromDec n) (lib.lists.range first last); /* Checks if the given hex string is valid or not. @@ -77,13 +77,13 @@ rec { */ pad = n: hex: let - strLength = pkgs.lib.stringLength hex; + strLength = lib.stringLength hex; reqWidth = n - strLength; - components = pkgs.lib.genList (_: "0") reqWidth ++ [ hex ]; + components = lib.genList (_: "0") reqWidth ++ [ hex ]; in - assert pkgs.lib.assertMsg (isHexString hex) + assert lib.assertMsg (isHexString hex) "bahaghariLib.hex.pad: given hex number (${hex}) is not valid"; if (reqWidth <= 0) then hex - else pkgs.lib.concatStringsSep "" components; + else lib.concatStringsSep "" components; } diff --git a/subprojects/bahaghari/lib/math.nix b/subprojects/bahaghari/lib/math.nix index c8e71c51..d5f82fba 100644 --- a/subprojects/bahaghari/lib/math.nix +++ b/subprojects/bahaghari/lib/math.nix @@ -1,7 +1,7 @@ # A little math utility for common operations. Don't expect any high-level # mathematical operations nor godly optimizations expected from a typical math # library, it's just basic high school type of shit in all aspects. -{ pkgs, lib }: +{ pkgs, lib, self }: rec { /* Returns the absolute value of the given number. @@ -53,7 +53,7 @@ rec { => true */ isWithinRange = min: max: number: - (pkgs.lib.max number min) <= (pkgs.lib.min number max); + (lib.max number min) <= (lib.min number max); /* Given a number, make it grow by given amount of percentage. A value of 100 should make the number doubled. @@ -86,7 +86,7 @@ rec { let res = grow number value; in - pkgs.lib.min max (pkgs.lib.max res min); + lib.min max (lib.max res min); /* Given a number, return its value by the given percentage. diff --git a/subprojects/bahaghari/lib/tinted-theming.nix b/subprojects/bahaghari/lib/tinted-theming.nix index e51f0ae0..412ce4a7 100644 --- a/subprojects/bahaghari/lib/tinted-theming.nix +++ b/subprojects/bahaghari/lib/tinted-theming.nix @@ -1,16 +1,16 @@ -{ pkgs, lib }: +{ pkgs, lib, self }: # TODO: Remove the legacy scheme support once it is entirely removed in Tinted # Theming standard. let isBaseX = i: palette: let - paletteNames = pkgs.lib.attrNames palette; - maxDigitLength = pkgs.lib.lists.length (pkgs.lib.toBaseDigits 10 i); - mkBaseAttr = hex: "base${lib.hex.pad maxDigitLength hex}"; - schemeNames = builtins.map mkBaseAttr (lib.hex.range 0 (i - 1)); + paletteNames = lib.attrNames palette; + maxDigitLength = lib.lists.length (lib.toBaseDigits 10 i); + mkBaseAttr = hex: "base${self.hex.pad maxDigitLength hex}"; + schemeNames = builtins.map mkBaseAttr (self.hex.range 0 (i - 1)); in - (pkgs.lib.count (name: pkgs.lib.elem name schemeNames) paletteNames) == i; + (lib.count (name: lib.elem name schemeNames) paletteNames) == i; in rec { # TODO: Return a Nix object to generate a Tinted Theming color scheme from an @@ -105,7 +105,7 @@ rec { else null; palette = - pkgs.lib.attrsets.removeAttrs scheme [ "author" "description" "scheme" ]; + lib.attrsets.removeAttrs scheme [ "author" "description" "scheme" ]; in { inherit (scheme) author; @@ -113,8 +113,8 @@ rec { name = scheme.scheme; } - // pkgs.lib.optionalAttrs (scheme?description) { inherit (scheme) description; } - // pkgs.lib.optionalAttrs (system != null) { inherit system; }; + // lib.optionalAttrs (scheme?description) { inherit (scheme) description; } + // lib.optionalAttrs (system != null) { inherit system; }; /* Imports a Base16 scheme. This also handles converting the legacy Base16 schema into the new one if it's detected. Take note, every single token @@ -139,9 +139,9 @@ rec { */ importScheme = yamlpath: let - scheme = lib.importYAML yamlpath; + scheme = self.importYAML yamlpath; in - assert pkgs.lib.assertMsg (isValidScheme scheme || isLegacyScheme scheme) + assert lib.assertMsg (isValidScheme scheme || isLegacyScheme scheme) "bahaghariLib.tinted-theming.importScheme: given data is not a valid Tinted Theming scheme"; if isLegacyScheme scheme then modernizeLegacyScheme scheme diff --git a/subprojects/bahaghari/lib/trivial.nix b/subprojects/bahaghari/lib/trivial.nix index 6cf9d91d..9c559361 100644 --- a/subprojects/bahaghari/lib/trivial.nix +++ b/subprojects/bahaghari/lib/trivial.nix @@ -1,4 +1,4 @@ -{ pkgs, lib }: +{ pkgs, lib, self }: rec { inherit (pkgs.lib.generators) toYAML; @@ -21,10 +21,10 @@ rec { importYAML = path: let dataDrv = pkgs.runCommand "convert-yaml-to-json" { } '' - ${pkgs.lib.getExe' pkgs.yaml2json "yaml2json"} < "${path}" > "$out" + ${lib.getExe' pkgs.yaml2json "yaml2json"} < "${path}" > "$out" ''; in - pkgs.lib.importJSON dataDrv; + lib.importJSON dataDrv; /* Convert a given decimal number to a specified base digit with the set of glyphs for each digit as returned from lib.toBaseDigits. @@ -44,10 +44,10 @@ rec { */ toBaseDigitsWithGlyphs = base: i: glyphs: let - baseDigits = pkgs.lib.toBaseDigits base i; + baseDigits = lib.toBaseDigits base i; toBaseDigits = d: glyphs.${builtins.toString d}; in - pkgs.lib.concatMapStrings toBaseDigits baseDigits; + lib.concatMapStrings toBaseDigits baseDigits; /* Generates a glyph set usable for `toBaseDigitsWithGlyphs`. Take note the given list is assumed to be sorted and the generated glyph set starts at @@ -68,11 +68,11 @@ rec { generateGlyphSet = glyphsList: let glyphsList' = - pkgs.lib.lists.imap0 - (i: glyph: pkgs.lib.nameValuePair (builtins.toString i) glyph) + lib.lists.imap0 + (i: glyph: lib.nameValuePair (builtins.toString i) glyph) glyphsList; in - pkgs.lib.listToAttrs glyphsList'; + lib.listToAttrs glyphsList'; /* Generates a conversion table for a sorted list of glyphs to its decimal number. Suitable for creating your own conversion function. Accepts the @@ -93,11 +93,11 @@ rec { generateConversionTable = glyphsList: let glyphsList' = - pkgs.lib.lists.imap0 - (i: glyph: pkgs.lib.nameValuePair glyph i) + lib.lists.imap0 + (i: glyph: lib.nameValuePair glyph i) glyphsList; in - pkgs.lib.listToAttrs glyphsList'; + lib.listToAttrs glyphsList'; /* A factory function for generating an attribute set containing a glyph set, a conversion table, and a conversion function to and from decimal. @@ -118,7 +118,7 @@ rec { } */ generateBaseDigitType = glyphsList: rec { - base = pkgs.lib.length glyphsList; + base = lib.length glyphsList; glyphSet = generateGlyphSet glyphsList; conversionTable = generateConversionTable glyphsList; @@ -129,18 +129,18 @@ rec { # open a can of worms about implementing this with stringy types. fromDec = decimal: let - digits = pkgs.lib.toBaseDigits base decimal; + digits = lib.toBaseDigits base decimal; in - pkgs.lib.concatMapStrings (d: glyphSet.${builtins.toString d}) digits; + lib.concatMapStrings (d: glyphSet.${builtins.toString d}) digits; toDec = digit: let - chars = pkgs.lib.stringToCharacters digit; - maxDigits = (pkgs.lib.length chars) - 1; + chars = lib.stringToCharacters digit; + maxDigits = (lib.length chars) - 1; convertDigitToDec = - pkgs.lib.lists.imap0 (i: v: conversionTable.${v} * (lib.math.pow base (maxDigits - i))) chars; + lib.lists.imap0 (i: v: conversionTable.${v} * (self.math.pow base (maxDigits - i))) chars; in - pkgs.lib.foldl (sum: v: sum + v) 0 convertDigitToDec; + lib.foldl (sum: v: sum + v) 0 convertDigitToDec; }; /* Given a range of two numbers, ensure the value is only returned within the @@ -154,7 +154,10 @@ rec { clamp (-100) 100 (-234) => -100 + + clamp (-100) 100 54 + => 54 */ clamp = min: max: value: - pkgs.lib.min max (pkgs.lib.max min value); + lib.min max (lib.max min value); } diff --git a/subprojects/bahaghari/tests/lib/default.nix b/subprojects/bahaghari/tests/lib/default.nix index 9d5f91df..d0a5bc24 100644 --- a/subprojects/bahaghari/tests/lib/default.nix +++ b/subprojects/bahaghari/tests/lib/default.nix @@ -2,10 +2,14 @@ let lib = import ../../lib { inherit pkgs; }; + callLib = file: import file { + inherit (pkgs) lib; inherit pkgs; + self = lib; + }; in { - hex = import ./hex.nix { inherit pkgs lib; }; - math = import ./math.nix { inherit pkgs lib; }; - trivial = import ./trivial { inherit pkgs lib; }; - tinted-theming = import ./tinted-theming { inherit pkgs lib; }; + hex = callLib ./hex.nix; + math = callLib ./math.nix; + trivial = callLib ./trivial; + tinted-theming = callLib ./tinted-theming; } diff --git a/subprojects/bahaghari/tests/lib/hex.nix b/subprojects/bahaghari/tests/lib/hex.nix index 9ec5bbd4..e78558cb 100644 --- a/subprojects/bahaghari/tests/lib/hex.nix +++ b/subprojects/bahaghari/tests/lib/hex.nix @@ -1,63 +1,63 @@ -{ pkgs, lib }: +{ pkgs, lib, self }: -pkgs.lib.runTests { +lib.runTests { testToHexString = { - expr = lib.hex.fromDec 293454837; + expr = self.hex.fromDec 293454837; expected = "117DC3F5"; }; testToHexString2 = { - expr = lib.hex.fromDec 4500; + expr = self.hex.fromDec 4500; expected = "1194"; }; testToHexString3 = { - expr = lib.hex.fromDec 5942819; + expr = self.hex.fromDec 5942819; expected = "5AAE23"; }; testHexToDec = { - expr = lib.hex.toDec "FF"; + expr = self.hex.toDec "FF"; expected = 255; }; testHexToDec2 = { - expr = lib.hex.toDec "333FAB333"; + expr = self.hex.toDec "333FAB333"; expected = 13756969779; }; testCreateHexRange = { - expr = lib.hex.range 10 17; + expr = self.hex.range 10 17; expected = [ "A" "B" "C" "D" "E" "F" "10" "11" ]; }; testCreateHexWithHigherStart = { - expr = lib.hex.range 49 17; + expr = self.hex.range 49 17; expected = [ ]; }; testIsHexString = { - expr = lib.hex.isHexString "ABC"; + expr = self.hex.isHexString "ABC"; expected = true; }; testIsHexStringWithInvalidHex = { - expr = lib.hex.isHexString "WHAT IS THIS"; + expr = self.hex.isHexString "WHAT IS THIS"; expected = false; }; testHexPad = { - expr = lib.hex.pad 5 "A"; + expr = self.hex.pad 5 "A"; expected = "0000A"; }; testHexPadWithLowerMaxDigits = { - expr = lib.hex.pad 1 "9AC"; + expr = self.hex.pad 1 "9AC"; expected = "9AC"; }; testHexPadWithNegativeDigits = { - expr = lib.hex.pad (-5) "A42C"; + expr = self.hex.pad (-5) "A42C"; expected = "A42C"; }; } diff --git a/subprojects/bahaghari/tests/lib/math.nix b/subprojects/bahaghari/tests/lib/math.nix index 097c536c..f25ab4fd 100644 --- a/subprojects/bahaghari/tests/lib/math.nix +++ b/subprojects/bahaghari/tests/lib/math.nix @@ -1,98 +1,98 @@ -{ pkgs, lib }: +{ pkgs, lib, self }: -pkgs.lib.runTests { +lib.runTests { testMathPowPositive = { - expr = lib.math.pow 2 8; + expr = self.math.pow 2 8; expected = 256; }; testMathPowNegative = { - expr = lib.math.pow 2.0 (-1); + expr = self.math.pow 2.0 (-1); expected = 0.5; }; testMathPowZero = { - expr = lib.math.pow 31 0; + expr = self.math.pow 31 0; expected = 1; }; testMathAbsoluteValue = { - expr = lib.math.abs 5493; + expr = self.math.abs 5493; expected = 5493; }; testMathAbsoluteValue2 = { - expr = lib.math.abs (-435354); + expr = self.math.abs (-435354); expected = 435354; }; testMathPercentage = { - expr = lib.math.percentage 50 100; + expr = self.math.percentage 50 100; expected = 50; }; testMathPercentage2 = { - expr = lib.math.percentage 13 453; + expr = self.math.percentage 13 453; expected = 58.89; }; testMathPercentageNegative = { - expr = lib.math.percentage (-20) 500; + expr = self.math.percentage (-20) 500; expected = -100; }; testMathPercentageNegative2 = { - expr = lib.math.percentage (-64) 843; + expr = self.math.percentage (-64) 843; expected = -539.52; }; testMathPercentageZero = { - expr = lib.math.percentage 0 45723; + expr = self.math.percentage 0 45723; expected = 0; }; testMathPercentageZero2 = { - expr = lib.math.percentage 0 (-3423); + expr = self.math.percentage 0 (-3423); expected = 0; }; testMathGrow = { - expr = lib.math.grow 500 12; + expr = self.math.grow 500 12; expected = 72; }; testMathGrow2 = { - expr = lib.math.grow 55.5 5.5; + expr = self.math.grow 55.5 5.5; expected = 8.5525; }; testMathGrowVariantMax = { - expr = lib.math.grow' 0 255 130 100; + expr = self.math.grow' 0 255 130 100; expected = 255; }; testMathGrowVariantMin = { - expr = lib.math.grow' 0 255 130 (-500); + expr = self.math.grow' 0 255 130 (-500); expected = 0; }; testMathRoundDown = { - expr = lib.math.round 2.3; + expr = self.math.round 2.3; expected = 2; }; testMathRoundUp = { - expr = lib.math.round 2.8; + expr = self.math.round 2.8; expected = 3; }; testMathWithinRange = { - expr = lib.math.isWithinRange (-100) 100 50; + expr = self.math.isWithinRange (-100) 100 50; expected = true; }; testMathWithinRange2 = { - expr = lib.math.isWithinRange 5 10 (-5); + expr = self.math.isWithinRange 5 10 (-5); expected = false; }; } diff --git a/subprojects/bahaghari/tests/lib/tinted-theming/default.nix b/subprojects/bahaghari/tests/lib/tinted-theming/default.nix index 24a4a2ea..68f34584 100644 --- a/subprojects/bahaghari/tests/lib/tinted-theming/default.nix +++ b/subprojects/bahaghari/tests/lib/tinted-theming/default.nix @@ -1,14 +1,14 @@ -{ pkgs, lib }: +{ pkgs, lib, self }: let - sampleBase16Scheme = lib.tinted-theming.importScheme ./sample-base16-scheme.yml; - sampleBase16Scheme' = lib.tinted-theming.importScheme ./sample-base16-scheme-with-missing-colors.yml; - sampleBase24Scheme = lib.tinted-theming.importScheme ./sample-base24-scheme.yml; - sampleBase24Scheme' = lib.tinted-theming.importScheme ./sample-base24-scheme-with-missing-colors.yml; + sampleBase16Scheme = self.tinted-theming.importScheme ./sample-base16-scheme.yml; + sampleBase16Scheme' = self.tinted-theming.importScheme ./sample-base16-scheme-with-missing-colors.yml; + sampleBase24Scheme = self.tinted-theming.importScheme ./sample-base24-scheme.yml; + sampleBase24Scheme' = self.tinted-theming.importScheme ./sample-base24-scheme-with-missing-colors.yml; in -pkgs.lib.runTests { +lib.runTests { testTintedThemingSchemeImport = { - expr = lib.tinted-theming.importScheme ./sample-base16-scheme.yml; + expr = self.tinted-theming.importScheme ./sample-base16-scheme.yml; expected = { system = "base16"; name = "Bark on a tree"; @@ -37,7 +37,7 @@ pkgs.lib.runTests { }; testTintedThemingLegacyBase24SchemeImport = { - expr = lib.tinted-theming.importScheme ./sample-legacy-base24.yml; + expr = self.tinted-theming.importScheme ./sample-legacy-base24.yml; expected = { system = "base24"; name = "Scheme Name"; @@ -73,7 +73,7 @@ pkgs.lib.runTests { }; testTintedThemingLegacyBase16SchemeImport = { - expr = lib.tinted-theming.importScheme ./sample-legacy-base16.yml; + expr = self.tinted-theming.importScheme ./sample-legacy-base16.yml; expected = { system = "base16"; name = "Scheme Name"; @@ -101,32 +101,32 @@ pkgs.lib.runTests { }; testIsBase16 = { - expr = lib.tinted-theming.isBase16 sampleBase16Scheme.palette; + expr = self.tinted-theming.isBase16 sampleBase16Scheme.palette; expected = true; }; testIsNotBase16 = { - expr = lib.tinted-theming.isBase16 sampleBase16Scheme'.palette; + expr = self.tinted-theming.isBase16 sampleBase16Scheme'.palette; expected = false; }; testIsBase24 = { - expr = lib.tinted-theming.isBase24 sampleBase24Scheme.palette; + expr = self.tinted-theming.isBase24 sampleBase24Scheme.palette; expected = true; }; testIsNotBase24 = { - expr = lib.tinted-theming.isBase24 sampleBase24Scheme'.palette; + expr = self.tinted-theming.isBase24 sampleBase24Scheme'.palette; expected = false; }; testIsALegacyBase16Scheme = { - expr = lib.tinted-theming.isLegacyScheme (lib.importYAML ./sample-legacy-base16.yml); + expr = self.tinted-theming.isLegacyScheme (self.importYAML ./sample-legacy-base16.yml); expected = true; }; testIsALegacyBase24Scheme = { - expr = lib.tinted-theming.isLegacyScheme (lib.importYAML ./sample-legacy-base24.yml); + expr = self.tinted-theming.isLegacyScheme (self.importYAML ./sample-legacy-base24.yml); expected = true; }; } diff --git a/subprojects/bahaghari/tests/lib/trivial/default.nix b/subprojects/bahaghari/tests/lib/trivial/default.nix index d55861c6..9d311271 100644 --- a/subprojects/bahaghari/tests/lib/trivial/default.nix +++ b/subprojects/bahaghari/tests/lib/trivial/default.nix @@ -1,4 +1,4 @@ -{ pkgs, lib }: +{ pkgs, lib, self }: let customOctalGlyphs = { @@ -66,21 +66,21 @@ let "23" = "N"; }; - base24Set = lib.trivial.generateBaseDigitType base24GlyphsList; + base24Set = self.trivial.generateBaseDigitType base24GlyphsList; in -pkgs.lib.runTests { +lib.runTests { testGenerateCustomGlyphSet = { - expr = lib.trivial.generateGlyphSet [ "A" "B" "C" "D" "E" "F" "G" "H" ]; + expr = self.trivial.generateGlyphSet [ "A" "B" "C" "D" "E" "F" "G" "H" ]; expected = customOctalGlyphs; }; testGenerateBase24GlyphSet = { - expr = lib.trivial.generateGlyphSet base24GlyphsList; + expr = self.trivial.generateGlyphSet base24GlyphsList; expected = customBase24Glyphs; }; testGenerateConversionTable = { - expr = lib.trivial.generateConversionTable [ "A" "B" "C" "D" "E" "F" "G" "H" ]; + expr = self.trivial.generateConversionTable [ "A" "B" "C" "D" "E" "F" "G" "H" ]; expected = { "A" = 0; "B" = 1; @@ -94,7 +94,7 @@ pkgs.lib.runTests { }; testGenerateConversionTable2 = { - expr = lib.trivial.generateConversionTable + expr = self.trivial.generateConversionTable [ "0" "1" @@ -145,29 +145,29 @@ pkgs.lib.runTests { }; testBaseDigitWithCustomOctalGlyph = { - expr = lib.trivial.toBaseDigitsWithGlyphs 8 9 customOctalGlyphs; + expr = self.trivial.toBaseDigitsWithGlyphs 8 9 customOctalGlyphs; expected = "BB"; }; testBaseDigitWithCustomOctalGlyph2 = { - expr = lib.trivial.toBaseDigitsWithGlyphs 8 641 customOctalGlyphs; + expr = self.trivial.toBaseDigitsWithGlyphs 8 641 customOctalGlyphs; expected = "BCAB"; }; testBaseDigitWithProperBase24Glyph = { - expr = lib.trivial.toBaseDigitsWithGlyphs 24 641 customBase24Glyphs; + expr = self.trivial.toBaseDigitsWithGlyphs 24 641 customBase24Glyphs; expected = "12H"; }; testBaseDigitWithProperBase24Glyph2 = { - expr = lib.trivial.toBaseDigitsWithGlyphs 24 2583 customBase24Glyphs; + expr = self.trivial.toBaseDigitsWithGlyphs 24 2583 customBase24Glyphs; expected = "4BF"; }; - # We're mainly testing if the underlying YAML library is mostly compliant + # We're mainly testing if the underlying YAML selfrary is mostly compliant # with whatever it claims. testImportBasicYAML = { - expr = lib.trivial.importYAML ./simple.yml; + expr = self.trivial.importYAML ./simple.yml; expected = { hello = "there"; how-are-you-doing = "I'm fine. Thank you for asking.\n"; @@ -177,7 +177,7 @@ pkgs.lib.runTests { }; testImportTintedThemingBase16YAML = { - expr = lib.trivial.importYAML ../tinted-theming/sample-base16-scheme.yml; + expr = self.trivial.importYAML ../tinted-theming/sample-base16-scheme.yml; expected = { system = "base16"; name = "Bark on a tree"; @@ -207,22 +207,22 @@ pkgs.lib.runTests { # YAML is a superset of JSON (or was it the other way around?) after v1.2. testToYAML = { - expr = lib.trivial.toYAML { } { hello = "there"; }; + expr = self.trivial.toYAML { } { hello = "there"; }; expected = "{\"hello\":\"there\"}"; }; testNumberClamp = { - expr = lib.trivial.clamp 1 10 4; + expr = self.trivial.clamp 1 10 4; expected = 4; }; testNumberClampMin = { - expr = lib.trivial.clamp 1 10 (-5); + expr = self.trivial.clamp 1 10 (-5); expected = 1; }; testNumberClampMax = { - expr = lib.trivial.clamp 1 10 453; + expr = self.trivial.clamp 1 10 453; expected = 10; }; }