···

       
94
       
94
       
 
       
stdenvNoCC.mkDerivation {

     

       
95
       
95
       
 
       
  name = "nixpkgs-lib-docs";

     

       
96
       
96
       
 
       


     

       
97
       
97
       
-
       
  src = lib.fileset.toSource {

     

       
98
       
98
       
-
       
    root = ../..;

     

       
99
       
99
       
-
       
    fileset = ../../lib;

     

       
100
       
100
       
-
       
  };

     

       
97
       
97
       
+
       
  src = ../../lib;

     

       
101
       
98
       
 
       


     

       
102
       
99
       
 
       
  nativeBuildInputs = [

     

       
103
       
100
       
 
       
    nixdoc

     
···

       
105
       
102
       
 
       
  ];

     

       
106
       
103
       
 
       


     

       
107
       
104
       
 
       
  installPhase = ''

     

       
105
       
105
       
+
       
    cd ..

     

       
106
       
106
       
+
       


     

       
108
       
107
       
 
       
    export NIX_STATE_DIR=$(mktemp -d)

     

       
109
       
108
       
 
       
    nix-instantiate --eval --strict --json ${./lib-function-locations.nix} \

     

       
110
       
109
       
 
       
      --arg nixpkgsPath "./." \

     

···

       
25
       
25
       
 
       


     

       
26
       
26
       
 
       
    nativeBuildInputs = [ nixos-render-docs ];

     

       
27
       
27
       
 
       


     

       
28
       
28
       
-
       
    src = lib.fileset.toSource {

     

       
29
       
29
       
-
       
      root = ../.;

     

       
30
       
30
       
-
       
      fileset = lib.fileset.unions [

     

       
31
       
31
       
-
       
        (lib.fileset.fileFilter (file: file.hasExt "md" || file.hasExt "md.in") ../.)

     

       
32
       
32
       
-
       
        ../style.css

     

       
33
       
33
       
-
       
        ../anchor-use.js

     

       
34
       
34
       
-
       
        ../anchor.min.js

     

       
35
       
35
       
-
       
        ../manpage-urls.json

     

       
36
       
36
       
-
       
        ../redirects.json

     

       
37
       
37
       
-
       
      ];

     

       
28
       
28
       
+
       
    src = lib.cleanSourceWith {

     

       
29
       
29
       
+
       
      src = ../.;

     

       
30
       
30
       
+
       
      filter =

     

       
31
       
31
       
+
       
        path: type:

     

       
32
       
32
       
+
       
        type == "directory"

     

       
33
       
33
       
+
       
        || lib.hasSuffix ".md" path

     

       
34
       
34
       
+
       
        || lib.hasSuffix ".md.in" path

     

       
35
       
35
       
+
       
        || lib.elem path (

     

       
36
       
36
       
+
       
          map toString [

     

       
37
       
37
       
+
       
            ../style.css

     

       
38
       
38
       
+
       
            ../anchor-use.js

     

       
39
       
39
       
+
       
            ../anchor.min.js

     

       
40
       
40
       
+
       
            ../manpage-urls.json

     

       
41
       
41
       
+
       
            ../redirects.json

     

       
42
       
42
       
+
       
          ]

     

       
43
       
43
       
+
       
        );

     

       
38
       
44
       
 
       
    };

     

       
39
       
45
       
 
       


     

       
40
       
46
       
 
       
    postPatch = ''

     

···

       
14
       
14
       
 
       
  extraPythonPackages ? (_: [ ]),

     

       
15
       
15
       
 
       
  nixosTests,

     

       
16
       
16
       
 
       
}:

     

       
17
       
17
       
-
       
let

     

       
18
       
18
       
-
       
  fs = lib.fileset;

     

       
19
       
19
       
-
       
in

     

       
20
       
17
       
 
       
python3Packages.buildPythonApplication {

     

       
21
       
18
       
 
       
  pname = "nixos-test-driver";

     

       
22
       
19
       
 
       
  version = "1.1";

     

       
23
       
20
       
 
       
  pyproject = true;

     

       
24
       
21
       
 
       


     

       
25
       
25
       
-
       
  src = fs.toSource {

     

       
26
       
26
       
-
       
    root = ./.;

     

       
27
       
27
       
-
       
    fileset = fs.unions [

     

       
28
       
28
       
-
       
      ./pyproject.toml

     

       
29
       
29
       
-
       
      ./test_driver

     

       
30
       
30
       
-
       
      ./extract-docstrings.py

     

       
31
       
31
       
-
       
    ];

     

       
32
       
32
       
-
       
  };

     

       
22
       
22
       
+
       
  src = ./src;

     

       
33
       
23
       
 
       


     

       
34
       
24
       
 
       
  build-system = with python3Packages; [

     

       
35
       
25
       
 
       
    setuptools

     

···

       
11
       
11
       
 
       


     

       
12
       
12
       
 
       
runCommand "nixos-test-driver-docstrings" env ''

     

       
13
       
13
       
 
       
  mkdir $out

     

       
14
       
14
       
-
       
  python3 ${./extract-docstrings.py} ${./test_driver/machine.py} \

     

       
14
       
14
       
+
       
  python3 ${./src/extract-docstrings.py} ${./src/test_driver/machine.py} \

     

       
15
       
15
       
 
       
    > $out/machine-methods.md

     

       
16
       
16
       
 
       
''

     

···

       
2
       
2
       
 
       
{

     

       
3
       
3
       
 
       
  lib,

     

       
4
       
4
       
 
       
  stdenv,

     

       
5
       
5
       
+
       
  runCommand,

     

       
5
       
6
       
 
       
  shellcheck,

     

       
6
       
7
       
 
       
}:

     

       
7
       
8
       
 
       


     
···

       
10
       
11
       
 
       
# Tests: ./tests.nix

     

       
11
       
12
       
 
       
{ src }:

     

       
12
       
13
       
 
       
let

     

       
13
       
13
       
-
       
  inherit (lib) fileset pathType isPath;

     

       
14
       
14
       
+
       
  inherit (lib) pathType isPath;

     

       
14
       
15
       
 
       
in

     

       
15
       
16
       
 
       
stdenv.mkDerivation {

     

       
16
       
17
       
 
       
  name = "run-shellcheck";

     
···

       
18
       
19
       
 
       
    if

     

       
19
       
20
       
 
       
      isPath src && pathType src == "regular" # note that for strings this would have been IFD, which we prefer to avoid

     

       
20
       
21
       
 
       
    then

     

       
21
       
21
       
-
       
      fileset.toSource {

     

       
22
       
22
       
-
       
        root = dirOf src;

     

       
23
       
23
       
-
       
        fileset = src;

     

       
24
       
24
       
-
       
      }

     

       
22
       
22
       
+
       
      runCommand "testers-shellcheck-src" { } ''

     

       
23
       
23
       
+
       
        mkdir $out

     

       
24
       
24
       
+
       
        cp ${src} $out

     

       
25
       
25
       
+
       
      ''

     

       
25
       
26
       
 
       
    else

     

       
26
       
27
       
 
       
      src;

     

       
27
       
28
       
 
       
  nativeBuildInputs = [ shellcheck ];

     

···

       
6
       
6
       
 
       
  testers,

     

       
7
       
7
       
 
       
  runCommand,

     

       
8
       
8
       
 
       
}:

     

       
9
       
9
       
-
       
let

     

       
10
       
10
       
-
       
  inherit (lib) fileset;

     

       
11
       
11
       
-
       
in

     

       
12
       
9
       
 
       
lib.recurseIntoAttrs {

     

       
13
       
10
       
 
       


     

       
14
       
11
       
 
       
  example-dir =

     
···

       
16
       
13
       
 
       
      {

     

       
17
       
14
       
 
       
        failure = testers.testBuildFailure (

     

       
18
       
15
       
 
       
          testers.shellcheck {

     

       
19
       
19
       
-
       
            src = fileset.toSource {

     

       
20
       
20
       
-
       
              root = ./.;

     

       
21
       
21
       
-
       
              fileset = fileset.unions [

     

       
22
       
22
       
-
       
                ./example.sh

     

       
23
       
23
       
-
       
              ];

     

       
24
       
24
       
-
       
            };

     

       
16
       
16
       
+
       
            src = ./src;

     

       
25
       
17
       
 
       
          }

     

       
26
       
18
       
 
       
        );

     

       
27
       
19
       
 
       
      }

     
···

       
37
       
29
       
 
       
      {

     

       
38
       
30
       
 
       
        failure = testers.testBuildFailure (

     

       
39
       
31
       
 
       
          testers.shellcheck {

     

       
40
       
40
       
-
       
            src = ./example.sh;

     

       
32
       
32
       
+
       
            src = ./src/example.sh;

     

       
41
       
33
       
 
       
          }

     

       
42
       
34
       
 
       
        );

     

       
43
       
35
       
 
       
      }

     

···

       
1
       
1
       
 
       
{

     

       
2
       
2
       
 
       
  callPackage,

     

       
3
       
3
       
-
       
  lib,

     

       
3
       
3
       
+
       
  nix-gitignore,

     

       
4
       
4
       
 
       
  python3Packages,

     

       
5
       
5
       
 
       
}:

     

       
6
       
6
       
 
       
let

     

       
7
       
7
       
-
       
  inherit (lib) fileset;

     

       
8
       
7
       
 
       
  helpers = callPackage ./helpers.nix { };

     

       
9
       
8
       
 
       
  pythonPackages = python3Packages;

     

       
9
       
9
       
+
       


     

       
10
       
10
       
 
       
in

     

       
11
       
11
       
 
       
pythonPackages.buildPythonApplication {

     

       
12
       
12
       
 
       
  version = "0.1.0";

     

       
13
       
13
       
 
       
  pname = "flatten-references-graph";

     

       
14
       
14
       
 
       


     

       
15
       
15
       
-
       
  src = fileset.toSource {

     

       
16
       
16
       
-
       
    root = ./src;

     

       
17
       
17
       
-
       
    fileset = fileset.unions [

     

       
18
       
18
       
-
       
      ./src/.flake8

     

       
19
       
19
       
-
       
      ./src/flatten_references_graph

     

       
20
       
20
       
-
       
      ./src/setup.py

     

       
21
       
21
       
-
       
    ];

     

       
22
       
22
       
-
       
  };

     

       
15
       
15
       
+
       
  # Note: this uses only ./src/.gitignore

     

       
16
       
16
       
+
       
  src = nix-gitignore.gitignoreSource [ ] ./src;

     

       
23
       
17
       
 
       


     

       
24
       
18
       
 
       
  propagatedBuildInputs = with pythonPackages; [

     

       
25
       
19
       
 
       
    igraph

     

···

       
14
       
14
       
 
       
To update this package

     

       
15
       
15
       
 
       
======================

     

       
16
       
16
       
 
       


     

       
17
       
17
       
-
       
#. Bump the ``./package.json`` version pin

     

       
18
       
18
       
-
       
#. Run ``nix-shell -p nodejs --command "npm i --package-lock-only"``

     

       
17
       
17
       
+
       
#. Bump the ``./manifests/package.json`` version pin

     

       
18
       
18
       
+
       
#. Run ``(cd manifests && nix-shell -p nodejs --command "npm i --package-lock-only")``

     

       
19
       
19
       
 
       
#. Update ``npmDeps.hash`` in the ``package.nix``

     

···

       
8
       
8
       
 
       
let

     

       
9
       
9
       
 
       
  inherit (lib) fileset;

     

       
10
       
10
       
 
       


     

       
11
       
11
       
-
       
  packageLock = builtins.fromJSON (builtins.readFile ./package-lock.json);

     

       
11
       
11
       
+
       
  packageLock = builtins.fromJSON (builtins.readFile ./manifests/package-lock.json);

     

       
12
       
12
       
 
       


     

       
13
       
13
       
 
       
  pname = "purescm";

     

       
14
       
14
       
 
       
  version = packageLock.packages."node_modules/${pname}".version;

     
···

       
16
       
16
       
 
       
  package = buildNpmPackage {

     

       
17
       
17
       
 
       
    inherit pname version;

     

       
18
       
18
       
 
       


     

       
19
       
19
       
-
       
    src = fileset.toSource {

     

       
20
       
20
       
-
       
      root = ./.;

     

       
21
       
21
       
-
       
      fileset = fileset.unions [

     

       
22
       
22
       
-
       
        ./package.json

     

       
23
       
23
       
-
       
        ./package-lock.json

     

       
24
       
24
       
-
       
        ./.gitignore

     

       
25
       
25
       
-
       
      ];

     

       
26
       
26
       
-
       
    };

     

       
19
       
19
       
+
       
    src = ./manifests;

     

       
27
       
20
       
 
       
    dontNpmBuild = true;

     

       
28
       
21
       
 
       


     

       
29
       
22
       
 
       
    npmDeps = fetchNpmDeps {

     

       
30
       
30
       
-
       
      src = fileset.toSource {

     

       
31
       
31
       
-
       
        root = ./.;

     

       
32
       
32
       
-
       
        fileset = fileset.unions [

     

       
33
       
33
       
-
       
          ./package-lock.json

     

       
34
       
34
       
-
       
          ./package.json

     

       
35
       
35
       
-
       
        ];

     

       
36
       
36
       
-
       
      };

     

       
23
       
23
       
+
       
      src = ./manifests;

     

       
37
       
24
       
 
       
      hash = "sha256-ljeFcLvIET77Q0OR6O5Ok1fGnaxaKaoywpcy2aHq/6o=";

     

       
38
       
25
       
 
       
    };

     

       
39
       
26
       
 
       


     

···

       
6
       
6
       
 
       
  pname = "shopify";

     

       
7
       
7
       
 
       
  version = version;

     

       
8
       
8
       
 
       


     

       
9
       
9
       
-
       
  src = lib.fileset.toSource {

     

       
10
       
10
       
-
       
    root = ./.;

     

       
11
       
11
       
-
       
    fileset = with lib.fileset; unions [

     

       
12
       
12
       
-
       
      ./package.json

     

       
13
       
13
       
-
       
      ./package-lock.json

     

       
14
       
14
       
-
       
    ];

     

       
15
       
15
       
-
       
  };

     

       
9
       
9
       
+
       
  src = ./manifests;

     

       
16
       
10
       
 
       


     

       
17
       
11
       
 
       
  npmDepsHash = "sha256-QhbOKOs/0GEOeySG4uROzgtD4o7C+6tS/TAaPcmC3xk=";

     

       
18
       
12
       
 
       
  dontNpmBuild = true;

     

···

       
18
       
18
       
 
       
    exit 0

     

       
19
       
19
       
 
       
fi

     

       
20
       
20
       
 
       


     

       
21
       
21
       
+
       
pushd manifests

     

       
22
       
22
       
+
       


     

       
21
       
23
       
 
       
# Update the package.json

     

       
22
       
24
       
 
       
sed -i "s|$UPDATE_NIX_OLD_VERSION|$version|g" package.json

     

       
23
       
25
       
 
       


     
···

       
25
       
27
       
 
       
rm -f package-lock.json

     

       
26
       
28
       
 
       
npm i --package-lock-only

     

       
27
       
29
       
 
       
npm_hash=$(prefetch-npm-deps package-lock.json)

     

       
30
       
30
       
+
       


     

       
31
       
31
       
+
       
popd

     

       
32
       
32
       
+
       


     

       
28
       
33
       
 
       
sed -i "s|npmDepsHash = \".*\";|npmDepsHash = \"$npm_hash\";|" package.nix

     

       
29
       
34
       
 
       


     

       
30
       
35
       
 
       
popd

     

···

       
18
       
18
       
 
       
    libcublas

     

       
19
       
19
       
 
       
    ;

     

       
20
       
20
       
 
       
  inherit (lib) getDev getLib getOutput;

     

       
21
       
21
       
-
       
  fs = lib.fileset;

     

       
22
       
21
       
 
       
in

     

       
23
       
22
       
 
       
backendStdenv.mkDerivation {

     

       
24
       
23
       
 
       
  pname = "saxpy";

     

       
25
       
24
       
 
       
  version = "unstable-2023-07-11";

     

       
26
       
25
       
 
       


     

       
27
       
27
       
-
       
  src = fs.toSource {

     

       
28
       
28
       
-
       
    root = ./.;

     

       
29
       
29
       
-
       
    fileset = fs.unions [

     

       
30
       
30
       
-
       
      ./CMakeLists.txt

     

       
31
       
31
       
-
       
      ./saxpy.cu

     

       
32
       
32
       
-
       
    ];

     

       
33
       
33
       
-
       
  };

     

       
26
       
26
       
+
       
  src = ./src;

     

       
34
       
27
       
 
       


     

       
35
       
28
       
 
       
  __structuredAttrs = true;

     

       
36
       
29
       
 
       
  strictDeps = true;

     

···

       
6
       
6
       
 
       
  waitress,

     

       
7
       
7
       
 
       
}:

     

       
8
       
8
       
 
       


     

       
9
       
9
       
-
       
let

     

       
10
       
10
       
-
       
  fs = lib.fileset;

     

       
11
       
11
       
-
       
in

     

       
12
       
12
       
-
       


     

       
13
       
9
       
 
       
buildPythonPackage {

     

       
14
       
10
       
 
       
  pname = "waitress-django";

     

       
15
       
11
       
 
       
  version = "1.0.0";

     

       
16
       
12
       
 
       
  pyproject = true;

     

       
17
       
13
       
 
       


     

       
18
       
18
       
-
       
  src = fs.toSource {

     

       
19
       
19
       
-
       
    root = ./.;

     

       
20
       
20
       
-
       
    fileset = fs.unions [

     

       
21
       
21
       
-
       
      ./setup.py

     

       
22
       
22
       
-
       
      ./src

     

       
23
       
23
       
-
       
    ];

     

       
24
       
24
       
-
       
  };

     

       
14
       
14
       
+
       
  src = ./src;

     

       
25
       
15
       
 
       


     

       
26
       
16
       
 
       
  build-system = [ setuptools ];

     

       
27
       
17
       
 
       


     

···

       
7
       
7
       
 
       
     , description  = "A waitress WSGI server serving django"

     

       
8
       
8
       
 
       
     , author       = "Bas van Dijk"

     

       
9
       
9
       
 
       
     , author_email = "v.dijk.bas@gmail.com"

     

       
10
       
10
       
-
       
     , package_dir  = {"" : "src"}

     

       
11
       
11
       
-
       
     , scripts      = ["src/waitress-serve-django"]

     

       
10
       
10
       
+
       
     , scripts      = ["waitress-serve-django"]

     

       
12
       
11
       
 
       
     )

     

···

       
398
       
398
       
 
       
    });

     

       
399
       
399
       
 
       


     

       
400
       
400
       
 
       
  yarn2nix = mkYarnPackage {

     

       
401
       
401
       
-
       
    src = lib.fileset.toSource {

     

       
402
       
402
       
-
       
      root = ./.;

     

       
403
       
403
       
-
       
      fileset = lib.fileset.unions [

     

       
404
       
404
       
-
       
        ./bin

     

       
405
       
405
       
-
       
        ./lib

     

       
406
       
406
       
-
       
        ./package.json

     

       
407
       
407
       
-
       
        ./yarn.lock

     

       
408
       
408
       
-
       
      ];

     

       
409
       
409
       
-
       
    };

     

       
401
       
401
       
+
       
    src = ./yarn2nix;

     

       
410
       
402
       
 
       


     

       
411
       
403
       
 
       
    # yarn2nix is the only package that requires the yarnNix option.

     

       
412
       
404
       
 
       
    # All the other projects can auto-generate that file.

     
···

       
415
       
407
       
 
       
    # Using the filter above and importing package.json from the filtered

     

       
416
       
408
       
 
       
    # source results in an error in restricted mode. To circumvent this,

     

       
417
       
409
       
 
       
    # we import package.json from the unfiltered source

     

       
418
       
418
       
-
       
    packageJSON = ./package.json;

     

       
410
       
410
       
+
       
    packageJSON = ./yarn2nix/package.json;

     

       
419
       
411
       
 
       


     

       
420
       
412
       
 
       
    yarnFlags = defaultYarnFlags ++ [ "--ignore-scripts" "--production=true" ];

     

       
421
       
413
       
 
       


     
···

       
446
       
438
       
 
       
    mkdir -p $out/lib

     

       
447
       
439
       
 
       
    mkdir -p $out/bin

     

       
448
       
440
       
 
       


     

       
449
       
449
       
-
       
    cp ${./lib/urlToName.js} $out/lib/urlToName.js

     

       
441
       
441
       
+
       
    cp ${./yarn2nix/lib/urlToName.js} $out/lib/urlToName.js

     

       
450
       
442
       
 
       
    cp ${./internal/fixup_yarn_lock.js} $out/bin/fixup_yarn_lock

     

       
451
       
443
       
 
       


     

       
452
       
444
       
 
       
    patchShebangs $out

     

···

       
6
       
6
       
 
       
}:

     

       
7
       
7
       
 
       


     

       
8
       
8
       
 
       
let

     

       
9
       
9
       
-
       
  src = lib.fileset.toSource {

     

       
10
       
10
       
-
       
    root = ./local;

     

       
11
       
11
       
-
       
    fileset = lib.fileset.unions [

     

       
12
       
12
       
-
       
      ./local/app

     

       
13
       
13
       
-
       
      ./local/CHANGELOG.md

     

       
14
       
14
       
-
       
      ./local/local.cabal

     

       
15
       
15
       
-
       
    ];

     

       
16
       
16
       
-
       
  };

     

       
17
       
17
       
-
       
  # This prevents the source from depending on the formatting of the ./local/generated.nix file

     

       
18
       
18
       
-
       
  localRaw = haskell.lib.compose.overrideSrc {

     

       
19
       
19
       
-
       
    inherit src;

     

       
20
       
20
       
-
       
  } (haskellPackages.callPackage ./local/generated.nix { });

     

       
9
       
9
       
+
       
  localRaw = haskellPackages.callPackage ./generated.nix { };

     

       
21
       
10
       
 
       
in

     

       
22
       
11
       
 
       
lib.recurseIntoAttrs rec {

     

       
23
       
12
       
 
       


     
···

       
28
       
17
       
 
       


     

       
29
       
18
       
 
       
  localFromCabalSdist = haskellPackages.buildFromCabalSdist localRaw;

     

       
30
       
19
       
 
       


     

       
31
       
31
       
-
       
  # NOTE: ./local refers to the "./." path in `./local/generated.nix`.

     

       
32
       
20
       
 
       
  # This test makes sure that localHasNoDirectReference can actually fail if

     

       
33
       
21
       
 
       
  # it doesn't do anything. If this test fails, either the test setup was broken,

     

       
34
       
22
       
 
       
  # or Haskell packaging has changed the way `src` is treated in such a way that

     
···

       
39
       
27
       
 
       
        drvPath = builtins.unsafeDiscardOutputDependency localRaw.drvPath;

     

       
40
       
28
       
 
       
      }

     

       
41
       
29
       
 
       
      ''

     

       
42
       
42
       
-
       
        grep ${src} $drvPath >/dev/null

     

       
30
       
30
       
+
       
        grep ${localRaw.src} $drvPath >/dev/null

     

       
43
       
31
       
 
       
        touch $out

     

       
44
       
32
       
 
       
      '';

     

       
45
       
33
       
 
       


     
···

       
49
       
37
       
 
       
        drvPath = builtins.unsafeDiscardOutputDependency localFromCabalSdist.drvPath;

     

       
50
       
38
       
 
       
      }

     

       
51
       
39
       
 
       
      ''

     

       
52
       
52
       
-
       
        grep -v ${src} $drvPath >/dev/null

     

       
40
       
40
       
+
       
        grep -v ${localRaw.src} $drvPath >/dev/null

     

       
53
       
41
       
 
       
        touch $out

     

       
54
       
42
       
 
       
      '';

     

       
55
       
43
       
 
       
}

     

···

       
1
       
1
       
-
       
# nix run ../../../../..#cabal2nix -- ./.

     

       
1
       
1
       
+
       
# nix run ../../../../..#cabal2nix -- ./local

     

       
2
       
2
       
 
       
{

     

       
3
       
3
       
 
       
  mkDerivation,

     

       
4
       
4
       
 
       
  base,

     
···

       
7
       
7
       
 
       
mkDerivation {

     

       
8
       
8
       
 
       
  pname = "local";

     

       
9
       
9
       
 
       
  version = "0.1.0.0";

     

       
10
       
10
       
-
       
  src = ./.; # also referred to as ./local in the test; these are the same path constants

     

       
10
       
10
       
+
       
  src = ./local;

     

       
11
       
11
       
 
       
  isLibrary = false;

     

       
12
       
12
       
 
       
  isExecutable = true;

     

       
13
       
13
       
 
       
  executableHaskellDepends = [ base ];

     

       
14
       
14
       
 
       
  description = "Nixpkgs test case";

     

       
15
       
15
       
 
       
  license = lib.licenses.mit;

     

       
16
       
16
       
+
       
  mainProgram = "local";

     

       
16
       
17
       
 
       
}

     

···

       
1
       
1
       
 
       
{ pkgs, haskellPackages }:

     

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
let

     

       
4
       
4
       
-
       
  # This can be regenerated by running `cabal2nix .` in the current directory.

     

       
4
       
4
       
+
       
  # This can be regenerated by running `cabal2nix ./src` in the current directory.

     

       
5
       
5
       
 
       
  pkgDef =

     

       
6
       
6
       
 
       
    {

     

       
7
       
7
       
 
       
      mkDerivation,

     
···

       
11
       
11
       
 
       
    mkDerivation {

     

       
12
       
12
       
 
       
      pname = "haskell-setBuildTarget";

     

       
13
       
13
       
 
       
      version = "0.1.0.0";

     

       
14
       
14
       
-
       
      src = lib.fileset.toSource {

     

       
15
       
15
       
-
       
        root = ./.;

     

       
16
       
16
       
-
       
        fileset = lib.fileset.unions [

     

       
17
       
17
       
-
       
          ./haskell-setBuildTarget.cabal

     

       
18
       
18
       
-
       
          ./Bar.hs

     

       
19
       
19
       
-
       
          ./Foo.hs

     

       
20
       
20
       
-
       
          ./Setup.hs

     

       
21
       
21
       
-
       
        ];

     

       
22
       
22
       
-
       
      };

     

       
14
       
14
       
+
       
      src = ./src;

     

       
23
       
15
       
 
       
      isLibrary = false;

     

       
24
       
16
       
 
       
      isExecutable = true;

     

       
25
       
17
       
 
       
      executableHaskellDepends = [ base ];

     

       
26
       
26
       
-
       
      license = lib.licenses.bsd3;

     

       
18
       
18
       
+
       
      license = "unknown";

     

       
27
       
19
       
 
       
    };

     

       
28
       
20
       
 
       


     

       
29
       
21
       
 
       
  drv = haskellPackages.callPackage pkgDef { };

     

···

       
20
       
20
       
 
       
    runCommand "make-binary-wrapper-test-${testname}" env ''

     

       
21
       
21
       
 
       
      mkdir -p tmp/foo # for the chdir test

     

       
22
       
22
       
 
       


     

       
23
       
23
       
-
       
      source=${

     

       
24
       
24
       
-
       
        lib.fileset.toSource {

     

       
25
       
25
       
-
       
          root = ./.;

     

       
26
       
26
       
-
       
          fileset = lib.fileset.unions [

     

       
27
       
27
       
-
       
            (./. + "/${testname}.cmdline")

     

       
28
       
28
       
-
       
            (./. + "/${testname}.c")

     

       
29
       
29
       
-
       
            (lib.fileset.maybeMissing (./. + "/${testname}.env"))

     

       
30
       
30
       
-
       
          ];

     

       
31
       
31
       
-
       
        }

     

       
32
       
32
       
-
       
      }

     

       
23
       
23
       
+
       
      source=${./${testname}}

     

       
33
       
24
       
 
       


     

       
34
       
25
       
 
       
      params=$(<"$source/${testname}.cmdline")

     

       
35
       
26
       
 
       
      eval "makeCWrapper /send/me/flags $params" > wrapper.c

     

···

       
5667
       
5667
       
 
       


     

       
5668
       
5668
       
 
       
  yarn-berry = callPackage ../development/tools/yarn-berry { };

     

       
5669
       
5669
       
 
       


     

       
5670
       
5670
       
-
       
  yarn2nix-moretea = callPackage ../development/tools/yarn2nix-moretea/yarn2nix { pkgs = pkgs.__splicedPackages; };

     

       
5670
       
5670
       
+
       
  yarn2nix-moretea = callPackage ../development/tools/yarn2nix-moretea { pkgs = pkgs.__splicedPackages; };

     

       
5671
       
5671
       
 
       


     

       
5672
       
5672
       
 
       
  inherit (yarn2nix-moretea)

     

       
5673
       
5673
       
 
       
    yarn2nix

     

···

       
27
       
27
       
 
       
, # Allow a configuration attribute set to be passed in as an argument.

     

       
28
       
28
       
 
       
  config ? {}

     

       
29
       
29
       
 
       


     

       
30
       
30
       
+
       
, # Temporary hack to let Nixpkgs forbid internal use of `lib.fileset`

     

       
31
       
31
       
+
       
  # until <https://github.com/NixOS/nix/issues/11503> is fixed.

     

       
32
       
32
       
+
       
  __allowFileset ? true

     

       
33
       
33
       
+
       


     

       
30
       
34
       
 
       
, # List of overlays layers used to extend Nixpkgs.

     

       
31
       
35
       
 
       
  overlays ? []

     

       
32
       
36
       
 
       


     
···

       
47
       
51
       
 
       
  crossSystem0 = crossSystem;

     

       
48
       
52
       
 
       


     

       
49
       
53
       
 
       
in let

     

       
50
       
50
       
-
       
  lib = import ../../lib;

     

       
54
       
54
       
+
       
  pristineLib = import ../../lib;

     

       
55
       
55
       
+
       


     

       
56
       
56
       
+
       
  lib =

     

       
57
       
57
       
+
       
    if __allowFileset then

     

       
58
       
58
       
+
       
      pristineLib

     

       
59
       
59
       
+
       
    else

     

       
60
       
60
       
+
       
      pristineLib.extend (_: _: {

     

       
61
       
61
       
+
       
        fileset = abort ''

     

       
62
       
62
       
+
       


     

       
63
       
63
       
+
       
          The use of `lib.fileset` is currently forbidden in Nixpkgs due to the

     

       
64
       
64
       
+
       
          upstream Nix bug <https://github.com/NixOS/nix/issues/11503>. This

     

       
65
       
65
       
+
       
          causes difficult‐to‐debug errors when combined with chroot stores,

     

       
66
       
66
       
+
       
          such as in the NixOS installer.

     

       
67
       
67
       
+
       


     

       
68
       
68
       
+
       
          For packages that require source to be vendored inside Nixpkgs,

     

       
69
       
69
       
+
       
          please use a subdirectory of the package instead.

     

       
70
       
70
       
+
       
        '';

     

       
71
       
71
       
+
       
      });

     

       
51
       
72
       
 
       


     

       
52
       
73
       
 
       
  inherit (lib) throwIfNot;

     

       
53
       
74
       
 
       


     

···

       
17
       
17
       
 
       
, # Strip most of attributes when evaluating to spare memory usage

     

       
18
       
18
       
 
       
  scrubJobs ? true

     

       
19
       
19
       
 
       
, # Attributes passed to nixpkgs. Don't build packages marked as unfree.

     

       
20
       
20
       
-
       
  nixpkgsArgs ? { config = { allowUnfree = false; inHydra = true; }; }

     

       
20
       
20
       
+
       
  nixpkgsArgs ? {

     

       
21
       
21
       
+
       
    config = { allowUnfree = false; inHydra = true; };

     

       
22
       
22
       
+
       
    __allowFileset = false;

     

       
23
       
23
       
+
       
  }

     

       
21
       
24
       
 
       
}:

     

       
22
       
25
       
 
       


     

       
23
       
26
       
 
       
let

     

···

       
43
       
43
       
 
       
      "${variant}Support" = true;

     

       
44
       
44
       
 
       
      inHydra = true;

     

       
45
       
45
       
 
       
    };

     

       
46
       
46
       
+
       


     

       
47
       
47
       
+
       
    __allowFileset = false;

     

       
46
       
48
       
 
       
  },

     

       
47
       
49
       
 
       
  ...

     

       
48
       
50
       
 
       
}@args:

     

···

       
3
       
3
       
 
       
, packageSet ? (import ../..)

     

       
4
       
4
       
 
       
, scrubJobs ? true

     

       
5
       
5
       
 
       
, # Attributes passed to nixpkgs. Don't build packages marked as unfree.

     

       
6
       
6
       
-
       
  nixpkgsArgs ? { config = { allowUnfree = false; inHydra = true; }; }

     

       
6
       
6
       
+
       
  nixpkgsArgs ? {

     

       
7
       
7
       
+
       
    config = { allowUnfree = false; inHydra = true; };

     

       
8
       
8
       
+
       
    __allowFileset = false;

     

       
9
       
9
       
+
       
  }

     

       
7
       
10
       
 
       
}:

     

       
8
       
11
       
 
       


     

       
9
       
12
       
 
       
let

     

···

       
57
       
57
       
 
       


     

       
58
       
58
       
 
       
            inHydra = true;

     

       
59
       
59
       
 
       
          };

     

       
60
       
60
       
+
       


     

       
61
       
61
       
+
       
          __allowFileset = false;

     

       
60
       
62
       
 
       
        };

     

       
61
       
63
       
 
       
      };

     

       
62
       
64
       
 
       
  recurseIntoAttrs = attrs: attrs // { recurseForDerivations = true; };

     

···

       
15
       
15
       
 
       
      allowUnfree = false;

     

       
16
       
16
       
 
       
      inHydra = true;

     

       
17
       
17
       
 
       
    };

     

       
18
       
18
       
+
       


     

       
19
       
19
       
+
       
    __allowFileset = false;

     

       
18
       
20
       
 
       
  },

     

       
19
       
21
       
 
       
}:

     

       
20
       
22
       
 
       


     

···

       
19
       
19
       
 
       
      allowUnfree = false;

     

       
20
       
20
       
 
       
      inHydra = true;

     

       
21
       
21
       
 
       
    };

     

       
22
       
22
       
+
       


     

       
23
       
23
       
+
       
    __allowFileset = false;

     

       
22
       
24
       
 
       
  },

     

       
23
       
25
       
 
       
}:

     

       
24
       
26
       
 
       


     

···

       
37
       
37
       
 
       
      cudaSupport = true;

     

       
38
       
38
       
 
       
      inHydra = true;

     

       
39
       
39
       
 
       
    };

     

       
40
       
40
       
+
       


     

       
41
       
41
       
+
       
    __allowFileset = false;

     

       
40
       
42
       
 
       
  },

     

       
41
       
43
       
 
       
  # We only build the full package set on infrequently releasing channels.

     

       
42
       
44
       
 
       
  full ? false,

     

···

       
28
       
28
       
 
       
  # Strip most of attributes when evaluating to spare memory usage

     

       
29
       
29
       
 
       
, scrubJobs ? true

     

       
30
       
30
       
 
       
  # Attributes passed to nixpkgs. Don't build packages marked as unfree.

     

       
31
       
31
       
-
       
, nixpkgsArgs ? { config = {

     

       
32
       
32
       
-
       
    allowUnfree = false;

     

       
33
       
33
       
-
       
    inHydra = true;

     

       
34
       
34
       
-
       
    # Exceptional unsafe packages that we still build and distribute,

     

       
35
       
35
       
-
       
    # so users choosing to allow don't have to rebuild them every time.

     

       
36
       
36
       
-
       
    permittedInsecurePackages = [

     

       
37
       
37
       
-
       
      "olm-3.2.16" # see PR #347899

     

       
38
       
38
       
-
       
      "kanidm_1_3-1.3.3"

     

       
39
       
39
       
-
       
    ];

     

       
40
       
40
       
-
       
  }; }

     

       
31
       
31
       
+
       
, nixpkgsArgs ? {

     

       
32
       
32
       
+
       
    config = {

     

       
33
       
33
       
+
       
      allowUnfree = false;

     

       
34
       
34
       
+
       
      inHydra = true;

     

       
35
       
35
       
+
       
      # Exceptional unsafe packages that we still build and distribute,

     

       
36
       
36
       
+
       
      # so users choosing to allow don't have to rebuild them every time.

     

       
37
       
37
       
+
       
      permittedInsecurePackages = [

     

       
38
       
38
       
+
       
        "olm-3.2.16" # see PR #347899

     

       
39
       
39
       
+
       
        "kanidm_1_3-1.3.3"

     

       
40
       
40
       
+
       
      ];

     

       
41
       
41
       
+
       
    };

     

       
42
       
42
       
+
       


     

       
43
       
43
       
+
       
    __allowFileset = false;

     

       
44
       
44
       
+
       
  }

     

       
41
       
45
       
 
       


     

       
42
       
46
       
 
       
  # This flag, if set to true, will inhibit the use of `mapTestOn`

     

       
43
       
47
       
 
       
  # and `release-lib.packagePlatforms`.  Generally, it causes the