commit a817fdac5fea62e89332ea223c0a5ea8b6443341 · pyrox.dev/nixpkgs

+8 -4

doc/languages-frameworks/pkg-config.section.md

···

       7
       7
        
       ## Writing packages providing pkg-config modules {#pkg-config-writing-packages}

     

       8
       8
        
       

     

       9
       9
        
       Packages should set `meta.pkgConfigModules` with the list of package config modules they provide.

     

       10
       10
       -
       They should also use `testers.testMetaPkgConfig` to check that the final built package matches that list.

     

       10
       10
       +
       They should also use `testers.hasPkgConfigModules` to check that the final built package matches that list,

     

       11
       11
       +
       and optionally check that the pkgconf modules' version metadata matches the derivation's.

     

       11
       12
        
       Additionally, the [`validatePkgConfig` setup hook](https://nixos.org/manual/nixpkgs/stable/#validatepkgconfig), will do extra checks on to-be-installed pkg-config modules.

     

       12
       13
        
       

     

       13
       13
       -
       A good example of all these things is zlib:

     

       14
       14
       +
       A good example of all these things is miniz:

     

       14
       15
        
       

     

       15
       16
        
       ```nix

     

       16
       17
        
       { pkg-config, testers, ... }:

     
···

       20
       21
        
       

     

       21
       22
        
         nativeBuildInputs = [ pkg-config validatePkgConfig ];

     

       22
       23
        
       

     

       23
       23
       -
         passthru.tests.pkg-config = testers.testMetaPkgConfig finalAttrs.finalPackage;

     

       24
       24
       +
         passthru.tests.pkg-config = testers.hasPkgConfigModules {

     

       25
       25
       +
           package = finalAttrs.finalPackage;

     

       26
       26
       +
           versionCheck = true;

     

       27
       27
       +
         };

     

       24
       28
        
       

     

       25
       29
        
         meta = {

     

       26
       30
        
           /* ... */

     

       27
       27
       -
           pkgConfigModules = [ "zlib" ];

     

       31
       31
       +
           pkgConfigModules = [ "miniz" ];

     

       28
       32
        
         };

     

       29
       33
        
       })

     

       30
       34
        
       ```

+26 -6

pkgs/build-support/testers/hasPkgConfigModules/tester.nix

···

       5
       5
        
       { package,

     

       6
       6
        
         moduleNames ? package.meta.pkgConfigModules,

     

       7
       7
        
         testName ? "check-pkg-config-${lib.concatStringsSep "-" moduleNames}",

     

       8
       8
       +
         version ? package.version or null,

     

       9
       9
       +
         versionCheck ? false,

     

       8
       10
        
       }:

     

       9
       11
        
       

     

       10
       12
        
       runCommand testName {

     

       11
       13
        
           nativeBuildInputs = [ pkg-config ];

     

       12
       14
        
           buildInputs = [ package ];

     

       13
       13
       -
           inherit moduleNames;

     

       15
       15
       +
           inherit moduleNames version versionCheck;

     

       14
       16
        
           meta = {

     

       15
       17
        
             description = "Test whether ${package.name} exposes pkg-config modules ${lib.concatStringsSep ", " moduleNames}.";

     

       16
       18
        
           }

     
···

       31
       33
        
               package.meta;

     

       32
       34
        
         } ''

     

       33
       35
        
           touch "$out"

     

       36
       36
       +
           notFound=0

     

       37
       37
       +
           versionMismatch=0

     

       34
       38
        
           for moduleName in $moduleNames; do

     

       35
       39
        
             echo "checking pkg-config module $moduleName in $buildInputs"

     

       36
       40
        
             set +e

     

       37
       37
       -
             version="$($PKG_CONFIG --modversion $moduleName)"

     

       41
       41
       +
             moduleVersion="$($PKG_CONFIG --modversion $moduleName)"

     

       38
       42
        
             r=$?

     

       39
       43
        
             set -e

     

       40
       44
        
             if [[ $r = 0 ]]; then

     

       41
       41
       -
               echo "✅ pkg-config module $moduleName exists and has version $version"

     

       45
       45
       +
               if [[ "$moduleVersion" == "$version" ]]; then

     

       46
       46
       +
                 echo "✅ pkg-config module $moduleName exists and has version $moduleVersion"

     

       47
       47
       +
               else

     

       48
       48
       +
                 echo "❌ pkg-config module $moduleName exists and has version $moduleVersion when $version was expected"

     

       49
       49
       +
                 ((versionMismatch+=1))

     

       50
       50
       +
               fi

     

       42
       51
        
               printf '%s\t%s\n' "$moduleName" "$version" >> "$out"

     

       43
       52
        
             else

     

       44
       44
       -
               echo "These modules were available in the input propagation closure:"

     

       45
       45
       -
               $PKG_CONFIG --list-all

     

       46
       53
        
               echo "❌ pkg-config module $moduleName was not found"

     

       47
       47
       -
               false

     

       54
       54
       +
               ((notFound+=1))

     

       48
       55
        
             fi

     

       49
       56
        
           done

     

       57
       57
       +
       

     

       58
       58
       +
           if [[ $notFound -eq 0 ]] && ([[ $versionMismatch -eq 0 ]] || [[ "$versionCheck" == false ]]); then

     

       59
       59
       +
             exit 0

     

       60
       60
       +
           fi

     

       61
       61
       +
           if [[ $notFound -ne 0 ]]; then

     

       62
       62
       +
             echo "$notFound modules not found"

     

       63
       63
       +
             echo "These modules were available in the input propagation closure:"

     

       64
       64
       +
             $PKG_CONFIG --list-all

     

       65
       65
       +
           fi

     

       66
       66
       +
           if [[ $versionMismatch -ne 0 ]]; then

     

       67
       67
       +
             echo "$versionMismatch version mismatches"

     

       68
       68
       +
           fi

     

       69
       69
       +
           exit 1

     

       50
       70
        
         ''

+13 -2

pkgs/build-support/testers/hasPkgConfigModules/tests.nix

···

       1
       1
        
       # cd nixpkgs

     

       2
       2
       -
       # nix-build -A tests.testers.hasPkgConfigModule

     

       3
       3
       -
       { lib, testers, zlib, openssl, runCommand }:

     

       2
       2
       +
       # nix-build -A tests.testers.hasPkgConfigModules

     

       3
       3
       +
       { lib, testers, miniz, zlib, openssl, runCommand }:

     

       4
       4
        
       

     

       5
       5
        
       lib.recurseIntoAttrs {

     

       6
       6
       +
       

     

       7
       7
       +
         miniz-versions-match = testers.hasPkgConfigModules {

     

       8
       8
       +
           package = miniz;

     

       9
       9
       +
           versionCheck = true;

     

       10
       10
       +
         };

     

       11
       11
       +
       

     

       12
       12
       +
         miniz-versions-mismatch = testers.testBuildFailure (testers.hasPkgConfigModules {

     

       13
       13
       +
           package = miniz;

     

       14
       14
       +
           version = "1.2.3";

     

       15
       15
       +
           versionCheck = true;

     

       16
       16
       +
         });

     

       6
       17
        
       

     

       7
       18
        
         zlib-has-zlib = testers.hasPkgConfigModules {

     

       8
       19
        
           package = zlib;

+4 -1

pkgs/development/libraries/miniz/default.nix

···

       28
       28
        
             --replace-fail '=''${exec_prefix}//' '=/'

     

       29
       29
        
         '';

     

       30
       30
        
       

     

       31
       31
       -
         passthru.tests.pkg-config = testers.testMetaPkgConfig finalAttrs.finalPackage;

     

       31
       31
       +
         passthru.tests.pkg-config = testers.hasPkgConfigModules {

     

       32
       32
       +
           package = finalAttrs.finalPackage;

     

       33
       33
       +
           versionCheck = true;

     

       34
       34
       +
         };

     

       32
       35
        
       

     

       33
       36
        
         meta = with lib; {

     

       34
       37
        
           description = "Single C source file zlib-replacement library";