···

       
37
       
37
       
 
       
  * Not start with the package name.

     

       
38
       
38
       
 
       
  * Not have a period at the end.

     

       
39
       
39
       
 
       
* `meta.license` must be set and fit the upstream license.

     

       
40
       
40
       
-
       
  * If there is no upstream license, `meta.license` should default to `stdenv.lib.licenses.unfree`.

     

       
40
       
40
       
+
       
  * If there is no upstream license, `meta.license` should default to `lib.licenses.unfree`.

     

       
41
       
41
       
 
       
* `meta.maintainers` must be set.

     

       
42
       
42
       
 
       


     

       
43
       
43
       
 
       
See the nixpkgs manual for more details on [standard meta-attributes](https://nixos.org/nixpkgs/manual/#sec-standard-meta-attributes) and on how to [submit changes to nixpkgs](https://nixos.org/nixpkgs/manual/#chap-submitting-changes).

     

···

       
1
       
1
       
 
       
import ./make-test-python.nix ({ pkgs, ... }: {

     

       
2
       
2
       
 
       
  name = "usbguard";

     

       
3
       
3
       
-
       
  meta = with pkgs.stdenv.lib.maintainers; {

     

       
3
       
3
       
+
       
  meta = with pkgs.lib.maintainers; {

     

       
4
       
4
       
 
       
    maintainers = [ tnias ];

     

       
5
       
5
       
 
       
  };

     

       
6
       
6
       
 
       


     

···

       
1
       
1
       
-
       
{ stdenv, fetchFromGitHub, fetchpatch

     

       
1
       
1
       
+
       
{ lib, stdenv, fetchFromGitHub, fetchpatch

     

       
2
       
2
       
 
       
, cmake, halide

     

       
3
       
3
       
 
       
, libpng, libjpeg, libtiff, libraw

     

       
4
       
4
       
 
       
}:

     
···

       
32
       
32
       
 
       
    done

     

       
33
       
33
       
 
       
  '';

     

       
34
       
34
       
 
       


     

       
35
       
35
       
-
       
  meta = with stdenv.lib; {

     

       
35
       
35
       
+
       
  meta = with lib; {

     

       
36
       
36
       
 
       
    description = "Burst photography pipeline based on Google's HDR+";

     

       
37
       
37
       
 
       
    homepage = "https://www.timothybrooks.com/tech/hdr-plus/";

     

       
38
       
38
       
 
       
    license = licenses.mit;

     

···

       
38
       
38
       
 
       
  passthru.updateScript = writeScript "${pname}-updater" ''

     

       
39
       
39
       
 
       
    #!${stdenv.shell}

     

       
40
       
40
       
 
       
    set -eu -o pipefail

     

       
41
       
41
       
-
       
    PATH=${stdenv.lib.makeBinPath [curl pup common-updater-scripts]}:$PATH

     

       
41
       
41
       
+
       
    PATH=${lib.makeBinPath [curl pup common-updater-scripts]}:$PATH

     

       
42
       
42
       
 
       
    latestVersion="$(curl -sS https://www.rescuetime.com/release-notes/linux | pup '.release:first-of-type h2 strong text{}' | tr -d '\n')"

     

       
43
       
43
       
 
       


     

       
44
       
44
       
-
       
    for platform in ${stdenv.lib.concatStringsSep " " meta.platforms}; do

     

       
44
       
44
       
+
       
    for platform in ${lib.concatStringsSep " " meta.platforms}; do

     

       
45
       
45
       
 
       
      # The script will not perform an update when the version attribute is up to date from previous platform run

     

       
46
       
46
       
 
       
      # We need to clear it before each run

     

       
47
       
47
       
 
       
      update-source-version ${pname} 0 $(yes 0 | head -64 | tr -d "\n") --system=$platform

     

···

       
1
       
1
       
-
       
{ stdenv, fetchurl, hamlib, pkg-config, qt5, qtbase, qttools, qtserialport, qtcharts, qmake, wrapQtAppsHook }:

     

       
1
       
1
       
+
       
{ lib, stdenv, fetchurl, hamlib, pkg-config, qt5, qtbase, qttools, qtserialport, qtcharts, qmake, wrapQtAppsHook }:

     

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
stdenv.mkDerivation rec {

     

       
4
       
4
       
 
       
  pname = "klog";

     
···

       
14
       
14
       
 
       


     

       
15
       
15
       
 
       
  qmakeFlags = [ "KLog.pro" ];

     

       
16
       
16
       
 
       


     

       
17
       
17
       
-
       
  meta = with stdenv.lib; {

     

       
17
       
17
       
+
       
  meta = with lib; {

     

       
18
       
18
       
 
       
    description = "A multiplatform free hamradio logger";

     

       
19
       
19
       
 
       
    longDescription = ''

     

       
20
       
20
       
 
       
      KLog provides QSO management, useful QSL management DX-Cluster client, DXCC management,

     

···

       
1
       
1
       
-
       
{ gccStdenv, fetchurl, zlib, mpi }:

     

       
1
       
1
       
+
       
{ lib, gccStdenv, fetchurl, zlib, mpi }:

     

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
gccStdenv.mkDerivation rec {

     

       
4
       
4
       
 
       
  version = "3.7.2";

     
···

       
14
       
14
       
 
       
  buildFlags = [ "thread" "mpis" ];

     

       
15
       
15
       
 
       
  preInstall = "mkdir -p $out/man/man1";

     

       
16
       
16
       
 
       


     

       
17
       
17
       
-
       
  meta = with gccStdenv.lib; {

     

       
17
       
17
       
+
       
  meta = with lib; {

     

       
18
       
18
       
 
       
    description = "Estimates population size, migration, population splitting parameters using genetic/genomic data";

     

       
19
       
19
       
 
       
    homepage = "https://peterbeerli.com/migrate-html5/index.html";

     

       
20
       
20
       
 
       
    license = licenses.mit;

     

···

       
132
       
132
       
 
       
Cflags: -I$dev/include

     

       
133
       
133
       
 
       
Libs: -L$out/lib -lcblas

     

       
134
       
134
       
 
       
EOF

     

       
135
       
135
       
-
       
'' + stdenv.lib.optionalString (blasImplementation == "mkl") ''

     

       
135
       
135
       
+
       
'' + lib.optionalString (blasImplementation == "mkl") ''

     

       
136
       
136
       
 
       
  mkdir -p $out/nix-support

     

       
137
       
137
       
 
       
  echo 'export MKL_INTERFACE_LAYER=${lib.optionalString isILP64 "I"}LP64,GNU' > $out/nix-support/setup-hook

     

       
138
       
138
       
 
       
  ln -s $out/lib/libblas${canonicalExtension} $out/lib/libmkl_rt${stdenv.hostPlatform.extensions.sharedLibrary}

     

···

       
98
       
98
       
 
       
Cflags: -I$dev/include

     

       
99
       
99
       
 
       
Libs: -L$out/lib -llapacke

     

       
100
       
100
       
 
       
EOF

     

       
101
       
101
       
-
       
'' + stdenv.lib.optionalString (lapackImplementation == "mkl") ''

     

       
101
       
101
       
+
       
'' + lib.optionalString (lapackImplementation == "mkl") ''

     

       
102
       
102
       
 
       
  mkdir -p $out/nix-support

     

       
103
       
103
       
 
       
  echo 'export MKL_INTERFACE_LAYER=${lib.optionalString isILP64 "I"}LP64,GNU' > $out/nix-support/setup-hook

     

       
104
       
104
       
 
       
  ln -s $out/lib/liblapack${canonicalExtension} $out/lib/libmkl_rt${stdenv.hostPlatform.extensions.sharedLibrary}

     

···

       
1
       
1
       
-
       
{ stdenv

     

       
1
       
1
       
+
       
{ lib

     

       
2
       
2
       
+
       
, stdenv

     

       
2
       
3
       
 
       
, bash

     

       
3
       
4
       
 
       
, binutils-unwrapped

     

       
4
       
5
       
 
       
, coreutils

     
···

       
15
       
16
       
 
       
    src = ./appimage-exec.sh;

     

       
16
       
17
       
 
       
    isExecutable = true;

     

       
17
       
18
       
 
       
    dir = "bin";

     

       
18
       
18
       
-
       
    path = with pkgs; stdenv.lib.makeBinPath [

     

       
19
       
19
       
+
       
    path = lib.makeBinPath [

     

       
19
       
20
       
 
       
      bash

     

       
20
       
21
       
 
       
      binutils-unwrapped

     

       
21
       
22
       
 
       
      coreutils

     

···

       
94
       
94
       
 
       
      inherit imageDigest;

     

       
95
       
95
       
 
       
      imageName = finalImageName;

     

       
96
       
96
       
 
       
      imageTag = finalImageTag;

     

       
97
       
97
       
-
       
      impureEnvVars = stdenv.lib.fetchers.proxyImpureEnvVars;

     

       
97
       
97
       
+
       
      impureEnvVars = lib.fetchers.proxyImpureEnvVars;

     

       
98
       
98
       
 
       
      outputHashMode = "flat";

     

       
99
       
99
       
 
       
      outputHashAlgo = "sha256";

     

       
100
       
100
       
 
       
      outputHash = sha256;

     

···

       
1
       
1
       
-
       
{ stdenv, makeWrapper, nix, skopeo, jq }:

     

       
2
       
2
       
-
       


     

       
3
       
3
       
-
       
with stdenv.lib;

     

       
1
       
1
       
+
       
{ lib, stdenv, makeWrapper, nix, skopeo, jq }:

     

       
4
       
2
       
 
       


     

       
5
       
3
       
 
       
stdenv.mkDerivation {

     

       
6
       
4
       
 
       
  name = "nix-prefetch-docker";

     
···

       
12
       
10
       
 
       
  installPhase = ''

     

       
13
       
11
       
 
       
    install -vD ${./nix-prefetch-docker} $out/bin/$name;

     

       
14
       
12
       
 
       
    wrapProgram $out/bin/$name \

     

       
15
       
15
       
-
       
      --prefix PATH : ${makeBinPath [ nix skopeo jq ]} \

     

       
13
       
13
       
+
       
      --prefix PATH : ${lib.makeBinPath [ nix skopeo jq ]} \

     

       
16
       
14
       
 
       
      --set HOME /homeless-shelter

     

       
17
       
15
       
 
       
  '';

     

       
18
       
16
       
 
       


     

       
19
       
17
       
 
       
  preferLocalBuild = true;

     

       
20
       
18
       
 
       


     

       
21
       
21
       
-
       
  meta = {

     

       
19
       
19
       
+
       
  meta = with lib; {

     

       
22
       
20
       
 
       
    description = "Script used to obtain source hashes for dockerTools.pullImage";

     

       
23
       
21
       
 
       
    maintainers = with maintainers; [ offline ];

     

       
24
       
22
       
 
       
    platforms = platforms.unix;

     

···

       
1
       
1
       
-
       
{stdenv, dotnetfx}:

     

       
1
       
1
       
+
       
{ lib, stdenv, dotnetfx }:

     

       
2
       
2
       
 
       
{ name

     

       
3
       
3
       
 
       
, src

     

       
4
       
4
       
 
       
, baseDir ? "."

     
···

       
24
       
24
       
 
       
  '';

     

       
25
       
25
       
 
       


     

       
26
       
26
       
 
       
  preBuild = ''

     

       
27
       
27
       
-
       
    ${stdenv.lib.optionalString modifyPublicMain ''

     

       
27
       
27
       
+
       
    ${lib.optionalString modifyPublicMain ''

     

       
28
       
28
       
 
       
      sed -i -e "s|static void Main|public static void Main|" ${mainClassFile}

     

       
29
       
29
       
 
       
    ''}

     

       
30
       
30
       
 
       
    ${preBuild}

     

···

       
1
       
1
       
-
       
{stdenv, dotnetfx}:

     

       
1
       
1
       
+
       
{ lib, stdenv, dotnetfx }:

     

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
let dotnetenv =

     

       
4
       
4
       
 
       
{

     

       
5
       
5
       
 
       
  buildSolution = import ./build-solution.nix {

     

       
6
       
6
       
-
       
    inherit stdenv;

     

       
6
       
6
       
+
       
    inherit lib stdenv;

     

       
7
       
7
       
 
       
    dotnetfx = dotnetfx.pkg;

     

       
8
       
8
       
 
       
  };

     

       
9
       
9
       
 
       


     

···

       
1
       
1
       
 
       
# Adaptation of the MIT-licensed work on `sbt2nix` done by Charles O'Farrell

     

       
2
       
2
       
 
       


     

       
3
       
3
       
-
       
{ fetchurl, stdenv }:

     

       
3
       
3
       
+
       
{ lib, fetchurl, stdenv }:

     

       
4
       
4
       
 
       
let

     

       
5
       
5
       
 
       
  defaultRepos = [

     

       
6
       
6
       
 
       
    "https://repo1.maven.org/maven2"

     
···

       
36
       
36
       
 
       
# if repos is empty, then url or urls must be specified.

     

       
37
       
37
       
 
       
assert (repos != []) || (url != "") || (urls != []);

     

       
38
       
38
       
 
       


     

       
39
       
39
       
-
       


     

       
40
       
39
       
 
       
let

     

       
41
       
40
       
 
       
  name_ =

     

       
42
       
42
       
-
       
    with stdenv.lib; concatStrings [

     

       
43
       
43
       
-
       
      (replaceChars ["."] ["_"] groupId) "_"

     

       
44
       
44
       
-
       
      (replaceChars ["."] ["_"] artifactId) "-"

     

       
41
       
41
       
+
       
    lib.concatStrings [

     

       
42
       
42
       
+
       
      (lib.replaceChars ["."] ["_"] groupId) "_"

     

       
43
       
43
       
+
       
      (lib.replaceChars ["."] ["_"] artifactId) "-"

     

       
45
       
44
       
 
       
      version

     

       
46
       
45
       
 
       
    ];

     

       
47
       
46
       
 
       
  mkJarUrl = repoUrl:

     

       
48
       
48
       
-
       
    with stdenv.lib; concatStringsSep "/" [

     

       
49
       
49
       
-
       
      (removeSuffix "/" repoUrl)

     

       
50
       
50
       
-
       
      (replaceChars ["."] ["/"] groupId)

     

       
47
       
47
       
+
       
    lib.concatStringsSep "/" [

     

       
48
       
48
       
+
       
      (lib.removeSuffix "/" repoUrl)

     

       
49
       
49
       
+
       
      (lib.replaceChars ["."] ["/"] groupId)

     

       
51
       
50
       
 
       
      artifactId

     

       
52
       
51
       
 
       
      version

     

       
53
       
53
       
-
       
      "${artifactId}-${version}${optionalString (!isNull classifier) "-${classifier}"}.jar"

     

       
52
       
52
       
+
       
      "${artifactId}-${version}${lib.optionalString (!isNull classifier) "-${classifier}"}.jar"

     

       
54
       
53
       
 
       
    ];

     

       
55
       
54
       
 
       
  urls_ =

     

       
56
       
55
       
 
       
    if url != "" then [url]

     

···

       
1
       
1
       
-
       
{ stdenv, icoutils }:

     

       
1
       
1
       
+
       
{ lib, stdenv, icoutils }:

     

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
stdenv.mkDerivation {

     

       
4
       
4
       
 
       
  name = "icon-conv-tools-0.0.0";

     
···

       
23
       
23
       
 
       
  dontPatchELF = true;

     

       
24
       
24
       
 
       
  dontStrip = true;

     

       
25
       
25
       
 
       


     

       
26
       
26
       
-
       
  meta = {

     

       
26
       
26
       
+
       
  meta = with lib; {

     

       
27
       
27
       
 
       
    description = "Tools for icon conversion specific to nix package manager";

     

       
28
       
28
       
-
       
    maintainers = with stdenv.lib.maintainers; [ jraygauthier ];

     

       
29
       
29
       
-
       
    platforms = with stdenv.lib.platforms; linux;

     

       
28
       
28
       
+
       
    maintainers = with maintainers; [ jraygauthier ];

     

       
29
       
29
       
+
       
    platforms = platforms.linux;

     

       
30
       
30
       
 
       
  };

     

       
31
       
31
       
 
       
}

     

···

       
46
       
46
       
 
       
    )

     

       
47
       
47
       
 
       
  '';

     

       
48
       
48
       
 
       


     

       
49
       
49
       
-
       
  meta = {

     

       
50
       
50
       
-
       
    platforms = stdenv.lib.platforms.unix;

     

       
49
       
49
       
+
       
  meta = with lib; {

     

       
50
       
50
       
+
       
    platforms = platforms.unix;

     

       
51
       
51
       
 
       
    description = "An LD_PRELOAD library to intercept and rewrite the paths in glibc calls";

     

       
52
       
52
       
 
       
    longDescription = ''

     

       
53
       
53
       
 
       
      libredirect is an LD_PRELOAD library to intercept and rewrite the paths in

     

···

       
1
       
1
       
-
       
{ stdenv, writeText, ocaml, findlib, ocamlbuild, camlp4 }:

     

       
1
       
1
       
+
       
{ lib, stdenv, writeText, ocaml, findlib, ocamlbuild, camlp4 }:

     

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
{ name, version, buildInputs ? [],

     

       
4
       
4
       
 
       
  createFindlibDestdir ?  true,

     
···

       
14
       
14
       
 
       
  };

     

       
15
       
15
       
 
       
in

     

       
16
       
16
       
 
       
  assert minimumSupportedOcamlVersion != null ->

     

       
17
       
17
       
-
       
          stdenv.lib.versionOlder minimumSupportedOcamlVersion ocaml.version;

     

       
17
       
17
       
+
       
          lib.versionOlder minimumSupportedOcamlVersion ocaml.version;

     

       
18
       
18
       
 
       


     

       
19
       
19
       
 
       
stdenv.mkDerivation (args // {

     

       
20
       
20
       
 
       
  name = "ocaml-${name}-${version}";

     

···

       
1
       
1
       
-
       
{ stdenv, ocaml, findlib, dune, dune_2 }:

     

       
1
       
1
       
+
       
{ lib, stdenv, ocaml, findlib, dune, dune_2 }:

     

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
{ pname, version, buildInputs ? [], enableParallelBuilding ? true, ... }@args:

     

       
4
       
4
       
 
       


     

       
5
       
5
       
 
       
let Dune = if args.useDune2 or false then dune_2 else dune; in

     

       
6
       
6
       
 
       


     

       
7
       
7
       
 
       
if args ? minimumOCamlVersion &&

     

       
8
       
8
       
-
       
   ! stdenv.lib.versionAtLeast ocaml.version args.minimumOCamlVersion

     

       
8
       
8
       
+
       
   ! lib.versionAtLeast ocaml.version args.minimumOCamlVersion

     

       
9
       
9
       
 
       
then throw "${pname}-${version} is not available for OCaml ${ocaml.version}"

     

       
10
       
10
       
 
       
else

     

       
11
       
11
       
 
       


     

···

       
1
       
1
       
-
       
{ stdenv, ocaml_oasis, ocaml, findlib, ocamlbuild }:

     

       
1
       
1
       
+
       
{ lib, stdenv, ocaml_oasis, ocaml, findlib, ocamlbuild }:

     

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
{ pname, version, buildInputs ? [], meta ? { platforms = ocaml.meta.platforms or []; },

     

       
4
       
4
       
 
       
  minimumOCamlVersion ? null,

     
···

       
8
       
8
       
 
       
}@args:

     

       
9
       
9
       
 
       


     

       
10
       
10
       
 
       
if args ? minimumOCamlVersion &&

     

       
11
       
11
       
-
       
   ! stdenv.lib.versionAtLeast ocaml.version args.minimumOCamlVersion

     

       
11
       
11
       
+
       
   ! lib.versionAtLeast ocaml.version args.minimumOCamlVersion

     

       
12
       
12
       
 
       
then throw "${pname}-${version} is not available for OCaml ${ocaml.version}"

     

       
13
       
13
       
 
       
else

     

       
14
       
14
       
 
       


     

···

       
2
       
2
       
 
       
# PKG_CONFIG_PATH_FOR_BUILD work properly.

     

       
3
       
3
       
 
       


     

       
4
       
4
       
 
       
{ stdenvNoCC

     

       
5
       
5
       
+
       
, lib

     

       
5
       
6
       
 
       
, buildPackages

     

       
6
       
7
       
 
       
, pkg-config

     

       
7
       
8
       
 
       
, baseBinName ? "pkg-config"

     
···

       
19
       
20
       
 
       
  #

     

       
20
       
21
       
 
       
  # TODO(@Ericson2314) Make unconditional, or optional but always true by

     

       
21
       
22
       
 
       
  # default.

     

       
22
       
22
       
-
       
  targetPrefix = stdenv.lib.optionalString (targetPlatform != hostPlatform)

     

       
23
       
23
       
+
       
  targetPrefix = lib.optionalString (targetPlatform != hostPlatform)

     

       
23
       
24
       
 
       
                                        (targetPlatform.config + "-");

     

       
24
       
25
       
 
       


     

       
25
       
26
       
 
       
  # See description in cc-wrapper.

     
···

       
119
       
120
       
 
       
    let pkg-config_ = if pkg-config != null then pkg-config else {}; in

     

       
120
       
121
       
 
       
    (if pkg-config_ ? meta then removeAttrs pkg-config.meta ["priority"] else {}) //

     

       
121
       
122
       
 
       
    { description =

     

       
122
       
122
       
-
       
        stdenv.lib.attrByPath ["meta" "description"] "pkg-config" pkg-config_

     

       
123
       
123
       
+
       
        lib.attrByPath ["meta" "description"] "pkg-config" pkg-config_

     

       
123
       
124
       
 
       
        + " (wrapper script)";

     

       
124
       
125
       
 
       
      priority = 10;

     

       
125
       
126
       
 
       
  };

     

···

       
1
       
1
       
-
       
{ stdenv }:

     

       
1
       
1
       
+
       
{ lib, stdenv }:

     

       
2
       
2
       
 
       
# helper functions for packaging programs with plugin systems

     

       
3
       
3
       
 
       
{

     

       
4
       
4
       
 
       


     
···

       
13
       
13
       
 
       
  diffPlugins = expectedPlugins: foundPluginsFilePath: ''

     

       
14
       
14
       
 
       
     # sort both lists first

     

       
15
       
15
       
 
       
     plugins_expected=$(mktemp)

     

       
16
       
16
       
-
       
     (${stdenv.lib.concatMapStrings (s: "echo \"${s}\";") expectedPlugins}) \

     

       
16
       
16
       
+
       
     (${lib.concatMapStrings (s: "echo \"${s}\";") expectedPlugins}) \

     

       
17
       
17
       
 
       
       | sort -u > "$plugins_expected"

     

       
18
       
18
       
 
       
     plugins_found=$(mktemp)

     

       
19
       
19
       
 
       
     sort -u "${foundPluginsFilePath}" > "$plugins_found"

     

···

       
2
       
2
       
 
       
# that contains a Debian-like (i.e. dpkg-based) OS.

     

       
3
       
3
       
 
       


     

       
4
       
4
       
 
       
{ name ? "debian-build"

     

       
5
       
5
       
+
       
, lib

     

       
5
       
6
       
 
       
, diskImage

     

       
6
       
7
       
 
       
, src, stdenv, vmTools, checkinstall

     

       
7
       
8
       
 
       
, fsTranslation ? false

     
···

       
10
       
11
       
 
       
, # Features required by this package.

     

       
11
       
12
       
 
       
  debRequires ? []

     

       
12
       
13
       
 
       
, ... } @ args:

     

       
13
       
13
       
-
       


     

       
14
       
14
       
-
       
with stdenv.lib;

     

       
15
       
14
       
 
       


     

       
16
       
15
       
 
       
vmTools.runInLinuxImage (stdenv.mkDerivation (

     

       
17
       
16
       
 
       


     
···

       
59
       
58
       
 
       
      export PAGER=cat

     

       
60
       
59
       
 
       
      ${checkinstall}/sbin/checkinstall --nodoc -y -D \

     

       
61
       
60
       
 
       
        --fstrans=${if fsTranslation then "yes" else "no"} \

     

       
62
       
62
       
-
       
        --requires="${concatStringsSep "," debRequires}" \

     

       
63
       
63
       
-
       
        --provides="${concatStringsSep "," debProvides}" \

     

       
61
       
61
       
+
       
        --requires="${lib.concatStringsSep "," debRequires}" \

     

       
62
       
62
       
+
       
        --provides="${lib.concatStringsSep "," debProvides}" \

     

       
64
       
63
       
 
       
        ${if (src ? version) then "--pkgversion=$(echo ${src.version} | tr _ -)"

     

       
65
       
64
       
 
       
                             else "--pkgversion=0.0.0"} \

     

       
66
       
65
       
 
       
        ''${debMaintainer:+--maintainer="'$debMaintainer'"} \

     

···

       
1
       
1
       
-
       
{ pkgs }:

     

       
1
       
1
       
+
       
{ lib, pkgs }:

     

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
with pkgs;

     

       
4
       
4
       
 
       


     
···

       
23
       
23
       
 
       
    } // args);

     

       
24
       
24
       
 
       


     

       
25
       
25
       
 
       
  nixBuild = args: import ./nix-build.nix (

     

       
26
       
26
       
-
       
    { inherit stdenv;

     

       
26
       
26
       
+
       
    { inherit lib stdenv;

     

       
27
       
27
       
 
       
    } // args);

     

       
28
       
28
       
 
       


     

       
29
       
29
       
 
       
  coverageAnalysis = args: nixBuild (

     
···

       
46
       
46
       
 
       
    } // args);

     

       
47
       
47
       
 
       


     

       
48
       
48
       
 
       
  debBuild = args: import ./debian-build.nix (

     

       
49
       
49
       
-
       
    { inherit stdenv vmTools checkinstall;

     

       
49
       
49
       
+
       
    { inherit lib stdenv vmTools checkinstall;

     

       
50
       
50
       
 
       
    } // args);

     

       
51
       
51
       
 
       


     

       
52
       
52
       
 
       
  aggregate =

     
···

       
94
       
94
       
 
       


     

       
95
       
95
       
 
       
      phases = [ "unpackPhase" "patchPhase" "installPhase" ];

     

       
96
       
96
       
 
       


     

       
97
       
97
       
-
       
      patchPhase = stdenv.lib.optionalString isNixOS ''

     

       
97
       
97
       
+
       
      patchPhase = lib.optionalString isNixOS ''

     

       
98
       
98
       
 
       
        touch .update-on-nixos-rebuild

     

       
99
       
99
       
 
       
      '';

     

       
100
       
100
       
 
       


     

···

       
12
       
12
       
 
       
, doCoverityAnalysis ? false

     

       
13
       
13
       
 
       
, lcovFilter ? []

     

       
14
       
14
       
 
       
, lcovExtraTraceFiles ? []

     

       
15
       
15
       
-
       
, src, stdenv

     

       
15
       
15
       
+
       
, src, lib, stdenv

     

       
16
       
16
       
 
       
, name ? if doCoverageAnalysis then "nix-coverage" else "nix-build"

     

       
17
       
17
       
 
       
, failureHook ? null

     

       
18
       
18
       
 
       
, prePhases ? []

     
···

       
69
       
69
       
 
       
        fi

     

       
70
       
70
       
 
       
      '';

     

       
71
       
71
       
 
       


     

       
72
       
72
       
-
       
    failureHook = (stdenv.lib.optionalString (failureHook != null) failureHook) +

     

       
72
       
72
       
+
       
    failureHook = (lib.optionalString (failureHook != null) failureHook) +

     

       
73
       
73
       
 
       
    ''

     

       
74
       
74
       
 
       
      if test -n "$succeedOnFailure"; then

     

       
75
       
75
       
 
       
          if test -n "$keepBuildDirectory"; then

     
···

       
136
       
136
       
 
       


     

       
137
       
137
       
 
       
    buildInputs =

     

       
138
       
138
       
 
       
      buildInputs ++

     

       
139
       
139
       
-
       
      (stdenv.lib.optional doCoverageAnalysis args.makeGCOVReport) ++

     

       
140
       
140
       
-
       
      (stdenv.lib.optional doClangAnalysis args.clang-analyzer) ++

     

       
141
       
141
       
-
       
      (stdenv.lib.optional doCoverityAnalysis args.cov-build) ++

     

       
142
       
142
       
-
       
      (stdenv.lib.optional doCoverityAnalysis args.xz);

     

       
139
       
139
       
+
       
      (lib.optional doCoverageAnalysis args.makeGCOVReport) ++

     

       
140
       
140
       
+
       
      (lib.optional doClangAnalysis args.clang-analyzer) ++

     

       
141
       
141
       
+
       
      (lib.optional doCoverityAnalysis args.cov-build) ++

     

       
142
       
142
       
+
       
      (lib.optional doCoverityAnalysis args.xz);

     

       
143
       
143
       
 
       


     

       
144
       
144
       
 
       
    lcovFilter = ["/nix/store/*"] ++ lcovFilter;

     

       
145
       
145
       
 
       


     

···

       
1
       
1
       
-
       
{ stdenv, pkg-config, curl, darwin, libiconv, libgit2, libssh2,

     

       
1
       
1
       
+
       
{ lib, stdenv, pkg-config, curl, darwin, libiconv, libgit2, libssh2,

     

       
2
       
2
       
 
       
  openssl, sqlite, zlib, dbus, dbus-glib, gdk-pixbuf, cairo, python3,

     

       
3
       
3
       
 
       
  libsodium, postgresql, gmp, foundationdb, capnproto, nettle, clang,

     

       
4
       
4
       
 
       
  llvmPackages, ... }:

     
···

       
17
       
17
       
 
       


     

       
18
       
18
       
 
       
  cargo = attrs: {

     

       
19
       
19
       
 
       
    buildInputs = [ openssl zlib curl ]

     

       
20
       
20
       
-
       
      ++ stdenv.lib.optionals stdenv.isDarwin [ CoreFoundation Security libiconv ];

     

       
20
       
20
       
+
       
      ++ lib.optionals stdenv.isDarwin [ CoreFoundation Security libiconv ];

     

       
21
       
21
       
 
       
  };

     

       
22
       
22
       
 
       


     

       
23
       
23
       
 
       
  libz-sys = attrs: {

     
···

       
149
       
149
       
 
       
  };

     

       
150
       
150
       
 
       


     

       
151
       
151
       
 
       
  serde_derive = attrs: {

     

       
152
       
152
       
-
       
    buildInputs = stdenv.lib.optional stdenv.isDarwin Security;

     

       
152
       
152
       
+
       
    buildInputs = lib.optional stdenv.isDarwin Security;

     

       
153
       
153
       
 
       
  };

     

       
154
       
154
       
 
       


     

       
155
       
155
       
 
       
  thrussh-libsodium = attrs: {

     

···

       
1
       
1
       
 
       
{ stdenv

     

       
2
       
2
       
+
       
, lib

     

       
2
       
3
       
 
       
, buildPackages

     

       
3
       
4
       
 
       
, cacert

     

       
4
       
5
       
 
       
, cargo

     
···

       
83
       
84
       
 
       
      cargoDepsCopy="$sourceRoot/${cargoVendorDir}"

     

       
84
       
85
       
 
       
    '';

     

       
85
       
86
       
 
       


     

       
86
       
86
       
-
       
  targetIsJSON = stdenv.lib.hasSuffix ".json" target;

     

       
87
       
87
       
+
       
  targetIsJSON = lib.hasSuffix ".json" target;

     

       
87
       
88
       
 
       
  useSysroot = targetIsJSON && !__internal_dontAddSysroot;

     

       
88
       
89
       
 
       


     

       
89
       
90
       
 
       
  # see https://github.com/rust-lang/cargo/blob/964a16a28e234a3d397b2a7031d4ab4a428b1391/src/cargo/core/compiler/compile_kind.rs#L151-L168

     

       
90
       
91
       
 
       
  # the "${}" is needed to transform the path into a /nix/store path before baseNameOf

     

       
91
       
92
       
 
       
  shortTarget = if targetIsJSON then

     

       
92
       
92
       
-
       
      (stdenv.lib.removeSuffix ".json" (builtins.baseNameOf "${target}"))

     

       
93
       
93
       
+
       
      (lib.removeSuffix ".json" (builtins.baseNameOf "${target}"))

     

       
93
       
94
       
 
       
    else target;

     

       
94
       
95
       
 
       


     

       
95
       
96
       
 
       
  sysroot = (callPackage ./sysroot {}) {

     
···

       
116
       
117
       
 
       
# See https://os.phil-opp.com/testing/ for more information.

     

       
117
       
118
       
 
       
assert useSysroot -> !(args.doCheck or true);

     

       
118
       
119
       
 
       


     

       
119
       
119
       
-
       
stdenv.mkDerivation ((removeAttrs args ["depsExtraArgs"]) // stdenv.lib.optionalAttrs useSysroot {

     

       
120
       
120
       
+
       
stdenv.mkDerivation ((removeAttrs args ["depsExtraArgs"]) // lib.optionalAttrs useSysroot {

     

       
120
       
121
       
 
       
  RUSTFLAGS = "--sysroot ${sysroot} " + (args.RUSTFLAGS or "");

     

       
121
       
122
       
 
       
} // {

     

       
122
       
123
       
 
       
  inherit cargoDeps;

     
···

       
124
       
125
       
 
       
  patchRegistryDeps = ./patch-registry-deps;

     

       
125
       
126
       
 
       


     

       
126
       
127
       
 
       
  nativeBuildInputs = nativeBuildInputs ++ [ cacert git cargo rustc ];

     

       
127
       
127
       
-
       
  buildInputs = buildInputs ++ stdenv.lib.optional stdenv.hostPlatform.isMinGW windows.pthreads;

     

       
128
       
128
       
+
       
  buildInputs = buildInputs ++ lib.optional stdenv.hostPlatform.isMinGW windows.pthreads;

     

       
128
       
129
       
 
       


     

       
129
       
130
       
 
       
  patches = cargoPatches ++ patches;

     

       
130
       
131
       
 
       


     
···

       
147
       
148
       
 
       
    cat >> .cargo/config <<'EOF'

     

       
148
       
149
       
 
       
    [target."${rust.toRustTarget stdenv.buildPlatform}"]

     

       
149
       
150
       
 
       
    "linker" = "${ccForBuild}"

     

       
150
       
150
       
-
       
    ${stdenv.lib.optionalString (stdenv.buildPlatform.config != stdenv.hostPlatform.config) ''

     

       
151
       
151
       
+
       
    ${lib.optionalString (stdenv.buildPlatform.config != stdenv.hostPlatform.config) ''

     

       
151
       
152
       
 
       
    [target."${shortTarget}"]

     

       
152
       
153
       
 
       
    "linker" = "${ccForHost}"

     

       
153
       
154
       
 
       
    ${# https://github.com/rust-lang/rust/issues/46651#issuecomment-433611633

     

       
154
       
154
       
-
       
      stdenv.lib.optionalString (stdenv.hostPlatform.isMusl && stdenv.hostPlatform.isAarch64) ''

     

       
155
       
155
       
+
       
      lib.optionalString (stdenv.hostPlatform.isMusl && stdenv.hostPlatform.isAarch64) ''

     

       
155
       
156
       
 
       
    "rustflags" = [ "-C", "target-feature=+crt-static", "-C", "link-arg=-lgcc" ]

     

       
156
       
157
       
 
       
    ''}

     

       
157
       
158
       
 
       
    ''}

     
···

       
163
       
164
       
 
       
  # After unpacking and applying patches, check that the Cargo.lock matches our

     

       
164
       
165
       
 
       
  # src package. Note that we do this after the patchPhase, because the

     

       
165
       
166
       
 
       
  # patchPhase may create the Cargo.lock if upstream has not shipped one.

     

       
166
       
166
       
-
       
  postPatch = (args.postPatch or "") + stdenv.lib.optionalString validateCargoDeps ''

     

       
167
       
167
       
+
       
  postPatch = (args.postPatch or "") + lib.optionalString validateCargoDeps ''

     

       
167
       
168
       
 
       
    cargoDepsLockfile=$NIX_BUILD_TOP/$cargoDepsCopy/Cargo.lock

     

       
168
       
169
       
 
       
    srcLockfile=$NIX_BUILD_TOP/$sourceRoot/Cargo.lock

     

       
169
       
170
       
 
       


     
···

       
206
       
207
       
 
       
  '';

     

       
207
       
208
       
 
       


     

       
208
       
209
       
 
       
  buildPhase = with builtins; args.buildPhase or ''

     

       
209
       
209
       
-
       
    ${stdenv.lib.optionalString (buildAndTestSubdir != null) "pushd ${buildAndTestSubdir}"}

     

       
210
       
210
       
+
       
    ${lib.optionalString (buildAndTestSubdir != null) "pushd ${buildAndTestSubdir}"}

     

       
210
       
211
       
 
       
    runHook preBuild

     

       
211
       
212
       
 
       


     

       
212
       
213
       
 
       
    (

     
···

       
217
       
218
       
 
       
      "CC_${rust.toRustTarget stdenv.hostPlatform}"="${ccForHost}" \

     

       
218
       
219
       
 
       
      "CXX_${rust.toRustTarget stdenv.hostPlatform}"="${cxxForHost}" \

     

       
219
       
220
       
 
       
      cargo build -j $NIX_BUILD_CORES \

     

       
220
       
220
       
-
       
        ${stdenv.lib.optionalString (buildType == "release") "--release"} \

     

       
221
       
221
       
+
       
        ${lib.optionalString (buildType == "release") "--release"} \

     

       
221
       
222
       
 
       
        --target ${target} \

     

       
222
       
223
       
 
       
        --frozen ${concatStringsSep " " cargoBuildFlags}

     

       
223
       
224
       
 
       
    )

     

       
224
       
225
       
 
       


     

       
225
       
226
       
 
       
    runHook postBuild

     

       
226
       
227
       
 
       


     

       
227
       
227
       
-
       
    ${stdenv.lib.optionalString (buildAndTestSubdir != null) "popd"}

     

       
228
       
228
       
+
       
    ${lib.optionalString (buildAndTestSubdir != null) "popd"}

     

       
228
       
229
       
 
       


     

       
229
       
230
       
 
       
    # This needs to be done after postBuild: packages like `cargo` do a pushd/popd in

     

       
230
       
231
       
 
       
    # the pre/postBuild-hooks that need to be taken into account before gathering

     
···

       
238
       
239
       
 
       
  '';

     

       
239
       
240
       
 
       


     

       
240
       
241
       
 
       
  checkPhase = args.checkPhase or (let

     

       
241
       
241
       
-
       
    argstr = "${stdenv.lib.optionalString (checkType == "release") "--release"} --target ${target} --frozen";

     

       
242
       
242
       
+
       
    argstr = "${lib.optionalString (checkType == "release") "--release"} --target ${target} --frozen";

     

       
242
       
243
       
 
       
    threads = if cargoParallelTestThreads then "$NIX_BUILD_CORES" else "1";

     

       
243
       
244
       
 
       
  in ''

     

       
244
       
244
       
-
       
    ${stdenv.lib.optionalString (buildAndTestSubdir != null) "pushd ${buildAndTestSubdir}"}

     

       
245
       
245
       
+
       
    ${lib.optionalString (buildAndTestSubdir != null) "pushd ${buildAndTestSubdir}"}

     

       
245
       
246
       
 
       
    runHook preCheck

     

       
246
       
247
       
 
       
    echo "Running cargo test ${argstr} -- ''${checkFlags} ''${checkFlagsArray+''${checkFlagsArray[@]}}"

     

       
247
       
248
       
 
       
    cargo test -j $NIX_BUILD_CORES ${argstr} -- --test-threads=${threads} ''${checkFlags} ''${checkFlagsArray+"''${checkFlagsArray[@]}"}

     

       
248
       
249
       
 
       
    runHook postCheck

     

       
249
       
249
       
-
       
    ${stdenv.lib.optionalString (buildAndTestSubdir != null) "popd"}

     

       
250
       
250
       
+
       
    ${lib.optionalString (buildAndTestSubdir != null) "popd"}

     

       
250
       
251
       
 
       
  '');

     

       
251
       
252
       
 
       


     

       
252
       
253
       
 
       
  doCheck = args.doCheck or true;

     

···

       
1
       
1
       
-
       
{ stdenv, cacert, git, cargo, python3 }:

     

       
1
       
1
       
+
       
{ lib, stdenv, cacert, git, cargo, python3 }:

     

       
2
       
2
       
 
       
let cargo-vendor-normalise = stdenv.mkDerivation {

     

       
3
       
3
       
 
       
  name = "cargo-vendor-normalise";

     

       
4
       
4
       
 
       
  src = ./cargo-vendor-normalise.py;

     
···

       
80
       
80
       
 
       


     

       
81
       
81
       
 
       
  inherit (hash_) outputHashAlgo outputHash;

     

       
82
       
82
       
 
       


     

       
83
       
83
       
-
       
  impureEnvVars = stdenv.lib.fetchers.proxyImpureEnvVars;

     

       
83
       
83
       
+
       
  impureEnvVars = lib.fetchers.proxyImpureEnvVars;

     

       
84
       
84
       
 
       
} // (builtins.removeAttrs args [

     

       
85
       
85
       
 
       
  "name" "sha256" "cargoUpdateHook"

     

       
86
       
86
       
 
       
]))

     

···

       
1
       
1
       
 
       
{ runCommand

     

       
2
       
2
       
+
       
, lib

     

       
2
       
3
       
 
       
, stdenv

     

       
3
       
4
       
 
       
, storeDir ? builtins.storeDir

     

       
4
       
5
       
 
       
, writeScript

     
···

       
64
       
65
       
 
       
            mkdir proc sys dev

     

       
65
       
66
       
 
       


     

       
66
       
67
       
 
       
            # Run root script

     

       
67
       
67
       
-
       
            ${stdenv.lib.optionalString (runAsRoot != null) ''

     

       
68
       
68
       
+
       
            ${lib.optionalString (runAsRoot != null) ''

     

       
68
       
69
       
 
       
              mkdir -p ./${storeDir}

     

       
69
       
70
       
 
       
              mount --rbind ${storeDir} ./${storeDir}

     

       
70
       
71
       
 
       
              unshare -imnpuf --mount-proc chroot ./ ${runAsRootFile}

     

···

       
1
       
1
       
-
       
{ stdenv, cleanPackaging, fetchurl }:

     

       
2
       
2
       
-
       
let lib = stdenv.lib;

     

       
3
       
3
       
-
       
in {

     

       
1
       
1
       
+
       
{ lib, stdenv, cleanPackaging, fetchurl }:

     

       
2
       
2
       
+
       
{

     

       
4
       
3
       
 
       
  # : string

     

       
5
       
4
       
 
       
  pname

     

       
6
       
5
       
 
       
  # : string

     
···

       
98
       
97
       
 
       
  meta = {

     

       
99
       
98
       
 
       
    homepage = "https://skarnet.org/software/${pname}/";

     

       
100
       
99
       
 
       
    inherit description platforms;

     

       
101
       
101
       
-
       
    license = stdenv.lib.licenses.isc;

     

       
100
       
100
       
+
       
    license = lib.licenses.isc;

     

       
102
       
101
       
 
       
    maintainers = with lib.maintainers;

     

       
103
       
102
       
 
       
      [ pmahoney Profpatsch ] ++ maintainers;

     

       
104
       
103
       
 
       
  };

     

···

       
3
       
3
       
 
       
# files were either discarded or moved to outputs.

     

       
4
       
4
       
 
       
# This ensures nothing is forgotten and new files

     

       
5
       
5
       
 
       
# are correctly handled on update.

     

       
6
       
6
       
-
       
{ stdenv, file, writeScript }:

     

       
6
       
6
       
+
       
{ lib, stdenv, file, writeScript }:

     

       
7
       
7
       
 
       


     

       
8
       
8
       
 
       
let

     

       
9
       
9
       
-
       
  globWith = stdenv.lib.concatMapStringsSep "\n";

     

       
9
       
9
       
+
       
  globWith = lib.concatMapStringsSep "\n";

     

       
10
       
10
       
 
       
  rmNoise = noiseGlobs: globWith (f:

     

       
11
       
11
       
 
       
    ''rm -rf ${f}'') noiseGlobs;

     

       
12
       
12
       
 
       
  mvDoc = docGlobs: globWith

     

···

       
1
       
1
       
-
       
{ stdenv }:

     

       
1
       
1
       
+
       
{ lib, stdenv }:

     

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
args:

     

       
4
       
4
       
 
       


     

       
5
       
5
       
 
       
stdenv.mkDerivation ({

     

       
6
       
6
       
 
       
  name = if args ? name then args.name else baseNameOf (toString args.src);

     

       
7
       
7
       
-
       
  builder = with stdenv.lib; builtins.toFile "builder.sh" ''

     

       
7
       
7
       
+
       
  builder = builtins.toFile "builder.sh" ''

     

       
8
       
8
       
 
       
    source $stdenv/setup

     

       
9
       
9
       
 
       
    set -o pipefail

     

       
10
       
10
       
 
       


     
···

       
13
       
13
       
 
       
    args=

     

       
14
       
14
       
 
       


     

       
15
       
15
       
 
       
    pushd "$src"

     

       
16
       
16
       
-
       
    echo -ne "${concatStringsSep "\\0" args.files}" | xargs -0 -n1 -I {} -- find {} -type f -print0 | while read -d "" line; do

     

       
16
       
16
       
+
       
    echo -ne "${lib.concatStringsSep "\\0" args.files}" | xargs -0 -n1 -I {} -- find {} -type f -print0 | while read -d "" line; do

     

       
17
       
17
       
 
       
      mkdir -p "$out/$(dirname "$line")"

     

       
18
       
18
       
 
       
      substituteAll "$line" "$out/$line"

     

       
19
       
19
       
 
       
    done

     

···

       
18
       
18
       
 
       
  meta = with lib; {

     

       
19
       
19
       
 
       
    description = "Create templates of nix expressions from RPM .spec files";

     

       
20
       
20
       
 
       
    maintainers = with maintainers; [ tstrobel ];

     

       
21
       
21
       
-
       
    platforms = with stdenv.lib.platforms; unix;

     

       
21
       
21
       
+
       
    platforms = platforms.unix;

     

       
22
       
22
       
 
       
    hydraPlatforms = [];

     

       
23
       
23
       
 
       
  };

     

       
24
       
24
       
 
       
}

     

···

       
1
       
1
       
-
       
{ pkgs

     

       
1
       
1
       
+
       
{ lib

     

       
2
       
2
       
+
       
, pkgs

     

       
2
       
3
       
 
       
, kernel ? pkgs.linux

     

       
3
       
4
       
 
       
, img ? pkgs.stdenv.hostPlatform.linux-kernel.target

     

       
4
       
5
       
 
       
, storeDir ? builtins.storeDir

     
···

       
572
       
573
       
 
       
      buildCommand = ''

     

       
573
       
574
       
 
       
        ${createRootFS}

     

       
574
       
575
       
 
       


     

       
575
       
575
       
-
       
        PATH=$PATH:${stdenv.lib.makeBinPath [ dpkg dpkg glibc lzma ]}

     

       
576
       
576
       
+
       
        PATH=$PATH:${lib.makeBinPath [ dpkg dpkg glibc lzma ]}

     

       
576
       
577
       
 
       


     

       
577
       
578
       
 
       
        # Unpack the .debs.  We do this to prevent pre-install scripts

     

       
578
       
579
       
 
       
        # (which have lots of circular dependencies) from barfing.

     

···

       
196
       
196
       
 
       


     

       
197
       
197
       
 
       
in runCommand "test-writers" {

     

       
198
       
198
       
 
       
  passthru = { inherit writeTest bin simple; };

     

       
199
       
199
       
-
       
  meta.platforms = stdenv.lib.platforms.all;

     

       
199
       
199
       
+
       
  meta.platforms = lib.platforms.all;

     

       
200
       
200
       
 
       
} ''

     

       
201
       
201
       
 
       
  ${lib.concatMapStringsSep "\n" (test: writeTest "success" "${test}/bin/test_writers") (lib.attrValues bin)}

     

       
202
       
202
       
 
       
  ${lib.concatMapStringsSep "\n" (test: writeTest "success" test) (lib.attrValues simple)}

     

···

       
1
       
1
       
-
       
{ stdenv, makeWrapper, coreutils, gnused, gnugrep, diffutils, nix, git, jq }:

     

       
1
       
1
       
+
       
{ lib, stdenv, makeWrapper, coreutils, gnused, gnugrep, diffutils, nix, git, jq }:

     

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
stdenv.mkDerivation {

     

       
4
       
4
       
 
       
  name = "common-updater-scripts";

     
···

       
12
       
12
       
 
       
    cp ${./scripts}/* $out/bin

     

       
13
       
13
       
 
       


     

       
14
       
14
       
 
       
    for f in $out/bin/*; do

     

       
15
       
15
       
-
       
      wrapProgram $f --prefix PATH : ${stdenv.lib.makeBinPath [ coreutils gnused gnugrep nix diffutils git jq ]}

     

       
15
       
15
       
+
       
      wrapProgram $f --prefix PATH : ${lib.makeBinPath [ coreutils gnused gnugrep nix diffutils git jq ]}

     

       
16
       
16
       
 
       
    done

     

       
17
       
17
       
 
       
  '';

     

       
18
       
18
       
 
       
}

     

···

       
35
       
35
       
 
       
    buildPhase = ''

     

       
36
       
36
       
 
       
      export GRADLE_USER_HOME=$(mktemp -d)

     

       
37
       
37
       
 
       
      # https://github.com/gradle/gradle/issues/4426

     

       
38
       
38
       
-
       
      ${stdenv.lib.optionalString stdenv.isDarwin "export TERM=dumb"}

     

       
38
       
38
       
+
       
      ${lib.optionalString stdenv.isDarwin "export TERM=dumb"}

     

       
39
       
39
       
 
       
      gradle --no-daemon desktop:release

     

       
40
       
40
       
 
       
    '';

     

       
41
       
41
       
 
       
    # perl code mavenizes pathes (com.squareup.okio/okio/1.13.0/a9283170b7305c8d92d25aff02a6ab7e45d06cbe/okio-1.13.0.jar -> com/squareup/okio/okio/1.13.0/okio-1.13.0.jar)

     
···

       
57
       
57
       
 
       
  buildPhase = ''

     

       
58
       
58
       
 
       
    export GRADLE_USER_HOME=$(mktemp -d)

     

       
59
       
59
       
 
       
    # https://github.com/gradle/gradle/issues/4426

     

       
60
       
60
       
-
       
    ${stdenv.lib.optionalString stdenv.isDarwin "export TERM=dumb"}

     

       
60
       
60
       
+
       
    ${lib.optionalString stdenv.isDarwin "export TERM=dumb"}

     

       
61
       
61
       
 
       
    # point to offline repo

     

       
62
       
62
       
 
       
    sed -ie "s#repositories {#repositories { maven { url '${deps}' };#g" build.gradle

     

       
63
       
63
       
 
       
    gradle --offline --no-daemon desktop:release

     

···

       
1
       
1
       
-
       
{ multiStdenv, fetchurl }:

     

       
1
       
1
       
+
       
{ lib, multiStdenv, fetchurl }:

     

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
let version = "1.7.4"; in

     

       
4
       
4
       
 
       
multiStdenv.mkDerivation {

     
···

       
16
       
16
       
 
       
    sed -e s@/bin/bash@"${multiStdenv.shell}"@g -i src/*.sh

     

       
17
       
17
       
 
       
  '';

     

       
18
       
18
       
 
       


     

       
19
       
19
       
-
       
  meta = with multiStdenv.lib; {

     

       
19
       
19
       
+
       
  meta = with lib; {

     

       
20
       
20
       
 
       
    description = "Tool for creating static Linux binaries";

     

       
21
       
21
       
 
       
    platforms = platforms.linux;

     

       
22
       
22
       
 
       
    license = licenses.gpl2;

     

···

       
1
       
1
       
-
       
{ stdenv, fetchFromGitHub }:

     

       
1
       
1
       
+
       
{ lib, stdenv, fetchFromGitHub }:

     

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
stdenv.mkDerivation rec {

     

       
4
       
4
       
 
       
  pname = "fiche";

     
···

       
17
       
17
       
 
       


     

       
18
       
18
       
 
       
  doCheck = true;

     

       
19
       
19
       
 
       


     

       
20
       
20
       
-
       
  meta = with stdenv.lib; {

     

       
20
       
20
       
+
       
  meta = with lib; {

     

       
21
       
21
       
 
       
    description = "Command line pastebin for sharing terminal output";

     

       
22
       
22
       
 
       
    longDescription = ''

     

       
23
       
23
       
 
       
      Fiche is a command line pastebin server for sharing terminal output.

     

···

       
139
       
139
       
 
       


     

       
140
       
140
       
 
       
        outputs = [ "out" "lib" "dev" "pythonsrc" ];

     

       
141
       
141
       
 
       


     

       
142
       
142
       
-
       
        meta = with gcc6Stdenv.lib; {

     

       
142
       
142
       
+
       
        meta = with lib; {

     

       
143
       
143
       
 
       
          description = "Open source, distributed, transactional key-value store";

     

       
144
       
144
       
 
       
          homepage    = "https://www.foundationdb.org";

     

       
145
       
145
       
 
       
          license     = licenses.asl20;

     

···

       
1
       
1
       
-
       
{ buildBazelPackage

     

       
1
       
1
       
+
       
{ lib

     

       
2
       
2
       
+
       
, buildBazelPackage

     

       
2
       
3
       
 
       
, fetchFromGitHub

     

       
3
       
4
       
 
       
, stdenv

     

       
4
       
5
       
 
       
, cmake

     
···

       
109
       
110
       
 
       
    "--cxxopt=-Wno-uninitialized"

     

       
110
       
111
       
 
       
  ];

     

       
111
       
112
       
 
       


     

       
112
       
112
       
-
       
  meta = with stdenv.lib; {

     

       
113
       
113
       
+
       
  meta = with lib; {

     

       
113
       
114
       
 
       
    homepage = "https://envoyproxy.io";

     

       
114
       
115
       
 
       
    description = "Cloud-native edge and service proxy";

     

       
115
       
116
       
 
       
    license = licenses.asl20;

     

···

       
1
       
1
       
-
       
{ stdenv, glibc }:

     

       
2
       
2
       
-
       
with stdenv.lib;

     

       
1
       
1
       
+
       
{ lib, stdenv, glibc }:

     

       
2
       
2
       
+
       


     

       
3
       
3
       
 
       
let

     

       
4
       
4
       
 
       
  # Sanitizers are not supported on Darwin.

     

       
5
       
5
       
 
       
  # Sanitizer headers aren't available in older libc++ stdenvs due to a bug

     

       
6
       
6
       
 
       
  sanitizersWorking = !stdenv.hostPlatform.isMusl && (

     

       
7
       
7
       
-
       
    (stdenv.cc.isClang && versionAtLeast (getVersion stdenv.cc.name) "5.0.0")

     

       
7
       
7
       
+
       
    (stdenv.cc.isClang && lib.versionAtLeast (lib.getVersion stdenv.cc.name) "5.0.0")

     

       
8
       
8
       
 
       
    || (stdenv.cc.isGNU && stdenv.isLinux)

     

       
9
       
9
       
 
       
  );

     

       
10
       
10
       
-
       
  staticLibc = optionalString (stdenv.hostPlatform.libc == "glibc") "-L ${glibc.static}/lib";

     

       
10
       
10
       
+
       
  staticLibc = lib.optionalString (stdenv.hostPlatform.libc == "glibc") "-L ${glibc.static}/lib";

     

       
11
       
11
       
 
       
in stdenv.mkDerivation {

     

       
12
       
12
       
 
       
  name = "cc-wrapper-test";

     

       
13
       
13
       
 
       


     
···

       
23
       
23
       
 
       
    $CXX -o cxx-check ${./cxx-main.cc}

     

       
24
       
24
       
 
       
    ./cxx-check

     

       
25
       
25
       
 
       


     

       
26
       
26
       
-
       
    ${optionalString (stdenv.isDarwin && stdenv.cc.isClang) ''

     

       
26
       
26
       
+
       
    ${lib.optionalString (stdenv.isDarwin && stdenv.cc.isClang) ''

     

       
27
       
27
       
 
       
      printf "checking whether compiler can build with CoreFoundation.framework... " >&2

     

       
28
       
28
       
 
       
      mkdir -p foo/lib

     

       
29
       
29
       
 
       
      $CC -framework CoreFoundation -o core-foundation-check ${./core-foundation-main.c}

     
···

       
31
       
31
       
 
       
    ''}

     

       
32
       
32
       
 
       


     

       
33
       
33
       
 
       


     

       
34
       
34
       
-
       
    ${optionalString (!stdenv.isDarwin) ''

     

       
34
       
34
       
+
       
    ${lib.optionalString (!stdenv.isDarwin) ''

     

       
35
       
35
       
 
       
      printf "checking whether compiler builds valid static C binaries... " >&2

     

       
36
       
36
       
 
       
      $CC ${staticLibc} -static -o cc-static ${./cc-main.c}

     

       
37
       
37
       
 
       
      ./cc-static

     

       
38
       
38
       
 
       
      # our glibc does not have pie enabled yet.

     

       
39
       
39
       
-
       
      ${optionalString (stdenv.hostPlatform.isMusl && stdenv.cc.isGNU) ''

     

       
39
       
39
       
+
       
      ${lib.optionalString (stdenv.hostPlatform.isMusl && stdenv.cc.isGNU) ''

     

       
40
       
40
       
 
       
        printf "checking whether compiler builds valid static pie C binaries... " >&2

     

       
41
       
41
       
 
       
        $CC ${staticLibc} -static-pie -o cc-static-pie ${./cc-main.c}

     

       
42
       
42
       
 
       
        ./cc-static-pie

     
···

       
52
       
52
       
 
       
    printf "checking whether compiler uses NIX_LDFLAGS... " >&2

     

       
53
       
53
       
 
       
    mkdir -p foo/lib

     

       
54
       
54
       
 
       
    $CC -shared \

     

       
55
       
55
       
-
       
      ${optionalString stdenv.isDarwin "-Wl,-install_name,@rpath/libfoo.dylib"} \

     

       
55
       
55
       
+
       
      ${lib.optionalString stdenv.isDarwin "-Wl,-install_name,@rpath/libfoo.dylib"} \

     

       
56
       
56
       
 
       
      -DVALUE=42 \

     

       
57
       
57
       
 
       
      -o foo/lib/libfoo${stdenv.hostPlatform.extensions.sharedLibrary} \

     

       
58
       
58
       
 
       
      ${./foo.c}

     
···

       
68
       
68
       
 
       
    $CXX -I std-include -nostdinc++ -o nostdinc-main++ ${./nostdinc-main.c}

     

       
69
       
69
       
 
       
    ./nostdinc-main++

     

       
70
       
70
       
 
       


     

       
71
       
71
       
-
       
    ${optionalString sanitizersWorking ''

     

       
71
       
71
       
+
       
    ${lib.optionalString sanitizersWorking ''

     

       
72
       
72
       
 
       
      printf "checking whether sanitizers are fully functional... ">&2

     

       
73
       
73
       
 
       
      $CC -o sanitizers -fsanitize=address,undefined ${./sanitizers.c}

     

       
74
       
74
       
 
       
      ./sanitizers

     
···

       
77
       
77
       
 
       
    touch $out

     

       
78
       
78
       
 
       
  '';

     

       
79
       
79
       
 
       


     

       
80
       
80
       
-
       
  meta.platforms = platforms.all;

     

       
80
       
80
       
+
       
  meta.platforms = lib.platforms.all;

     

       
81
       
81
       
 
       
}

     

···

       
1
       
1
       
-
       
{ stdenv }:

     

       
1
       
1
       
+
       
{ lib, stdenv }:

     

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
stdenv.mkDerivation {

     

       
4
       
4
       
 
       
  name = "cc-multilib-test";

     
···

       
33
       
33
       
 
       
    touch $out

     

       
34
       
34
       
 
       
  '';

     

       
35
       
35
       
 
       


     

       
36
       
36
       
-
       
  meta.platforms = stdenv.lib.platforms.x86_64;

     

       
36
       
36
       
+
       
  meta.platforms = lib.platforms.x86_64;

     

       
37
       
37
       
 
       
}

     

···

       
1
       
1
       
-
       
{ stdenv, runCommandLocal, recurseIntoAttrs, installShellFiles }:

     

       
1
       
1
       
+
       
{ lib, stdenv, runCommandLocal, recurseIntoAttrs, installShellFiles }:

     

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
let

     

       
4
       
4
       
 
       
  runTest = name: env: buildCommand:

     

       
5
       
5
       
 
       
    runCommandLocal "install-shell-files--${name}" ({

     

       
6
       
6
       
 
       
      nativeBuildInputs = [ installShellFiles ];

     

       
7
       
7
       
-
       
      meta.platforms = stdenv.lib.platforms.all;

     

       
7
       
7
       
+
       
      meta.platforms = lib.platforms.all;

     

       
8
       
8
       
 
       
    } // env) buildCommand;

     

       
9
       
9
       
 
       
in

     

       
10
       
10
       
 
       


     

···

       
1
       
1
       
-
       
{ stdenv }:

     

       
1
       
1
       
+
       
{ lib, stdenv }:

     

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
# This tests that libraries listed in LD_LIBRARY_PATH take precedence over those listed in RPATH.

     

       
4
       
4
       
 
       


     
···

       
84
       
84
       
 
       
    touch $out

     

       
85
       
85
       
 
       
  '';

     

       
86
       
86
       
 
       


     

       
87
       
87
       
-
       
  meta.platforms = stdenv.lib.platforms.linux;

     

       
87
       
87
       
+
       
  meta.platforms = lib.platforms.linux;

     

       
88
       
88
       
 
       
}

     

···

       
1
       
1
       
-
       
{ stdenv, runCommand }:

     

       
1
       
1
       
+
       
{ lib, stdenv, runCommand }:

     

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
let

     

       
4
       
4
       
 
       
  bad-shebang = stdenv.mkDerivation {

     
···

       
13
       
13
       
 
       
  };

     

       
14
       
14
       
 
       
in runCommand "patch-shebangs-test" {

     

       
15
       
15
       
 
       
  passthru = { inherit bad-shebang; };

     

       
16
       
16
       
-
       
  meta.platforms = stdenv.lib.platforms.all;

     

       
16
       
16
       
+
       
  meta.platforms = lib.platforms.all;

     

       
17
       
17
       
 
       
} ''

     

       
18
       
18
       
 
       
  printf "checking whether patchShebangs works properly... ">&2

     

       
19
       
19
       
 
       
  if ! grep -q '^#!/bin/sh' ${bad-shebang}/bin/test; then

     

···

       
1
       
1
       
-
       
{ stdenv }:

     

       
1
       
1
       
+
       
{ lib, stdenv }:

     

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
let

     

       
4
       
4
       
 
       
  foo = stdenv.mkDerivation {

     
···

       
12
       
12
       
 
       
      chmod +x $out/bin/foo

     

       
13
       
13
       
 
       
      cp ${./foo.c} $out/include/foo.h

     

       
14
       
14
       
 
       
      $CC -shared \

     

       
15
       
15
       
-
       
        ${stdenv.lib.optionalString stdenv.isDarwin "-Wl,-install_name,$out/lib/libfoo.dylib"} \

     

       
15
       
15
       
+
       
        ${lib.optionalString stdenv.isDarwin "-Wl,-install_name,$out/lib/libfoo.dylib"} \

     

       
16
       
16
       
 
       
        -o $out/lib/libfoo${stdenv.hostPlatform.extensions.sharedLibrary} \

     

       
17
       
17
       
 
       
        ${./foo.c}

     

       
18
       
18
       
 
       
    '';

     
···

       
30
       
30
       
 
       
      chmod +x $out/bin/bar

     

       
31
       
31
       
 
       
      cp ${./bar.c} $dev/include/bar.h

     

       
32
       
32
       
 
       
      $CC -shared \

     

       
33
       
33
       
-
       
        ${stdenv.lib.optionalString stdenv.isDarwin "-Wl,-install_name,$dev/lib/libbar.dylib"} \

     

       
33
       
33
       
+
       
        ${lib.optionalString stdenv.isDarwin "-Wl,-install_name,$dev/lib/libbar.dylib"} \

     

       
34
       
34
       
 
       
        -o $dev/lib/libbar${stdenv.hostPlatform.extensions.sharedLibrary} \

     

       
35
       
35
       
 
       
        ${./bar.c}

     

       
36
       
36
       
 
       
    '';

     
···

       
64
       
64
       
 
       
    touch $out

     

       
65
       
65
       
 
       
  '';

     

       
66
       
66
       
 
       


     

       
67
       
67
       
-
       
  meta.platforms = stdenv.lib.platforms.all;

     

       
67
       
67
       
+
       
  meta.platforms = lib.platforms.all;

     

       
68
       
68
       
 
       
}

     

···

       
1
       
1
       
-
       
{ stdenv, fetchFromGitHub, libpng, libjpeg, giflib, perl, pkg-config }:

     

       
1
       
1
       
+
       
{ lib, stdenv, fetchFromGitHub, libpng, libjpeg, giflib, perl, pkg-config }:

     

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
stdenv.mkDerivation rec {

     

       
4
       
4
       
 
       
  pname = "metapixel";

     
···

       
24
       
24
       
 
       
    cp metapixel-sizesort $out/bin/metapixel-sizesort

     

       
25
       
25
       
 
       
  '';

     

       
26
       
26
       
 
       


     

       
27
       
27
       
-
       
  meta = with stdenv.lib; {

     

       
27
       
27
       
+
       
  meta = with lib; {

     

       
28
       
28
       
 
       
    homepage = "https://github.com/schani/metapixel";

     

       
29
       
29
       
 
       
    description = "Tool for generating photomosaics";

     

       
30
       
30
       
 
       
    license = licenses.gpl2Only;

     

···

       
1
       
1
       
-
       
{ stdenv, fetchFromGitHub

     

       
1
       
1
       
+
       
{ lib, stdenv, fetchFromGitHub

     

       
2
       
2
       
 
       
, autoreconfHook, pkg-config

     

       
3
       
3
       
 
       
, liblxi, readline, lua

     

       
4
       
4
       
 
       
}:

     
···

       
18
       
18
       
 
       


     

       
19
       
19
       
 
       
  buildInputs = [ liblxi readline lua ];

     

       
20
       
20
       
 
       


     

       
21
       
21
       
-
       
  meta = with stdenv.lib; {

     

       
21
       
21
       
+
       
  meta = with lib; {

     

       
22
       
22
       
 
       
    description = "Tool for communicating with LXI compatible instruments";

     

       
23
       
23
       
 
       
    longDescription = ''

     

       
24
       
24
       
 
       
      lxi-tools is a collection of open source software tools

     

···

       
15
       
15
       
 
       
  # source-highlight uses it's own binary to generate documentation.

     

       
16
       
16
       
 
       
  # During cross-compilation, that binary was built for the target

     

       
17
       
17
       
 
       
  # platform architecture, so it can't run on the build host.

     

       
18
       
18
       
-
       
  patchPhase = stdenv.lib.optionalString (stdenv.hostPlatform != stdenv.buildPlatform) ''

     

       
18
       
18
       
+
       
  patchPhase = lib.optionalString (stdenv.hostPlatform != stdenv.buildPlatform) ''

     

       
19
       
19
       
 
       
    substituteInPlace Makefile.in --replace "src doc tests" "src tests"

     

       
20
       
20
       
 
       
  '';

     

       
21
       
21