commit ed4523186e452d185d8ba1d1eabe07ace33a4f87 · pyrox.dev/nixpkgs

+26

doc/builders/trivial-builders.chapter.md

···

       51
       51
        
       

     

       52
       52
        
       This can be used to put many derivations into the same directory structure. It works by creating a new derivation and adding symlinks to each of the paths listed. It expects two arguments, `name`, and `paths`. `name` is the name used in the Nix store path for the created derivation. `paths` is a list of paths that will be symlinked. These paths can be to Nix store derivations or any other subdirectory contained within.

     

       53
       53
        
       

     

       54
       54
       +
       ## `writeReferencesToFile` {#trivial-builder-writeReferencesToFile}

     

       55
       55
       +
       

     

       56
       56
       +
       Writes the closure of transitive dependencies to a file.

     

       57
       57
       +
       

     

       58
       58
       +
       This produces the equivalent of `nix-store -q --requisites`.

     

       59
       59
       +
       

     

       60
       60
       +
       For example,

     

       61
       61
       +
       

     

       62
       62
       +
       ```nix

     

       63
       63
       +
       writeReferencesToFile (writeScriptBin "hi" ''${hello}/bin/hello'')

     

       64
       64
       +
       ```

     

       65
       65
       +
       

     

       66
       66
       +
       produces an output path `/nix/store/<hash>-runtime-deps` containing

     

       67
       67
       +
       

     

       68
       68
       +
       ```nix

     

       69
       69
       +
       /nix/store/<hash>-hello-2.10

     

       70
       70
       +
       /nix/store/<hash>-hi

     

       71
       71
       +
       /nix/store/<hash>-libidn2-2.3.0

     

       72
       72
       +
       /nix/store/<hash>-libunistring-0.9.10

     

       73
       73
       +
       /nix/store/<hash>-glibc-2.32-40

     

       74
       74
       +
       ```

     

       75
       75
       +
       

     

       76
       76
       +
       You can see that this includes `hi`, the original input path,

     

       77
       77
       +
       `hello`, which is a direct reference, but also

     

       78
       78
       +
       the other paths that are indirectly required to run `hello`.

     

       79
       79
       +
       

     

       54
       80
        
       ## `writeDirectReferencesToFile` {#trivial-builder-writeDirectReferencesToFile}

     

       55
       81
        
       

     

       56
       82
        
       Writes the set of references to the output file, that is, their immediate dependencies.

+16

pkgs/build-support/trivial-builders/test.sh

···

       38
       38
        
       testDirectReferences 'writeText "hi" "hello ${hello}"'

     

       39
       39
        
       testDirectReferences 'writeText "hi" "hello ${hello} ${figlet}"'

     

       40
       40
        
       

     

       41
       41
       +
       

     

       42
       42
       +
       

     

       43
       43
       +
       testClosure() {

     

       44
       44
       +
         expr="$1"

     

       45
       45
       +
         diff -U3 \

     

       46
       46
       +
           <(sort <$(nix-build --no-out-link --expr "with import ../../.. {}; writeReferencesToFile ($expr)")) \

     

       47
       47
       +
           <(nix-store -q --requisites $(nix-build --no-out-link --expr "with import ../../.. {}; ($expr)") | sort)

     

       48
       48
       +
       }

     

       49
       49
       +
       

     

       50
       50
       +
       testClosure 'hello'

     

       51
       51
       +
       testClosure 'figlet'

     

       52
       52
       +
       testClosure 'writeText "hi" "hello"'

     

       53
       53
       +
       testClosure 'writeText "hi" "hello ${hello}"'

     

       54
       54
       +
       testClosure 'writeText "hi" "hello ${hello} ${figlet}"'

     

       55
       55
       +
       

     

       56
       56
       +
       

     

       41
       57
        
       echo 'OK!'