···

       
19724
       
19724
       
 
       
    githubId = 32478597;

     

       
19725
       
19725
       
 
       
    name = "Subin Kim";

     

       
19726
       
19726
       
 
       
  };

     

       
19727
       
19727
       
+
       
  sugar700 = {

     

       
19728
       
19728
       
+
       
    email = "sugar@sylveon.social";

     

       
19729
       
19729
       
+
       
    github = "sugar700";

     

       
19730
       
19730
       
+
       
    githubId = 168804988;

     

       
19731
       
19731
       
+
       
    name = "sugar";

     

       
19732
       
19732
       
+
       
  };

     

       
19727
       
19733
       
 
       
  suhr = {

     

       
19728
       
19734
       
 
       
    email = "suhr@i2pmail.org";

     

       
19729
       
19735
       
 
       
    github = "suhr";

     

···

       
135
       
135
       
 
       
  Processes also now run as a dynamically allocated user by default instead of

     

       
136
       
136
       
 
       
  root.

     

       
137
       
137
       
 
       


     

       
138
       
138
       
+
       
- `singularity-tools` have the `storeDir` argument removed from its override interface and use `builtins.storeDir` instead.

     

       
139
       
139
       
+
       


     

       
140
       
140
       
+
       
- Two build helpers in `singularity-tools`, i.e., `mkLayer` and `shellScript`, are deprecated, as they are no longer involved in image-building. Maintainers will remove them in future releases.

     

       
141
       
141
       
+
       


     

       
138
       
142
       
 
       
- The `budgie` and `budgiePlugins` scope have been removed and their packages

     

       
139
       
143
       
 
       
  moved into the top level scope (i.e., `budgie.budgie-desktop` is now

     

       
140
       
144
       
 
       
  `budgie-desktop`)

     

···

       
57
       
57
       
 
       


     

       
58
       
58
       
 
       
      environment = {

     

       
59
       
59
       
 
       
        PRODUCTION = "true";

     

       
60
       
60
       
-
       
        ALEMBIC_CONFIG_FILE="${pkg}/config/alembic.ini";

     

       
61
       
60
       
 
       
        API_PORT = toString cfg.port;

     

       
62
       
61
       
 
       
        BASE_URL = "http://localhost:${toString cfg.port}";

     

       
63
       
62
       
 
       
        DATA_DIR = "/var/lib/mealie";

     

···

       
29
       
29
       
 
       
in

     

       
30
       
30
       
 
       
melpaBuild {

     

       
31
       
31
       
 
       
  pname = "lsp-bridge";

     

       
32
       
32
       
-
       
  version = "0-unstable-2024-07-27";

     

       
32
       
32
       
+
       
  version = "0-unstable-2024-08-06";

     

       
33
       
33
       
 
       


     

       
34
       
34
       
 
       
  src = fetchFromGitHub {

     

       
35
       
35
       
 
       
    owner = "manateelazycat";

     

       
36
       
36
       
 
       
    repo = "lsp-bridge";

     

       
37
       
37
       
-
       
    rev = "92d58ff0fb938ced513d690e0daadef74737e5d4";

     

       
38
       
38
       
-
       
    hash = "sha256-qeoKPwK3qKcvUFchaQYCCQmSlXgN+Tt2kU+lXqiUwaw=";

     

       
37
       
37
       
+
       
    rev = "49b5497243873b1bddea09a4a988e3573ed7cc3e";

     

       
38
       
38
       
+
       
    hash = "sha256-bGO5DjsetInDyGDHog5QJtAgz499kJEj52iWYIzdp5Y=";

     

       
39
       
39
       
 
       
  };

     

       
40
       
40
       
 
       


     

       
41
       
41
       
 
       
  patches = [

     

···

       
24
       
24
       
 
       
      rm "$out/bin/kak"

     

       
25
       
25
       
 
       
      makeWrapper "${kakoune}/bin/kak" "$out/bin/kak" \

     

       
26
       
26
       
 
       
        --set KAKOUNE_RUNTIME "$out/share/kak" \

     

       
27
       
27
       
-
       
        --set PATH "$PATH:$out/share/kak/bin"

     

       
27
       
27
       
+
       
        --suffix PATH : "$out/share/kak/bin"

     

       
28
       
28
       
 
       


     

       
29
       
29
       
 
       
      # currently kakoune ignores doc files if they are symlinks, so workaround by

     

       
30
       
30
       
 
       
      # copying doc files over, so they become regular files...

     

···

       
1054
       
1054
       
 
       
      '';

     

       
1055
       
1055
       
 
       
    };

     

       
1056
       
1056
       
 
       


     

       
1057
       
1057
       
+
       
  markview-nvim = super.markview-nvim.overrideAttrs {

     

       
1058
       
1058
       
+
       
    dependencies = with self; [ nvim-web-devicons ];

     

       
1059
       
1059
       
+
       
  };

     

       
1060
       
1060
       
+
       


     

       
1057
       
1061
       
 
       
  mason-lspconfig-nvim = super.mason-lspconfig-nvim.overrideAttrs {

     

       
1058
       
1062
       
 
       
    dependencies = with self; [ mason-nvim nvim-lspconfig ];

     

       
1059
       
1063
       
 
       
  };

     

···

       
8
       
8
       
 
       


     

       
9
       
9
       
 
       
buildGoModule rec {

     

       
10
       
10
       
 
       
  pname = "nwg-dock";

     

       
11
       
11
       
-
       
  version = "0.3.9";

     

       
11
       
11
       
+
       
  version = "0.4.0";

     

       
12
       
12
       
 
       


     

       
13
       
13
       
 
       
  src = fetchFromGitHub {

     

       
14
       
14
       
 
       
    owner = "nwg-piotr";

     

       
15
       
15
       
 
       
    repo = pname;

     

       
16
       
16
       
 
       
    rev = "v${version}";

     

       
17
       
17
       
-
       
    sha256 = "sha256-/iUtVym+fNnbBeLlrYIiO5tV9eeAVBh6Nw+d3GCJ/F8=";

     

       
17
       
17
       
+
       
    sha256 = "sha256-qmzCjbWmrDJBB2gnhR5hc0sYD3V0i/SKTavfMA2iLyc=";

     

       
18
       
18
       
 
       
  };

     

       
19
       
19
       
 
       


     

       
20
       
20
       
-
       
  vendorHash = "sha256-GW+shKOCwU8yprEfBeAPx1RDgjA7cZZzXDG112bdZ6k=";

     

       
20
       
20
       
+
       
  vendorHash = "sha256-paRcBQwg2uGouMRX5XF++OyN8Y0JyucXLN0G5O0j3qA=";

     

       
21
       
21
       
 
       


     

       
22
       
22
       
 
       
  ldflags = [ "-s" "-w" ];

     

       
23
       
23
       
 
       


     

···

       
20
       
20
       
 
       


     

       
21
       
21
       
 
       
stdenv.mkDerivation rec {

     

       
22
       
22
       
 
       
  pname = "otpclient";

     

       
23
       
23
       
-
       
  version = "4.0.0";

     

       
23
       
23
       
+
       
  version = "4.0.2";

     

       
24
       
24
       
 
       


     

       
25
       
25
       
 
       
  src = fetchFromGitHub {

     

       
26
       
26
       
 
       
    owner = "paolostivanin";

     

       
27
       
27
       
 
       
    repo = pname;

     

       
28
       
28
       
 
       
    rev = "refs/tags/v${version}";

     

       
29
       
29
       
-
       
    hash = "sha256-Ah1TWRxLFKgSDjnLO5XLIyo1hgD7EAlMHDbxxcOu4Yg=";

     

       
29
       
29
       
+
       
    hash = "sha256-lSGXxwtys3V8dDTAW7l7+9VlF9tZQnWqNaV8neBvMRg=";

     

       
30
       
30
       
 
       
  };

     

       
31
       
31
       
 
       


     

       
32
       
32
       
 
       
  nativeBuildInputs = [

     

···

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
stdenv.mkDerivation rec {

     

       
4
       
4
       
 
       
  pname = "pdfsam-basic";

     

       
5
       
5
       
-
       
  version = "5.2.3";

     

       
5
       
5
       
+
       
  version = "5.2.4";

     

       
6
       
6
       
 
       


     

       
7
       
7
       
 
       
  src = fetchurl {

     

       
8
       
8
       
 
       
    url = "https://github.com/torakiki/pdfsam/releases/download/v${version}/pdfsam_${version}-1_amd64.deb";

     

       
9
       
9
       
-
       
    hash = "sha256-ai1UHMeLvCba6WV6f6dGc53CxPP7bJaPgo8Tm7ddkOM=";

     

       
9
       
9
       
+
       
    hash = "sha256-xtkp5OCxzLx0ZNeYlwLQWudzsILErlrAHacuq4hOL8E=";

     

       
10
       
10
       
 
       
  };

     

       
11
       
11
       
 
       


     

       
12
       
12
       
 
       
  unpackPhase = ''

     

···

       
1
       
1
       
-
       
{ lib, fetchFromGitHub, python3Packages }:

     

       
2
       
2
       
-
       


     

       
3
       
3
       
-
       
python3Packages.buildPythonApplication rec {

     

       
4
       
4
       
-
       
  pname = "zk-shell";

     

       
5
       
5
       
-
       
  version = "1.0.0";

     

       
6
       
6
       
-
       


     

       
7
       
7
       
-
       
  src = fetchFromGitHub {

     

       
8
       
8
       
-
       
    owner = "rgs1";

     

       
9
       
9
       
-
       
    repo = "zk_shell";

     

       
10
       
10
       
-
       
    rev = "v${version}";

     

       
11
       
11
       
-
       
    sha256 = "0zisvvlclsf4sdh7dpqcl1149xbxw6pi1aqcwjbqblgf8m4nm0c7";

     

       
12
       
12
       
-
       
  };

     

       
13
       
13
       
-
       


     

       
14
       
14
       
-
       
  propagatedBuildInputs = with python3Packages; [

     

       
15
       
15
       
-
       
    ansi

     

       
16
       
16
       
-
       
    kazoo

     

       
17
       
17
       
-
       
    nose

     

       
18
       
18
       
-
       
    six

     

       
19
       
19
       
-
       
    tabulate

     

       
20
       
20
       
-
       
    twitter

     

       
21
       
21
       
-
       
  ];

     

       
22
       
22
       
-
       


     

       
23
       
23
       
-
       
  # requires a running zookeeper, don't know how to fix that for the moment

     

       
24
       
24
       
-
       
  doCheck = false;

     

       
25
       
25
       
-
       


     

       
26
       
26
       
-
       
  meta = with lib; {

     

       
27
       
27
       
-
       
    description = "Powerful & scriptable shell for Apache ZooKeeper";

     

       
28
       
28
       
-
       
    mainProgram = "zk-shell";

     

       
29
       
29
       
-
       
    homepage = "https://github.com/rgs1/zk_shell";

     

       
30
       
30
       
-
       
    license = licenses.asl20;

     

       
31
       
31
       
-
       
    maintainers = [ maintainers.mahe ];

     

       
32
       
32
       
-
       
    platforms = platforms.all;

     

       
33
       
33
       
-
       
  };

     

       
34
       
34
       
-
       
}

     

···

       
27
       
27
       
 
       
        version = "2024-06-06";

     

       
28
       
28
       
 
       
      };

     

       
29
       
29
       
 
       
      ungoogled-patches = {

     

       
30
       
30
       
-
       
        hash = "sha256-4LfYBqFQ/e/ePaOTSFBpELt0ilo/Vohwnwp8FvkfavU=";

     

       
31
       
31
       
-
       
        rev = "127.0.6533.88-1";

     

       
30
       
30
       
+
       
        hash = "sha256-4iI+1mVMoI1xg2t+33PiYDsiuXw0v4oUbSbYX+I9Q7s=";

     

       
31
       
31
       
+
       
        rev = "127.0.6533.99-1";

     

       
32
       
32
       
 
       
      };

     

       
33
       
33
       
 
       
    };

     

       
34
       
34
       
-
       
    hash = "sha256-nZZ2yrVu+0TloMaM455bmyeoeVnfeGR3EGubAf8snNU=";

     

       
35
       
35
       
-
       
    version = "127.0.6533.88";

     

       
34
       
34
       
+
       
    hash = "sha256-VKPlcBfS6iw4E1nz0nYJLg273XmJ+RcGGktRbqQTTwQ=";

     

       
35
       
35
       
+
       
    version = "127.0.6533.99";

     

       
36
       
36
       
 
       
  };

     

       
37
       
37
       
 
       
}

     

···

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
let

     

       
4
       
4
       
 
       
  pname = "polypane";

     

       
5
       
5
       
-
       
  version = "20.1.1";

     

       
5
       
5
       
+
       
  version = "20.1.2";

     

       
6
       
6
       
 
       


     

       
7
       
7
       
 
       
  src = fetchurl {

     

       
8
       
8
       
 
       
    url = "https://github.com/firstversionist/${pname}/releases/download/v${version}/${pname}-${version}.AppImage";

     

       
9
       
9
       
 
       
    name = "${pname}-${version}.AppImage";

     

       
10
       
10
       
-
       
    sha256 = "sha256-2bofd/2Eu2jpyvp5l1/Q6QIY2t7xaIV+ZhneGG38dA0=";

     

       
10
       
10
       
+
       
    sha256 = "sha256-rdbx0ffI8MDGXArniFnqTpuLLMlihtXXQiZnxw5vq+c=";

     

       
11
       
11
       
 
       
  };

     

       
12
       
12
       
 
       


     

       
13
       
13
       
 
       
  appimageContents = appimageTools.extractType2 {

     

···

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
buildGoModule rec{

     

       
4
       
4
       
 
       
  pname = "pinniped";

     

       
5
       
5
       
-
       
  version = "0.32.0";

     

       
5
       
5
       
+
       
  version = "0.33.0";

     

       
6
       
6
       
 
       


     

       
7
       
7
       
 
       
  src = fetchFromGitHub {

     

       
8
       
8
       
 
       
    owner = "vmware-tanzu";

     

       
9
       
9
       
 
       
    repo = "pinniped";

     

       
10
       
10
       
 
       
    rev = "v${version}";

     

       
11
       
11
       
-
       
    sha256 = "sha256-ypl8P66SEoHpaqAgFA90bJmiVvH4SvymCMVz1o9x9mQ=";

     

       
11
       
11
       
+
       
    sha256 = "sha256-BcDUXu/p5BYPrisJJBcaAGHL0k7FHMRKj1/z6Bz9hLU=";

     

       
12
       
12
       
 
       
  };

     

       
13
       
13
       
 
       


     

       
14
       
14
       
 
       
  subPackages = "cmd/pinniped";

     

       
15
       
15
       
 
       


     

       
16
       
16
       
-
       
  vendorHash = "sha256-Tl5o/ytwdGT0bSa8ep7YSaSMM9rk8+Zx1SFgFGh9u6k=";

     

       
16
       
16
       
+
       
  vendorHash = "sha256-quGhv2JpMseQps9qPvuJ6Jit8CxcSCOWYHG684whwl4=";

     

       
17
       
17
       
 
       


     

       
18
       
18
       
 
       
  ldflags = [ "-s" "-w" ];

     

       
19
       
19
       
 
       


     

···

       
11
       
11
       
 
       


     

       
12
       
12
       
 
       
rustPlatform.buildRustPackage rec {

     

       
13
       
13
       
 
       
  pname = "twitch-tui";

     

       
14
       
14
       
-
       
  version = "2.6.13";

     

       
14
       
14
       
+
       
  version = "2.6.14";

     

       
15
       
15
       
 
       


     

       
16
       
16
       
 
       
  src = fetchFromGitHub {

     

       
17
       
17
       
 
       
    owner = "Xithrius";

     

       
18
       
18
       
 
       
    repo = pname;

     

       
19
       
19
       
 
       
    rev = "refs/tags/v${version}";

     

       
20
       
20
       
-
       
    hash = "sha256-VEcBPiekjiDjXYTz/gqjES8N77GgwPdWRUJJ3twLmgU=";

     

       
20
       
20
       
+
       
    hash = "sha256-a/tPRGqD6YBw1Ls28kJNxQYNMc8mUq8wLgSg0yiJR+U=";

     

       
21
       
21
       
 
       
  };

     

       
22
       
22
       
 
       


     

       
23
       
23
       
-
       
  cargoHash = "sha256-uhm6Z4oJ8w1tN3VDtCNF2/pixNLCXnaEg8yyUSTJRnM=";

     

       
23
       
23
       
+
       
  cargoHash = "sha256-MRbwA/riOECCv2/AzNIma9sMAyRrEDb6HDOaGVDxr1Q=";

     

       
24
       
24
       
 
       


     

       
25
       
25
       
 
       
  nativeBuildInputs = [

     

       
26
       
26
       
 
       
    pkg-config

     

···

       
48
       
48
       
 
       
  # and often with different versions.  We write them on three lines

     

       
49
       
49
       
 
       
  # like this (rather than using {}) so that the updater script can

     

       
50
       
50
       
 
       
  # find where to edit them.

     

       
51
       
51
       
-
       
  versions.aarch64-darwin = "6.1.1.36333";

     

       
52
       
52
       
-
       
  versions.x86_64-darwin = "6.1.1.36333";

     

       
53
       
53
       
-
       
  versions.x86_64-linux = "6.1.1.443";

     

       
51
       
51
       
+
       
  versions.aarch64-darwin = "6.1.6.37851";

     

       
52
       
52
       
+
       
  versions.x86_64-darwin = "6.1.6.37851";

     

       
53
       
53
       
+
       
  versions.x86_64-linux = "6.1.6.1013";

     

       
54
       
54
       
 
       


     

       
55
       
55
       
 
       
  srcs = {

     

       
56
       
56
       
 
       
    aarch64-darwin = fetchurl {

     

       
57
       
57
       
 
       
      url = "https://zoom.us/client/${versions.aarch64-darwin}/zoomusInstallerFull.pkg?archType=arm64";

     

       
58
       
58
       
 
       
      name = "zoomusInstallerFull.pkg";

     

       
59
       
59
       
-
       
      hash = "sha256-CBBJAa7hnz0I2ctEn7DMdzeXEs4x+aEmEr+L42ddqXE=";

     

       
59
       
59
       
+
       
      hash = "sha256-wsatsfVQElWXMZKZOVeqVBBE7ZRXx54OpA82ZzpymUI=";

     

       
60
       
60
       
 
       
    };

     

       
61
       
61
       
 
       
    x86_64-darwin = fetchurl {

     

       
62
       
62
       
 
       
      url = "https://zoom.us/client/${versions.x86_64-darwin}/zoomusInstallerFull.pkg";

     

       
63
       
63
       
-
       
      hash = "sha256-CHtyL/BdyBVCQOGWjP0H/5GJiq67hPNQxELlvzzUuts=";

     

       
63
       
63
       
+
       
      hash = "sha256-BTLEfVFrUQbb+LpGP93hMqGFWhKM3tBdKxDKe8GkhiA=";

     

       
64
       
64
       
 
       
    };

     

       
65
       
65
       
 
       
    x86_64-linux = fetchurl {

     

       
66
       
66
       
 
       
      url = "https://zoom.us/client/${versions.x86_64-linux}/zoom_x86_64.pkg.tar.xz";

     

       
67
       
67
       
-
       
      hash = "sha256-2FOAZ3MKusouuWvhxFEcqX+2e+PCF4N5zaz7mc9Mnq4=";

     

       
67
       
67
       
+
       
      hash = "sha256-mvCJft0suOxnwTkWWuH9OYKHwTMWx61ct10P5Q/EVBM=";

     

       
68
       
68
       
 
       
    };

     

       
69
       
69
       
 
       
  };

     

       
70
       
70
       
 
       


     

···

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
buildGoModule rec {

     

       
4
       
4
       
 
       
  pname = "git-credential-oauth";

     

       
5
       
5
       
-
       
  version = "0.13.0";

     

       
5
       
5
       
+
       
  version = "0.13.2";

     

       
6
       
6
       
 
       


     

       
7
       
7
       
 
       
  src = fetchFromGitHub {

     

       
8
       
8
       
 
       
    owner = "hickford";

     

       
9
       
9
       
 
       
    repo = pname;

     

       
10
       
10
       
 
       
    rev = "v${version}";

     

       
11
       
11
       
-
       
    hash = "sha256-hCZZPbkbkZcR2xFTECQWJl2MvSu8MnOznadaj0nKfSo=";

     

       
11
       
11
       
+
       
    hash = "sha256-pJ1Snq79bQvhE+D7U8pMmK4YyvoZIwv29kr5640jpns=";

     

       
12
       
12
       
 
       
  };

     

       
13
       
13
       
 
       


     

       
14
       
14
       
 
       
  nativeBuildInputs = [ installShellFiles ];

     
···

       
19
       
19
       
 
       
    "-X main.version=${version}"

     

       
20
       
20
       
 
       
  ];

     

       
21
       
21
       
 
       


     

       
22
       
22
       
-
       
  vendorHash = "sha256-nbwrVihcH+ARLHylsjogsv3LVP+0+YtQ+7cozB7pAWo=";

     

       
22
       
22
       
+
       
  vendorHash = "sha256-ujsfEmDOOGCNErtBW5EyefQ+jXhfnAiwteYm8F7RLVE=";

     

       
23
       
23
       
 
       


     

       
24
       
24
       
 
       
  postInstall = ''

     

       
25
       
25
       
 
       
    installManPage $src/git-credential-oauth.1

     

···

       
8
       
8
       
 
       
, after ? null

     

       
9
       
9
       
 
       
, condition ? null

     

       
10
       
10
       
 
       
, phase ? "2"

     

       
11
       
11
       
+
       
, prependExtraArgs ? []

     

       
12
       
12
       
+
       
, appendExtraArgs ? []

     

       
11
       
13
       
 
       
}:

     

       
12
       
14
       
 
       


     

       
13
       
15
       
 
       
# the builder requires that

     
···

       
18
       
20
       
 
       
  name = "autostart-${name}";

     

       
19
       
21
       
 
       
  priority = 5;

     

       
20
       
22
       
 
       


     

       
21
       
21
       
-
       
  buildCommand = ''

     

       
23
       
23
       
+
       
  buildCommand = let

     

       
24
       
24
       
+
       
    escapeArgs = args: lib.escapeRegex (lib.escapeShellArgs args);

     

       
25
       
25
       
+
       
    prependArgs = lib.optionalString (prependExtraArgs != []) "${escapeArgs prependExtraArgs} ";

     

       
26
       
26
       
+
       
    appendArgs = lib.optionalString (appendExtraArgs != []) " ${escapeArgs appendExtraArgs}";

     

       
27
       
27
       
+
       
  in ''

     

       
22
       
28
       
 
       
    mkdir -p $out/etc/xdg/autostart

     

       
23
       
29
       
 
       
    target=${name}.desktop

     

       
24
       
30
       
 
       
    cp ${package}/share/applications/${srcPrefix}${name}.desktop $target

     

       
31
       
31
       
+
       
    ${lib.optionalString (prependExtraArgs != [] || appendExtraArgs != []) ''

     

       
32
       
32
       
+
       
      sed -i -r "s/(Exec=)([^ ]*) (.*)/\1\2 ${prependArgs}\3${appendArgs}/" $target

     

       
33
       
33
       
+
       
    ''}

     

       
25
       
34
       
 
       
    chmod +rw $target

     

       
26
       
35
       
 
       
    echo "X-KDE-autostart-phase=${phase}" >> $target

     

       
27
       
36
       
 
       
    ${lib.optionalString (after != null) ''echo "${after}" >> $target''}

     

···

       
5
       
5
       
 
       
  runCommand,

     

       
6
       
6
       
 
       
  vmTools,

     

       
7
       
7
       
 
       
  writeClosure,

     

       
8
       
8
       
+
       
  writers,

     

       
8
       
9
       
 
       
  writeScript,

     

       
9
       
10
       
 
       
  # Native build inputs

     

       
11
       
11
       
+
       
  buildPackages,

     

       
10
       
12
       
 
       
  e2fsprogs,

     

       
11
       
11
       
-
       
  gawk,

     

       
12
       
13
       
 
       
  util-linux,

     

       
13
       
14
       
 
       
  # Build inputs

     

       
14
       
14
       
-
       
  bash,

     

       
15
       
15
       
+
       
  bashInteractive,

     

       
15
       
16
       
 
       
  runtimeShell,

     

       
16
       
17
       
 
       
  singularity,

     

       
17
       
17
       
-
       
  storeDir ? builtins.storeDir,

     

       
18
       
18
       
 
       
}:

     

       
19
       
19
       
+
       


     

       
20
       
20
       
+
       
let

     

       
21
       
21
       
+
       
  defaultSingularity = singularity;

     

       
22
       
22
       
+
       
in

     

       
19
       
23
       
 
       
rec {

     

       
24
       
24
       
+
       
  # TODO(@ShamrockLee): Remove after Nixpkgs 24.11 branch-off.

     

       
20
       
25
       
 
       
  shellScript =

     

       
21
       
21
       
-
       
    name: text:

     

       
22
       
22
       
-
       
    writeScript name ''

     

       
23
       
23
       
-
       
      #!${runtimeShell}

     

       
24
       
24
       
-
       
      set -e

     

       
25
       
25
       
-
       
      ${text}

     

       
26
       
26
       
-
       
    '';

     

       
26
       
26
       
+
       
    lib.warn

     

       
27
       
27
       
+
       
      "`singularity-tools.shellScript` is deprecated. Use `writeScript`, `writeShellScripts` or `writers.writeBash` instead."

     

       
28
       
28
       
+
       
      (

     

       
29
       
29
       
+
       
        name: text:

     

       
30
       
30
       
+
       
        writeScript name ''

     

       
31
       
31
       
+
       
          #!${runtimeShell}

     

       
32
       
32
       
+
       
          set -e

     

       
33
       
33
       
+
       
          ${text}

     

       
34
       
34
       
+
       
        ''

     

       
35
       
35
       
+
       
      );

     

       
27
       
36
       
 
       


     

       
37
       
37
       
+
       
  # TODO(@ShamrockLee): Remove after Nixpkgs 24.11 branch-off.

     

       
28
       
38
       
 
       
  mkLayer =

     

       
29
       
29
       
-
       
    {

     

       
30
       
30
       
-
       
      name,

     

       
31
       
31
       
-
       
      contents ? [ ],

     

       
32
       
32
       
-
       
      # May be "apptainer" instead of "singularity"

     

       
33
       
33
       
-
       
      projectName ? (singularity.projectName or "singularity"),

     

       
34
       
34
       
-
       
    }:

     

       
35
       
35
       
-
       
    runCommand "${projectName}-layer-${name}" { inherit contents; } ''

     

       
36
       
36
       
-
       
      mkdir $out

     

       
37
       
37
       
-
       
      for f in $contents ; do

     

       
38
       
38
       
-
       
        cp -ra $f $out/

     

       
39
       
39
       
-
       
      done

     

       
40
       
40
       
-
       
    '';

     

       
39
       
39
       
+
       
    lib.warn

     

       
40
       
40
       
+
       
      "`singularity-tools.mkLayer` is deprecated, as it is no longer used to implement `singularity-tools.buildImages`."

     

       
41
       
41
       
+
       
      (

     

       
42
       
42
       
+
       
        {

     

       
43
       
43
       
+
       
          name,

     

       
44
       
44
       
+
       
          contents ? [ ],

     

       
45
       
45
       
+
       
          # May be "apptainer" instead of "singularity"

     

       
46
       
46
       
+
       
          projectName ? (singularity.projectName or "singularity"),

     

       
47
       
47
       
+
       
        }:

     

       
48
       
48
       
+
       
        runCommand "${projectName}-layer-${name}" { inherit contents; } ''

     

       
49
       
49
       
+
       
          mkdir $out

     

       
50
       
50
       
+
       
          for f in $contents ; do

     

       
51
       
51
       
+
       
            cp -ra $f $out/

     

       
52
       
52
       
+
       
          done

     

       
53
       
53
       
+
       
        ''

     

       
54
       
54
       
+
       
      );

     

       
41
       
55
       
 
       


     

       
42
       
56
       
 
       
  buildImage =

     

       
43
       
43
       
-
       
    let

     

       
44
       
44
       
-
       
      defaultSingularity = singularity;

     

       
45
       
45
       
-
       
    in

     

       
46
       
57
       
 
       
    {

     

       
47
       
58
       
 
       
      name,

     

       
48
       
59
       
 
       
      contents ? [ ],

     
···

       
54
       
65
       
 
       
    }:

     

       
55
       
66
       
 
       
    let

     

       
56
       
67
       
 
       
      projectName = singularity.projectName or "singularity";

     

       
57
       
57
       
-
       
      runAsRootFile = shellScript "run-as-root.sh" runAsRoot;

     

       
58
       
58
       
-
       
      runScriptFile = shellScript "run-script.sh" runScript;

     

       
68
       
68
       
+
       
      runAsRootFile = buildPackages.writers.writeBash "run-as-root.sh" ''

     

       
69
       
69
       
+
       
        set -e

     

       
70
       
70
       
+
       
        ${runAsRoot}

     

       
71
       
71
       
+
       
      '';

     

       
72
       
72
       
+
       
      runScriptFile = writers.writeBash "run-script.sh" ''

     

       
73
       
73
       
+
       
        set -e

     

       
74
       
74
       
+
       
        ${runScript}

     

       
75
       
75
       
+
       
      '';

     

       
59
       
76
       
 
       
      result = vmTools.runInLinuxVM (

     

       
60
       
60
       
-
       
        runCommand "${projectName}-image-${name}.img"

     

       
77
       
77
       
+
       
        runCommand "${projectName}-image-${name}.sif"

     

       
61
       
78
       
 
       
          {

     

       
62
       
62
       
-
       
            buildInputs = [

     

       
79
       
79
       
+
       
            nativeBuildInputs = [

     

       
63
       
80
       
 
       
              singularity

     

       
64
       
81
       
 
       
              e2fsprogs

     

       
65
       
82
       
 
       
              util-linux

     

       
66
       
66
       
-
       
              gawk

     

       
67
       
83
       
 
       
            ];

     

       
84
       
84
       
+
       
            strictDeps = true;

     

       
68
       
85
       
 
       
            layerClosure = writeClosure contents;

     

       
69
       
86
       
 
       
            preVM = vmTools.createEmptyImage {

     

       
70
       
87
       
 
       
              size = diskSize;

     
···

       
83
       
100
       
 
       


     

       
84
       
101
       
 
       
            # Run root script

     

       
85
       
102
       
 
       
            ${lib.optionalString (runAsRoot != null) ''

     

       
86
       
86
       
-
       
              mkdir -p ./${storeDir}

     

       
87
       
87
       
-
       
              mount --rbind ${storeDir} ./${storeDir}

     

       
103
       
103
       
+
       
              mkdir -p ./${builtins.storeDir}

     

       
104
       
104
       
+
       
              mount --rbind "${builtins.storeDir}" ./${builtins.storeDir}

     

       
88
       
105
       
 
       
              unshare -imnpuf --mount-proc chroot ./ ${runAsRootFile}

     

       
89
       
89
       
-
       
              umount -R ./${storeDir}

     

       
106
       
106
       
+
       
              umount -R ./${builtins.storeDir}

     

       
90
       
107
       
 
       
            ''}

     

       
91
       
108
       
 
       


     

       
92
       
109
       
 
       
            # Build /bin and copy across closure

     
···

       
105
       
122
       
 
       


     

       
106
       
123
       
 
       
            # Create runScript and link shell

     

       
107
       
124
       
 
       
            if [ ! -e bin/sh ]; then

     

       
108
       
108
       
-
       
              ln -s ${runtimeShell} bin/sh

     

       
125
       
125
       
+
       
              ln -s ${lib.getExe bashInteractive} bin/sh

     

       
109
       
126
       
 
       
            fi

     

       
110
       
110
       
-
       
            mkdir -p .${projectName}.d

     

       
111
       
111
       
-
       
            ln -s ${runScriptFile} .${projectName}.d/runscript

     

       
127
       
127
       
+
       
            mkdir -p .singularity.d

     

       
128
       
128
       
+
       
            ln -s ${runScriptFile} .singularity.d/runscript

     

       
112
       
129
       
 
       


     

       
113
       
113
       
-
       
            # Fill out .${projectName}.d

     

       
114
       
114
       
-
       
            mkdir -p .${projectName}.d/env

     

       
115
       
115
       
-
       
            touch .${projectName}.d/env/94-appsbase.sh

     

       
130
       
130
       
+
       
            # Fill out .singularity.d

     

       
131
       
131
       
+
       
            mkdir -p .singularity.d/env

     

       
132
       
132
       
+
       
            touch .singularity.d/env/94-appsbase.sh

     

       
116
       
133
       
 
       


     

       
117
       
134
       
 
       
            cd ..

     

       
118
       
135
       
 
       
            mkdir -p /var/lib/${projectName}/mnt/session

     

···

       
21
       
21
       
 
       
    ;

     

       
22
       
22
       
 
       
in

     

       
23
       
23
       
 
       
rec {

     

       
24
       
24
       
-
       
  # Base implementation for non-compiled executables.

     

       
25
       
25
       
-
       
  # Takes an interpreter, for example `${lib.getExe pkgs.bash}`

     

       
26
       
26
       
-
       
  #

     

       
27
       
27
       
-
       
  # Examples:

     

       
28
       
28
       
-
       
  #   writeBash = makeScriptWriter { interpreter = "${pkgs.bash}/bin/bash"; }

     

       
29
       
29
       
-
       
  #   makeScriptWriter { interpreter = "${pkgs.dash}/bin/dash"; } "hello" "echo hello world"

     

       
30
       
30
       
-
       
  makeScriptWriter = { interpreter, check ? "", makeWrapperArgs ? [], }: nameOrPath: content:

     

       
31
       
31
       
-
       
    assert (types.path.check nameOrPath) || (builtins.match "([0-9A-Za-z._])[0-9A-Za-z._-]*" nameOrPath != null);

     

       
24
       
24
       
+
       
  /**

     

       
25
       
25
       
+
       
    A generic function that returns a derivation which, when beeing built outputs the script in an executable format.

     

       
26
       
26
       
+
       


     

       
27
       
27
       
+
       
    # Inputs

     

       
28
       
28
       
+
       


     

       
29
       
29
       
+
       
    config (AttrSet)

     

       
30
       
30
       
+
       
    : `interpreter` (String)

     

       
31
       
31
       
+
       
      : the interpreter to use for the script

     

       
32
       
32
       
+
       
    : `check` (String)

     

       
33
       
33
       
+
       
      : A command to check the script. I.e. some linting check.

     

       
34
       
34
       
+
       
    : `makeWrapperArgs` (Optional, [ String ], Default: [])

     

       
35
       
35
       
+
       
      : Arguments forwarded to (`makeWrapper`)[#fun-makeWrapper]

     

       
36
       
36
       
+
       


     

       
37
       
37
       
+
       
    `nameOrPath` (String)

     

       
38
       
38
       
+
       
    : The name of the script or the path to the script.

     

       
39
       
39
       
+
       


     

       
40
       
40
       
+
       
      When a `string` starting with "/" is passed, the script will be created at the specified path in $out.

     

       
41
       
41
       
+
       
      I.e. `"/bin/hello"` will create a script at `$out/bin/hello`.

     

       
42
       
42
       
+
       


     

       
43
       
43
       
+
       
      Any other `string` is interpreted as filename.

     

       
44
       
44
       
+
       
      It must be a simple unix filename starting with a letter, digit, dot, or underscore.

     

       
45
       
45
       
+
       
      Spaces or special characters are not allowed.

     

       
46
       
46
       
+
       


     

       
47
       
47
       
+
       
    `content` (String)

     

       
48
       
48
       
+
       
    : The content of the script.

     

       
49
       
49
       
+
       


     

       
50
       
50
       
+
       
    :::{.note}

     

       
51
       
51
       
+
       
    This function is used as base implementation for other high-level writer functions.

     

       
52
       
52
       
+
       


     

       
53
       
53
       
+
       
    For example, `writeBash` can (roughly) be implemented as:

     

       
54
       
54
       
+
       
    ```nix

     

       
55
       
55
       
+
       
    writeBash = makeScriptWriter { interpreter = "${pkgs.bash}/bin/bash"; }

     

       
56
       
56
       
+
       
    ```

     

       
57
       
57
       
+
       
    :::

     

       
58
       
58
       
+
       


     

       
59
       
59
       
+
       
    # Examples

     

       
60
       
60
       
+
       
    :::{.example}

     

       
61
       
61
       
+
       
    ## `pkgs.writers.makeScriptWriter` dash example

     

       
62
       
62
       
+
       


     

       
63
       
63
       
+
       
    ```nix-repl

     

       
64
       
64
       
+
       
    :b makeScriptWriter { interpreter = "${pkgs.dash}/bin/dash"; } "hello" "echo hello world"

     

       
65
       
65
       
+
       
    -> /nix/store/indvlr9ckmnv4f0ynkmasv2h4fxhand0-hello

     

       
66
       
66
       
+
       
    ```

     

       
67
       
67
       
+
       


     

       
68
       
68
       
+
       
    The above example creates a script named `hello` that outputs `hello world` when executed.

     

       
69
       
69
       
+
       


     

       
70
       
70
       
+
       
    ```sh

     

       
71
       
71
       
+
       
    > /nix/store/indvlr9ckmnv4f0ynkmasv2h4fxhand0-hello

     

       
72
       
72
       
+
       
    hello world

     

       
73
       
73
       
+
       
    ```

     

       
74
       
74
       
+
       
    :::

     

       
75
       
75
       
+
       


     

       
76
       
76
       
+
       
    :::{.example}

     

       
77
       
77
       
+
       
    ## `pkgs.writers.makeScriptWriter` python example

     

       
78
       
78
       
+
       


     

       
79
       
79
       
+
       
    ```nix-repl

     

       
80
       
80
       
+
       
    :b makeScriptWriter { interpreter = "${pkgs.python3}/bin/python"; } "python-hello" "print('hello world')"

     

       
81
       
81
       
+
       
    -> /nix/store/4kvby1hqr45ffcdrvfpnpj62hanskw93-python-hello

     

       
82
       
82
       
+
       
    ```

     

       
83
       
83
       
+
       


     

       
84
       
84
       
+
       
    ```sh

     

       
85
       
85
       
+
       
    > /nix/store/4kvby1hqr45ffcdrvfpnpj62hanskw93-python-hello

     

       
86
       
86
       
+
       
    hello world

     

       
87
       
87
       
+
       
    ```

     

       
88
       
88
       
+
       
    :::

     

       
89
       
89
       
+
       
  */

     

       
90
       
90
       
+
       
  makeScriptWriter =

     

       
91
       
91
       
+
       
    {

     

       
92
       
92
       
+
       
      interpreter,

     

       
93
       
93
       
+
       
      check ? "",

     

       
94
       
94
       
+
       
      makeWrapperArgs ? [ ],

     

       
95
       
95
       
+
       
    }:

     

       
96
       
96
       
+
       
    nameOrPath: content:

     

       
97
       
97
       
+
       
    assert

     

       
98
       
98
       
+
       
      (types.path.check nameOrPath)

     

       
99
       
99
       
+
       
      || (builtins.match "([0-9A-Za-z._])[0-9A-Za-z._-]*" nameOrPath != null);

     

       
32
       
100
       
 
       
    assert (types.path.check content) || (types.str.check content);

     

       
33
       
101
       
 
       
    let

     

       
34
       
102
       
 
       
      nameIsPath = types.path.check nameOrPath;

     
···

       
37
       
105
       
 
       
      # The inner derivation which creates the executable under $out/bin (never at $out directly)

     

       
38
       
106
       
 
       
      # This is required in order to support wrapping, as wrapped programs consist of at least two files: the executable and the wrapper.

     

       
39
       
107
       
 
       
      inner =

     

       
40
       
40
       
-
       
        pkgs.runCommandLocal name (

     

       
41
       
41
       
-
       
          {

     

       
42
       
42
       
-
       
            inherit makeWrapperArgs;

     

       
43
       
43
       
-
       
            nativeBuildInputs = [

     

       
44
       
44
       
-
       
              makeBinaryWrapper

     

       
45
       
45
       
-
       
            ];

     

       
46
       
46
       
-
       
            meta.mainProgram = name;

     

       
47
       
47
       
-
       
          }

     

       
48
       
48
       
-
       
          // (

     

       
49
       
49
       
-
       
            if (types.str.check content) then {

     

       
50
       
50
       
-
       
              inherit content interpreter;

     

       
51
       
51
       
-
       
              passAsFile = [ "content" ];

     

       
52
       
52
       
-
       
            } else {

     

       
53
       
53
       
-
       
              inherit interpreter;

     

       
54
       
54
       
-
       
              contentPath = content;

     

       
108
       
108
       
+
       
        pkgs.runCommandLocal name

     

       
109
       
109
       
+
       
          (

     

       
110
       
110
       
+
       
            {

     

       
111
       
111
       
+
       
              inherit makeWrapperArgs;

     

       
112
       
112
       
+
       
              nativeBuildInputs = [ makeBinaryWrapper ];

     

       
113
       
113
       
+
       
              meta.mainProgram = name;

     

       
55
       
114
       
 
       
            }

     

       
115
       
115
       
+
       
            // (

     

       
116
       
116
       
+
       
              if (types.str.check content) then

     

       
117
       
117
       
+
       
                {

     

       
118
       
118
       
+
       
                  inherit content interpreter;

     

       
119
       
119
       
+
       
                  passAsFile = [ "content" ];

     

       
120
       
120
       
+
       
                }

     

       
121
       
121
       
+
       
              else

     

       
122
       
122
       
+
       
                {

     

       
123
       
123
       
+
       
                  inherit interpreter;

     

       
124
       
124
       
+
       
                  contentPath = content;

     

       
125
       
125
       
+
       
                }

     

       
126
       
126
       
+
       
            )

     

       
56
       
127
       
 
       
          )

     

       
57
       
57
       
-
       
        )

     

       
58
       
58
       
-
       
        ''

     

       
59
       
59
       
-
       
          # On darwin a script cannot be used as an interpreter in a shebang but

     

       
60
       
60
       
-
       
          # there doesn't seem to be a limit to the size of shebang and multiple

     

       
61
       
61
       
-
       
          # arguments to the interpreter are allowed.

     

       
62
       
62
       
-
       
          if [[ -n "${toString pkgs.stdenvNoCC.isDarwin}" ]] && isScript $interpreter

     

       
63
       
63
       
-
       
          then

     

       
64
       
64
       
-
       
            wrapperInterpreterLine=$(head -1 "$interpreter" | tail -c+3)

     

       
65
       
65
       
-
       
            # Get first word from the line (note: xargs echo remove leading spaces)

     

       
66
       
66
       
-
       
            wrapperInterpreter=$(echo "$wrapperInterpreterLine" | xargs echo | cut -d " " -f1)

     

       
128
       
128
       
+
       
          ''

     

       
129
       
129
       
+
       
            # On darwin a script cannot be used as an interpreter in a shebang but

     

       
130
       
130
       
+
       
            # there doesn't seem to be a limit to the size of shebang and multiple

     

       
131
       
131
       
+
       
            # arguments to the interpreter are allowed.

     

       
132
       
132
       
+
       
            if [[ -n "${toString pkgs.stdenvNoCC.isDarwin}" ]] && isScript $interpreter

     

       
133
       
133
       
+
       
            then

     

       
134
       
134
       
+
       
              wrapperInterpreterLine=$(head -1 "$interpreter" | tail -c+3)

     

       
135
       
135
       
+
       
              # Get first word from the line (note: xargs echo remove leading spaces)

     

       
136
       
136
       
+
       
              wrapperInterpreter=$(echo "$wrapperInterpreterLine" | xargs echo | cut -d " " -f1)

     

       
137
       
137
       
+
       


     

       
138
       
138
       
+
       
              if isScript $wrapperInterpreter

     

       
139
       
139
       
+
       
              then

     

       
140
       
140
       
+
       
                echo "error: passed interpreter ($interpreter) is a script which has another script ($wrapperInterpreter) as an interpreter, which is not supported."

     

       
141
       
141
       
+
       
                exit 1

     

       
142
       
142
       
+
       
              fi

     

       
67
       
143
       
 
       


     

       
68
       
68
       
-
       
            if isScript $wrapperInterpreter

     

       
69
       
69
       
-
       
            then

     

       
70
       
70
       
-
       
              echo "error: passed interpreter ($interpreter) is a script which has another script ($wrapperInterpreter) as an interpreter, which is not supported."

     

       
71
       
71
       
-
       
              exit 1

     

       
144
       
144
       
+
       
              # This should work as long as wrapperInterpreter is a shell, which is

     

       
145
       
145
       
+
       
              # the case for programs wrapped with makeWrapper, like

     

       
146
       
146
       
+
       
              # python3.withPackages etc.

     

       
147
       
147
       
+
       
              interpreterLine="$wrapperInterpreterLine $interpreter"

     

       
148
       
148
       
+
       
            else

     

       
149
       
149
       
+
       
              interpreterLine=$interpreter

     

       
72
       
150
       
 
       
            fi

     

       
73
       
151
       
 
       


     

       
74
       
74
       
-
       
            # This should work as long as wrapperInterpreter is a shell, which is

     

       
75
       
75
       
-
       
            # the case for programs wrapped with makeWrapper, like

     

       
76
       
76
       
-
       
            # python3.withPackages etc.

     

       
77
       
77
       
-
       
            interpreterLine="$wrapperInterpreterLine $interpreter"

     

       
78
       
78
       
-
       
          else

     

       
79
       
79
       
-
       
            interpreterLine=$interpreter

     

       
80
       
80
       
-
       
          fi

     

       
152
       
152
       
+
       
            echo "#! $interpreterLine" > $out

     

       
153
       
153
       
+
       
            cat "$contentPath" >> $out

     

       
154
       
154
       
+
       
            ${optionalString (check != "") ''

     

       
155
       
155
       
+
       
              ${check} $out

     

       
156
       
156
       
+
       
            ''}

     

       
157
       
157
       
+
       
            chmod +x $out

     

       
81
       
158
       
 
       


     

       
82
       
82
       
-
       
          echo "#! $interpreterLine" > $out

     

       
83
       
83
       
-
       
          cat "$contentPath" >> $out

     

       
84
       
84
       
-
       
          ${optionalString (check != "") ''

     

       
85
       
85
       
-
       
            ${check} $out

     

       
86
       
86
       
-
       
          ''}

     

       
87
       
87
       
-
       
          chmod +x $out

     

       
159
       
159
       
+
       
            # Relocate executable

     

       
160
       
160
       
+
       
            # Wrap it if makeWrapperArgs are specified

     

       
161
       
161
       
+
       
            mv $out tmp

     

       
162
       
162
       
+
       
              mkdir -p $out/$(dirname "${path}")

     

       
163
       
163
       
+
       
              mv tmp $out/${path}

     

       
164
       
164
       
+
       
            if [ -n "''${makeWrapperArgs+''${makeWrapperArgs[@]}}" ]; then

     

       
165
       
165
       
+
       
                wrapProgram $out/${path} ''${makeWrapperArgs[@]}

     

       
166
       
166
       
+
       
            fi

     

       
167
       
167
       
+
       
          '';

     

       
168
       
168
       
+
       
    in

     

       
169
       
169
       
+
       
    if nameIsPath then

     

       
170
       
170
       
+
       
      inner

     

       
171
       
171
       
+
       
    # In case nameOrPath is a name, the user intends the executable to be located at $out.

     

       
172
       
172
       
+
       
    # This is achieved by creating a separate derivation containing a symlink at $out linking to ${inner}/bin/${name}.

     

       
173
       
173
       
+
       
    # This breaks the override pattern.

     

       
174
       
174
       
+
       
    # In case this turns out to be a problem, we can still add more magic

     

       
175
       
175
       
+
       
    else

     

       
176
       
176
       
+
       
      pkgs.runCommandLocal name { } ''

     

       
177
       
177
       
+
       
        ln -s ${inner}/bin/${name} $out

     

       
178
       
178
       
+
       
      '';

     

       
88
       
179
       
 
       


     

       
89
       
89
       
-
       
          # Relocate executable

     

       
90
       
90
       
-
       
          # Wrap it if makeWrapperArgs are specified

     

       
91
       
91
       
-
       
          mv $out tmp

     

       
92
       
92
       
-
       
            mkdir -p $out/$(dirname "${path}")

     

       
93
       
93
       
-
       
            mv tmp $out/${path}

     

       
94
       
94
       
-
       
          if [ -n "''${makeWrapperArgs+''${makeWrapperArgs[@]}}" ]; then

     

       
95
       
95
       
-
       
              wrapProgram $out/${path} ''${makeWrapperArgs[@]}

     

       
96
       
96
       
-
       
          fi

     

       
97
       
97
       
-
       
        '';

     

       
98
       
98
       
-
       
      in

     

       
99
       
99
       
-
       
        if nameIsPath

     

       
100
       
100
       
-
       
        then inner

     

       
101
       
101
       
-
       
        # In case nameOrPath is a name, the user intends the executable to be located at $out.

     

       
102
       
102
       
-
       
        # This is achieved by creating a separate derivation containing a symlink at $out linking to ${inner}/bin/${name}.

     

       
103
       
103
       
-
       
        # This breaks the override pattern.

     

       
104
       
104
       
-
       
        # In case this turns out to be a problem, we can still add more magic

     

       
105
       
105
       
-
       
        else pkgs.runCommandLocal name {} ''

     

       
106
       
106
       
-
       
          ln -s ${inner}/bin/${name} $out

     

       
107
       
107
       
-
       
        '';

     

       
180
       
180
       
+
       
  /**

     

       
181
       
181
       
+
       
    This is a generic function that returns a derivation which, when built, compiles the given script into an executable format.

     

       
182
       
182
       
+
       


     

       
183
       
183
       
+
       
    :::{.note}

     

       
184
       
184
       
+
       
    This function is the base implementation for other compile language `writers`.

     

       
185
       
185
       
+
       
    i.e. `writeHaskell`, `writeRust`.

     

       
186
       
186
       
+
       
    :::

     

       
187
       
187
       
+
       


     

       
188
       
188
       
+
       
    # Inputs

     

       
189
       
189
       
+
       


     

       
190
       
190
       
+
       
    config (AttrSet)

     

       
191
       
191
       
+
       
    : `compileScript` (String)

     

       
192
       
192
       
+
       
      : The script that compiles the given content into an executable.

     

       
193
       
193
       
+
       


     

       
194
       
194
       
+
       
    : `strip` (Boolean, Default: true)

     

       
195
       
195
       
+
       
      : Whether to strip the executable or not.

     

       
108
       
196
       
 
       


     

       
197
       
197
       
+
       
    : `makeWrapperArgs` (Optional, [ String ], Default: [])

     

       
198
       
198
       
+
       
      : Arguments forwarded to (`makeWrapper`)[#fun-makeWrapper]

     

       
109
       
199
       
 
       


     

       
110
       
110
       
-
       
  # Base implementation for compiled executables.

     

       
111
       
111
       
-
       
  # Takes a compile script, which in turn takes the name as an argument.

     

       
112
       
112
       
-
       
  #

     

       
113
       
113
       
-
       
  # Examples:

     

       
114
       
114
       
-
       
  #   writeSimpleC = makeBinWriter { compileScript = name: "gcc -o $out $contentPath"; }

     

       
115
       
115
       
-
       
  makeBinWriter = { compileScript, strip ? true, makeWrapperArgs ? [] }: nameOrPath: content:

     

       
116
       
116
       
-
       
    assert (types.path.check nameOrPath) || (builtins.match "([0-9A-Za-z._])[0-9A-Za-z._-]*" nameOrPath != null);

     

       
200
       
200
       
+
       
    `nameOrPath` (String)

     

       
201
       
201
       
+
       
    : The name of the script or the path to the script.

     

       
202
       
202
       
+
       


     

       
203
       
203
       
+
       
      When a `string` starting with "/" is passed, the script will be created at the specified path in $out.

     

       
204
       
204
       
+
       
      I.e. `"/bin/hello"` will create a script at `$out/bin/hello`.

     

       
205
       
205
       
+
       


     

       
206
       
206
       
+
       
      Any other `string` is interpreted as filename.

     

       
207
       
207
       
+
       
      It must be a simple unix filename starting with a letter, digit, dot, or underscore.

     

       
208
       
208
       
+
       
      Spaces or special characters are not allowed.

     

       
209
       
209
       
+
       


     

       
210
       
210
       
+
       
    # Examples

     

       
211
       
211
       
+
       
    :::{.example}

     

       
212
       
212
       
+
       
    ## `pkgs.writers.makeBinWriter` example

     

       
213
       
213
       
+
       


     

       
214
       
214
       
+
       
    ```c

     

       
215
       
215
       
+
       
    // main.c

     

       
216
       
216
       
+
       
    #include <stdio.h>

     

       
217
       
217
       
+
       


     

       
218
       
218
       
+
       
    int main()

     

       
219
       
219
       
+
       
    {

     

       
220
       
220
       
+
       
        printf("Hello, World!\n");

     

       
221
       
221
       
+
       
        return 0;

     

       
222
       
222
       
+
       
    }

     

       
223
       
223
       
+
       
    ```

     

       
224
       
224
       
+
       


     

       
225
       
225
       
+
       
    ```nix-repl

     

       
226
       
226
       
+
       
    :b makeBinWriter { compileScript = "${pkgs.gcc}/bin/gcc -o $out $contentPath"; } "hello" ./main.c

     

       
227
       
227
       
+
       
    out -> /nix/store/f6crc8mwj3lvcxqclw7n09cm8nb6kxbh-hello

     

       
228
       
228
       
+
       
    ```

     

       
229
       
229
       
+
       


     

       
230
       
230
       
+
       
    The above example creates an executable named `hello` that outputs `Hello, World!` when executed.

     

       
231
       
231
       
+
       


     

       
232
       
232
       
+
       
    ```sh

     

       
233
       
233
       
+
       
    > /nix/store/f6crc8mwj3lvcxqclw7n09cm8nb6kxbh-hello

     

       
234
       
234
       
+
       
    Hello, World!

     

       
235
       
235
       
+
       
    ```

     

       
236
       
236
       
+
       
    :::

     

       
237
       
237
       
+
       
  */

     

       
238
       
238
       
+
       
  makeBinWriter =

     

       
239
       
239
       
+
       
    {

     

       
240
       
240
       
+
       
      compileScript,

     

       
241
       
241
       
+
       
      strip ? true,

     

       
242
       
242
       
+
       
      makeWrapperArgs ? [ ],

     

       
243
       
243
       
+
       
    }:

     

       
244
       
244
       
+
       
    nameOrPath: content:

     

       
245
       
245
       
+
       
    assert

     

       
246
       
246
       
+
       
      (types.path.check nameOrPath)

     

       
247
       
247
       
+
       
      || (builtins.match "([0-9A-Za-z._])[0-9A-Za-z._-]*" nameOrPath != null);

     

       
117
       
248
       
 
       
    assert (types.path.check content) || (types.str.check content);

     

       
118
       
249
       
 
       
    let

     

       
119
       
250
       
 
       
      nameIsPath = types.path.check nameOrPath;

     
···

       
122
       
253
       
 
       
      # The inner derivation which creates the executable under $out/bin (never at $out directly)

     

       
123
       
254
       
 
       
      # This is required in order to support wrapping, as wrapped programs consist of at least two files: the executable and the wrapper.

     

       
124
       
255
       
 
       
      inner =

     

       
125
       
125
       
-
       
        pkgs.runCommandLocal name (

     

       
126
       
126
       
-
       
          {

     

       
127
       
127
       
-
       
            inherit makeWrapperArgs;

     

       
128
       
128
       
-
       
            nativeBuildInputs = [

     

       
129
       
129
       
-
       
              makeBinaryWrapper

     

       
130
       
130
       
-
       
            ];

     

       
131
       
131
       
-
       
            meta.mainProgram = name;

     

       
132
       
132
       
-
       
          }

     

       
133
       
133
       
-
       
          // (

     

       
134
       
134
       
-
       
            if (types.str.check content) then {

     

       
135
       
135
       
-
       
            inherit content;

     

       
136
       
136
       
-
       
            passAsFile = [ "content" ];

     

       
137
       
137
       
-
       
          } else {

     

       
138
       
138
       
-
       
            contentPath = content;

     

       
139
       
139
       
-
       
                  }

     

       
256
       
256
       
+
       
        pkgs.runCommandLocal name

     

       
257
       
257
       
+
       
          (

     

       
258
       
258
       
+
       
            {

     

       
259
       
259
       
+
       
              inherit makeWrapperArgs;

     

       
260
       
260
       
+
       
              nativeBuildInputs = [ makeBinaryWrapper ];

     

       
261
       
261
       
+
       
              meta.mainProgram = name;

     

       
262
       
262
       
+
       
            }

     

       
263
       
263
       
+
       
            // (

     

       
264
       
264
       
+
       
              if (types.str.check content) then

     

       
265
       
265
       
+
       
                {

     

       
266
       
266
       
+
       
                  inherit content;

     

       
267
       
267
       
+
       
                  passAsFile = [ "content" ];

     

       
268
       
268
       
+
       
                }

     

       
269
       
269
       
+
       
              else

     

       
270
       
270
       
+
       
                { contentPath = content; }

     

       
271
       
271
       
+
       
            )

     

       
140
       
272
       
 
       
          )

     

       
141
       
141
       
-
       
        )

     

       
142
       
142
       
-
       
        ''

     

       
143
       
143
       
-
       
          ${compileScript}

     

       
144
       
144
       
-
       
          ${lib.optionalString strip

     

       
145
       
145
       
-
       
              "${lib.getBin buildPackages.bintools-unwrapped}/bin/${buildPackages.bintools-unwrapped.targetPrefix}strip -S $out"}

     

       
146
       
146
       
-
       
          # Sometimes binaries produced for darwin (e. g. by GHC) won't be valid

     

       
147
       
147
       
-
       
          # mach-o executables from the get-go, but need to be corrected somehow

     

       
148
       
148
       
-
       
          # which is done by fixupPhase.

     

       
149
       
149
       
-
       
          ${lib.optionalString pkgs.stdenvNoCC.hostPlatform.isDarwin "fixupPhase"}

     

       
150
       
150
       
-
       
          mv $out tmp

     

       
151
       
151
       
-
       
          mkdir -p $out/$(dirname "${path}")

     

       
152
       
152
       
-
       
          mv tmp $out/${path}

     

       
153
       
153
       
-
       
          if [ -n "''${makeWrapperArgs+''${makeWrapperArgs[@]}}" ]; then

     

       
154
       
154
       
-
       
            wrapProgram $out/${path} ''${makeWrapperArgs[@]}

     

       
155
       
155
       
-
       
          fi

     

       
156
       
156
       
-
       
        '';

     

       
273
       
273
       
+
       
          ''

     

       
274
       
274
       
+
       
            ${compileScript}

     

       
275
       
275
       
+
       
            ${lib.optionalString strip "${lib.getBin buildPackages.bintools-unwrapped}/bin/${buildPackages.bintools-unwrapped.targetPrefix}strip -S $out"}

     

       
276
       
276
       
+
       
            # Sometimes binaries produced for darwin (e. g. by GHC) won't be valid

     

       
277
       
277
       
+
       
            # mach-o executables from the get-go, but need to be corrected somehow

     

       
278
       
278
       
+
       
            # which is done by fixupPhase.

     

       
279
       
279
       
+
       
            ${lib.optionalString pkgs.stdenvNoCC.hostPlatform.isDarwin "fixupPhase"}

     

       
280
       
280
       
+
       
            mv $out tmp

     

       
281
       
281
       
+
       
            mkdir -p $out/$(dirname "${path}")

     

       
282
       
282
       
+
       
            mv tmp $out/${path}

     

       
283
       
283
       
+
       
            if [ -n "''${makeWrapperArgs+''${makeWrapperArgs[@]}}" ]; then

     

       
284
       
284
       
+
       
              wrapProgram $out/${path} ''${makeWrapperArgs[@]}

     

       
285
       
285
       
+
       
            fi

     

       
286
       
286
       
+
       
          '';

     

       
157
       
287
       
 
       
    in

     

       
158
       
158
       
-
       
      if nameIsPath

     

       
159
       
159
       
-
       
      then inner

     

       
160
       
160
       
-
       
      # In case nameOrPath is a name, the user intends the executable to be located at $out.

     

       
161
       
161
       
-
       
      # This is achieved by creating a separate derivation containing a symlink at $out linking to ${inner}/bin/${name}.

     

       
162
       
162
       
-
       
      # This breaks the override pattern.

     

       
163
       
163
       
-
       
      # In case this turns out to be a problem, we can still add more magic

     

       
164
       
164
       
-
       
      else pkgs.runCommandLocal name {} ''

     

       
288
       
288
       
+
       
    if nameIsPath then

     

       
289
       
289
       
+
       
      inner

     

       
290
       
290
       
+
       
    # In case nameOrPath is a name, the user intends the executable to be located at $out.

     

       
291
       
291
       
+
       
    # This is achieved by creating a separate derivation containing a symlink at $out linking to ${inner}/bin/${name}.

     

       
292
       
292
       
+
       
    # This breaks the override pattern.

     

       
293
       
293
       
+
       
    # In case this turns out to be a problem, we can still add more magic

     

       
294
       
294
       
+
       
    else

     

       
295
       
295
       
+
       
      pkgs.runCommandLocal name { } ''

     

       
165
       
296
       
 
       
        ln -s ${inner}/bin/${name} $out

     

       
166
       
297
       
 
       
      '';

     

       
167
       
298
       
 
       


     
···

       
184
       
315
       
 
       
  #     ''

     

       
185
       
316
       
 
       
  #       hello

     

       
186
       
317
       
 
       
  #     ''

     

       
187
       
187
       
-
       
  writeBash = name: argsOrScript:

     

       
188
       
188
       
-
       
    if lib.isAttrs argsOrScript && ! lib.isDerivation argsOrScript

     

       
189
       
189
       
-
       
    then makeScriptWriter (argsOrScript // { interpreter = "${lib.getExe pkgs.bash}"; }) name

     

       
190
       
190
       
-
       
    else makeScriptWriter { interpreter = "${lib.getExe pkgs.bash}"; } name argsOrScript;

     

       
318
       
318
       
+
       
  writeBash =

     

       
319
       
319
       
+
       
    name: argsOrScript:

     

       
320
       
320
       
+
       
    if lib.isAttrs argsOrScript && !lib.isDerivation argsOrScript then

     

       
321
       
321
       
+
       
      makeScriptWriter (argsOrScript // { interpreter = "${lib.getExe pkgs.bash}"; }) name

     

       
322
       
322
       
+
       
    else

     

       
323
       
323
       
+
       
      makeScriptWriter { interpreter = "${lib.getExe pkgs.bash}"; } name argsOrScript;

     

       
191
       
324
       
 
       


     

       
192
       
325
       
 
       
  # Like writeScriptBin but the first line is a shebang to bash

     

       
193
       
326
       
 
       
  #

     
···

       
208
       
341
       
 
       
  #    ''

     

       
209
       
342
       
 
       
  #      hello

     

       
210
       
343
       
 
       
  #    ''

     

       
211
       
211
       
-
       
  writeBashBin = name:

     

       
212
       
212
       
-
       
    writeBash "/bin/${name}";

     

       
344
       
344
       
+
       
  writeBashBin = name: writeBash "/bin/${name}";

     

       
213
       
345
       
 
       


     

       
214
       
346
       
 
       
  # Like writeScript but the first line is a shebang to dash

     

       
215
       
347
       
 
       
  #

     
···

       
230
       
362
       
 
       
  #     ''

     

       
231
       
363
       
 
       
  #       hello

     

       
232
       
364
       
 
       
  #     ''

     

       
233
       
233
       
-
       
  writeDash = name: argsOrScript:

     

       
234
       
234
       
-
       
    if lib.isAttrs argsOrScript && ! lib.isDerivation argsOrScript

     

       
235
       
235
       
-
       
    then makeScriptWriter (argsOrScript // { interpreter = "${lib.getExe pkgs.dash}"; }) name

     

       
236
       
236
       
-
       
    else makeScriptWriter { interpreter = "${lib.getExe pkgs.dash}"; } name argsOrScript;

     

       
365
       
365
       
+
       
  writeDash =

     

       
366
       
366
       
+
       
    name: argsOrScript:

     

       
367
       
367
       
+
       
    if lib.isAttrs argsOrScript && !lib.isDerivation argsOrScript then

     

       
368
       
368
       
+
       
      makeScriptWriter (argsOrScript // { interpreter = "${lib.getExe pkgs.dash}"; }) name

     

       
369
       
369
       
+
       
    else

     

       
370
       
370
       
+
       
      makeScriptWriter { interpreter = "${lib.getExe pkgs.dash}"; } name argsOrScript;

     

       
237
       
371
       
 
       


     

       
238
       
372
       
 
       
  # Like writeScriptBin but the first line is a shebang to dash

     

       
239
       
373
       
 
       
  #

     
···

       
254
       
388
       
 
       
  #    ''

     

       
255
       
389
       
 
       
  #      hello

     

       
256
       
390
       
 
       
  #    ''

     

       
257
       
257
       
-
       
  writeDashBin = name:

     

       
258
       
258
       
-
       
    writeDash "/bin/${name}";

     

       
391
       
391
       
+
       
  writeDashBin = name: writeDash "/bin/${name}";

     

       
259
       
392
       
 
       


     

       
260
       
393
       
 
       
  # Like writeScript but the first line is a shebang to fish

     

       
261
       
394
       
 
       
  #

     
···

       
276
       
409
       
 
       
  #     ''

     

       
277
       
410
       
 
       
  #       hello

     

       
278
       
411
       
 
       
  #     ''

     

       
279
       
279
       
-
       
  writeFish = name: argsOrScript:

     

       
280
       
280
       
-
       
    if lib.isAttrs argsOrScript && ! lib.isDerivation argsOrScript

     

       
281
       
281
       
-
       
    then makeScriptWriter (argsOrScript // {

     

       
282
       
282
       
-
       
      interpreter = "${lib.getExe pkgs.fish} --no-config";

     

       
283
       
283
       
-
       
      check = "${lib.getExe pkgs.fish} --no-config --no-execute";  # syntax check only

     

       
284
       
284
       
-
       
    }) name

     

       
285
       
285
       
-
       
    else makeScriptWriter {

     

       
286
       
286
       
-
       
      interpreter = "${lib.getExe pkgs.fish} --no-config";

     

       
287
       
287
       
-
       
      check = "${lib.getExe pkgs.fish} --no-config --no-execute";  # syntax check only

     

       
288
       
288
       
-
       
    } name argsOrScript;

     

       
412
       
412
       
+
       
  writeFish =

     

       
413
       
413
       
+
       
    name: argsOrScript:

     

       
414
       
414
       
+
       
    if lib.isAttrs argsOrScript && !lib.isDerivation argsOrScript then

     

       
415
       
415
       
+
       
      makeScriptWriter (

     

       
416
       
416
       
+
       
        argsOrScript

     

       
417
       
417
       
+
       
        // {

     

       
418
       
418
       
+
       
          interpreter = "${lib.getExe pkgs.fish} --no-config";

     

       
419
       
419
       
+
       
          check = "${lib.getExe pkgs.fish} --no-config --no-execute"; # syntax check only

     

       
420
       
420
       
+
       
        }

     

       
421
       
421
       
+
       
      ) name

     

       
422
       
422
       
+
       
    else

     

       
423
       
423
       
+
       
      makeScriptWriter {

     

       
424
       
424
       
+
       
        interpreter = "${lib.getExe pkgs.fish} --no-config";

     

       
425
       
425
       
+
       
        check = "${lib.getExe pkgs.fish} --no-config --no-execute"; # syntax check only

     

       
426
       
426
       
+
       
      } name argsOrScript;

     

       
289
       
427
       
 
       


     

       
290
       
428
       
 
       
  # Like writeScriptBin but the first line is a shebang to fish

     

       
291
       
429
       
 
       
  #

     
···

       
306
       
444
       
 
       
  #     ''

     

       
307
       
445
       
 
       
  #       hello

     

       
308
       
446
       
 
       
  #     ''

     

       
309
       
309
       
-
       
  writeFishBin = name:

     

       
310
       
310
       
-
       
    writeFish "/bin/${name}";

     

       
447
       
447
       
+
       
  writeFishBin = name: writeFish "/bin/${name}";

     

       
311
       
448
       
 
       


     

       
312
       
449
       
 
       
  # writeHaskell takes a name, an attrset with libraries and haskell version (both optional)

     

       
313
       
450
       
 
       
  # and some haskell source code and returns an executable.

     
···

       
318
       
455
       
 
       
  #

     

       
319
       
456
       
 
       
  #     main = launchMissiles

     

       
320
       
457
       
 
       
  #   '';

     

       
321
       
321
       
-
       
  writeHaskell = name: {

     

       
322
       
322
       
-
       
    ghc ? pkgs.ghc,

     

       
323
       
323
       
-
       
    ghcArgs ? [],

     

       
324
       
324
       
-
       
    libraries ? [],

     

       
325
       
325
       
-
       
    makeWrapperArgs ? [],

     

       
326
       
326
       
-
       
    strip ? true,

     

       
327
       
327
       
-
       
    threadedRuntime ? true,

     

       
328
       
328
       
-
       
  }:

     

       
458
       
458
       
+
       
  writeHaskell =

     

       
459
       
459
       
+
       
    name:

     

       
460
       
460
       
+
       
    {

     

       
461
       
461
       
+
       
      ghc ? pkgs.ghc,

     

       
462
       
462
       
+
       
      ghcArgs ? [ ],

     

       
463
       
463
       
+
       
      libraries ? [ ],

     

       
464
       
464
       
+
       
      makeWrapperArgs ? [ ],

     

       
465
       
465
       
+
       
      strip ? true,

     

       
466
       
466
       
+
       
      threadedRuntime ? true,

     

       
467
       
467
       
+
       
    }:

     

       
329
       
468
       
 
       
    let

     

       
330
       
469
       
 
       
      appendIfNotSet = el: list: if elem el list then list else list ++ [ el ];

     

       
331
       
470
       
 
       
      ghcArgs' = if threadedRuntime then appendIfNotSet "-threaded" ghcArgs else ghcArgs;

     

       
332
       
471
       
 
       


     

       
333
       
333
       
-
       
    in makeBinWriter {

     

       
472
       
472
       
+
       
    in

     

       
473
       
473
       
+
       
    makeBinWriter {

     

       
334
       
474
       
 
       
      compileScript = ''

     

       
335
       
475
       
 
       
        cp $contentPath tmp.hs

     

       
336
       
336
       
-
       
        ${(ghc.withPackages (_: libraries ))}/bin/ghc ${lib.escapeShellArgs ghcArgs'} tmp.hs

     

       
476
       
476
       
+
       
        ${(ghc.withPackages (_: libraries))}/bin/ghc ${lib.escapeShellArgs ghcArgs'} tmp.hs

     

       
337
       
477
       
 
       
        mv tmp $out

     

       
338
       
478
       
 
       
      '';

     

       
339
       
479
       
 
       
      inherit makeWrapperArgs strip;

     

       
340
       
480
       
 
       
    } name;

     

       
341
       
481
       
 
       


     

       
342
       
482
       
 
       
  # writeHaskellBin takes the same arguments as writeHaskell but outputs a directory (like writeScriptBin)

     

       
343
       
343
       
-
       
  writeHaskellBin = name:

     

       
344
       
344
       
-
       
    writeHaskell "/bin/${name}";

     

       
483
       
483
       
+
       
  writeHaskellBin = name: writeHaskell "/bin/${name}";

     

       
345
       
484
       
 
       


     

       
346
       
485
       
 
       
  # Like writeScript but the first line is a shebang to nu

     

       
347
       
486
       
 
       
  #

     
···

       
362
       
501
       
 
       
  #     ''

     

       
363
       
502
       
 
       
  #       hello

     

       
364
       
503
       
 
       
  #     ''

     

       
365
       
365
       
-
       
  writeNu = name: argsOrScript:

     

       
366
       
366
       
-
       
    if lib.isAttrs argsOrScript && ! lib.isDerivation argsOrScript

     

       
367
       
367
       
-
       
    then makeScriptWriter (argsOrScript // { interpreter = "${lib.getExe pkgs.nushell} --no-config-file"; }) name

     

       
368
       
368
       
-
       
    else makeScriptWriter { interpreter = "${lib.getExe pkgs.nushell} --no-config-file"; } name argsOrScript;

     

       
369
       
369
       
-
       


     

       
504
       
504
       
+
       
  writeNu =

     

       
505
       
505
       
+
       
    name: argsOrScript:

     

       
506
       
506
       
+
       
    if lib.isAttrs argsOrScript && !lib.isDerivation argsOrScript then

     

       
507
       
507
       
+
       
      makeScriptWriter (

     

       
508
       
508
       
+
       
        argsOrScript // { interpreter = "${lib.getExe pkgs.nushell} --no-config-file"; }

     

       
509
       
509
       
+
       
      ) name

     

       
510
       
510
       
+
       
    else

     

       
511
       
511
       
+
       
      makeScriptWriter { interpreter = "${lib.getExe pkgs.nushell} --no-config-file"; } name argsOrScript;

     

       
370
       
512
       
 
       


     

       
371
       
513
       
 
       
  # Like writeScriptBin but the first line is a shebang to nu

     

       
372
       
514
       
 
       
  #

     
···

       
387
       
529
       
 
       
  #    ''

     

       
388
       
530
       
 
       
  #      hello

     

       
389
       
531
       
 
       
  #    ''

     

       
390
       
390
       
-
       
  writeNuBin = name:

     

       
391
       
391
       
-
       
    writeNu "/bin/${name}";

     

       
532
       
532
       
+
       
  writeNuBin = name: writeNu "/bin/${name}";

     

       
392
       
533
       
 
       


     

       
393
       
534
       
 
       
  # makeRubyWriter takes ruby and compatible rubyPackages and produces ruby script writer,

     

       
394
       
535
       
 
       
  # If any libraries are specified, ruby.withPackages is used as interpreter, otherwise the "bare" ruby is used.

     

       
395
       
395
       
-
       
  makeRubyWriter = ruby: rubyPackages: buildRubyPackages: name: { libraries ? [], ... } @ args:

     

       
396
       
396
       
-
       
  makeScriptWriter (

     

       
397
       
397
       
-
       
    (builtins.removeAttrs args ["libraries"])

     

       
398
       
398
       
-
       
    // {

     

       
399
       
399
       
-
       
      interpreter =

     

       
400
       
400
       
-
       
        if libraries == []

     

       
401
       
401
       
-
       
        then "${ruby}/bin/ruby"

     

       
402
       
402
       
-
       
        else "${(ruby.withPackages (ps: libraries))}/bin/ruby";

     

       
403
       
403
       
-
       
      # Rubocop doesn't seem to like running in this fashion.

     

       
404
       
404
       
-
       
      #check = (writeDash "rubocop.sh" ''

     

       
405
       
405
       
-
       
      #  exec ${lib.getExe buildRubyPackages.rubocop} "$1"

     

       
406
       
406
       
-
       
      #'');

     

       
407
       
407
       
-
       
    }

     

       
408
       
408
       
-
       
  ) name;

     

       
536
       
536
       
+
       
  makeRubyWriter =

     

       
537
       
537
       
+
       
    ruby: rubyPackages: buildRubyPackages: name:

     

       
538
       
538
       
+
       
    {

     

       
539
       
539
       
+
       
      libraries ? [ ],

     

       
540
       
540
       
+
       
      ...

     

       
541
       
541
       
+
       
    }@args:

     

       
542
       
542
       
+
       
    makeScriptWriter (

     

       
543
       
543
       
+
       
      (builtins.removeAttrs args [ "libraries" ])

     

       
544
       
544
       
+
       
      // {

     

       
545
       
545
       
+
       
        interpreter =

     

       
546
       
546
       
+
       
          if libraries == [ ] then "${ruby}/bin/ruby" else "${(ruby.withPackages (ps: libraries))}/bin/ruby";

     

       
547
       
547
       
+
       
        # Rubocop doesn't seem to like running in this fashion.

     

       
548
       
548
       
+
       
        #check = (writeDash "rubocop.sh" ''

     

       
549
       
549
       
+
       
        #  exec ${lib.getExe buildRubyPackages.rubocop} "$1"

     

       
550
       
550
       
+
       
        #'');

     

       
551
       
551
       
+
       
      }

     

       
552
       
552
       
+
       
    ) name;

     

       
409
       
553
       
 
       


     

       
410
       
554
       
 
       
  # Like writeScript but the first line is a shebang to ruby

     

       
411
       
555
       
 
       
  #

     
···

       
415
       
559
       
 
       
  #   ''

     

       
416
       
560
       
 
       
  writeRuby = makeRubyWriter pkgs.ruby pkgs.rubyPackages buildPackages.rubyPackages;

     

       
417
       
561
       
 
       


     

       
418
       
418
       
-
       
  writeRubyBin = name:

     

       
419
       
419
       
-
       
    writeRuby "/bin/${name}";

     

       
562
       
562
       
+
       
  writeRubyBin = name: writeRuby "/bin/${name}";

     

       
420
       
563
       
 
       


     

       
421
       
564
       
 
       
  # makeLuaWriter takes lua and compatible luaPackages and produces lua script writer,

     

       
422
       
565
       
 
       
  # which validates the script with luacheck at build time. If any libraries are specified,

     

       
423
       
566
       
 
       
  # lua.withPackages is used as interpreter, otherwise the "bare" lua is used.

     

       
424
       
424
       
-
       
  makeLuaWriter = lua: luaPackages: buildLuaPackages: name: { libraries ? [], ... } @ args:

     

       
425
       
425
       
-
       
  makeScriptWriter (

     

       
426
       
426
       
-
       
    (builtins.removeAttrs args ["libraries"])

     

       
427
       
427
       
-
       
    // {

     

       
428
       
428
       
-
       
      interpreter = lua.interpreter;

     

       
567
       
567
       
+
       
  makeLuaWriter =

     

       
568
       
568
       
+
       
    lua: luaPackages: buildLuaPackages: name:

     

       
569
       
569
       
+
       
    {

     

       
570
       
570
       
+
       
      libraries ? [ ],

     

       
571
       
571
       
+
       
      ...

     

       
572
       
572
       
+
       
    }@args:

     

       
573
       
573
       
+
       
    makeScriptWriter (

     

       
574
       
574
       
+
       
      (builtins.removeAttrs args [ "libraries" ])

     

       
575
       
575
       
+
       
      // {

     

       
576
       
576
       
+
       
        interpreter = lua.interpreter;

     

       
429
       
577
       
 
       
        # if libraries == []

     

       
430
       
578
       
 
       
        # then lua.interpreter

     

       
431
       
579
       
 
       
        # else (lua.withPackages (ps: libraries)).interpreter

     

       
432
       
580
       
 
       
        # This should support packages! I just cant figure out why some dependency collision happens whenever I try to run this.

     

       
433
       
433
       
-
       
      check = (writeDash "luacheck.sh" ''

     

       
434
       
434
       
-
       
        exec ${buildLuaPackages.luacheck}/bin/luacheck "$1"

     

       
435
       
435
       
-
       
      '');

     

       
436
       
436
       
-
       
    }

     

       
437
       
437
       
-
       
   ) name;

     

       
581
       
581
       
+
       
        check = (

     

       
582
       
582
       
+
       
          writeDash "luacheck.sh" ''

     

       
583
       
583
       
+
       
            exec ${buildLuaPackages.luacheck}/bin/luacheck "$1"

     

       
584
       
584
       
+
       
          ''

     

       
585
       
585
       
+
       
        );

     

       
586
       
586
       
+
       
      }

     

       
587
       
587
       
+
       
    ) name;

     

       
438
       
588
       
 
       


     

       
439
       
589
       
 
       
  # writeLua takes a name an attributeset with libraries and some lua source code and

     

       
440
       
590
       
 
       
  # returns an executable (should also work with luajit)

     
···

       
458
       
608
       
 
       
  # ''

     

       
459
       
609
       
 
       
  writeLua = makeLuaWriter pkgs.lua pkgs.luaPackages buildPackages.luaPackages;

     

       
460
       
610
       
 
       


     

       
461
       
461
       
-
       
  writeLuaBin = name:

     

       
462
       
462
       
-
       
    writeLua "/bin/${name}";

     

       
611
       
611
       
+
       
  writeLuaBin = name: writeLua "/bin/${name}";

     

       
463
       
612
       
 
       


     

       
464
       
464
       
-
       
  writeRust = name: {

     

       
465
       
465
       
-
       
    makeWrapperArgs ? [],

     

       
466
       
466
       
-
       
    rustc ? pkgs.rustc,

     

       
467
       
467
       
-
       
    rustcArgs ? [],

     

       
468
       
468
       
-
       
    strip ? true,

     

       
469
       
469
       
-
       
  }:

     

       
470
       
470
       
-
       
  let

     

       
471
       
471
       
-
       
    darwinArgs = lib.optionals stdenv.isDarwin [ "-L${lib.getLib libiconv}/lib" ];

     

       
472
       
472
       
-
       
  in

     

       
613
       
613
       
+
       
  writeRust =

     

       
614
       
614
       
+
       
    name:

     

       
615
       
615
       
+
       
    {

     

       
616
       
616
       
+
       
      makeWrapperArgs ? [ ],

     

       
617
       
617
       
+
       
      rustc ? pkgs.rustc,

     

       
618
       
618
       
+
       
      rustcArgs ? [ ],

     

       
619
       
619
       
+
       
      strip ? true,

     

       
620
       
620
       
+
       
    }:

     

       
621
       
621
       
+
       
    let

     

       
622
       
622
       
+
       
      darwinArgs = lib.optionals stdenv.isDarwin [ "-L${lib.getLib libiconv}/lib" ];

     

       
623
       
623
       
+
       
    in

     

       
473
       
624
       
 
       
    makeBinWriter {

     

       
474
       
625
       
 
       
      compileScript = ''

     

       
475
       
626
       
 
       
        cp "$contentPath" tmp.rs

     

       
476
       
476
       
-
       
        PATH=${lib.makeBinPath [pkgs.gcc]} ${rustc}/bin/rustc ${lib.escapeShellArgs rustcArgs} ${lib.escapeShellArgs darwinArgs} -o "$out" tmp.rs

     

       
627
       
627
       
+
       
        PATH=${lib.makeBinPath [ pkgs.gcc ]} ${rustc}/bin/rustc ${lib.escapeShellArgs rustcArgs} ${lib.escapeShellArgs darwinArgs} -o "$out" tmp.rs

     

       
477
       
628
       
 
       
      '';

     

       
478
       
629
       
 
       
      inherit makeWrapperArgs strip;

     

       
479
       
630
       
 
       
    } name;

     

       
480
       
631
       
 
       


     

       
481
       
481
       
-
       
  writeRustBin = name:

     

       
482
       
482
       
-
       
    writeRust "/bin/${name}";

     

       
632
       
632
       
+
       
  writeRustBin = name: writeRust "/bin/${name}";

     

       
483
       
633
       
 
       


     

       
484
       
634
       
 
       
  # writeJS takes a name an attributeset with libraries and some JavaScript sourcecode and

     

       
485
       
635
       
 
       
  # returns an executable

     
···

       
491
       
641
       
 
       
  #     var result = UglifyJS.minify(code);

     

       
492
       
642
       
 
       
  #     console.log(result.code);

     

       
493
       
643
       
 
       
  #   ''

     

       
494
       
494
       
-
       
  writeJS = name: { libraries ? [] }: content:

     

       
495
       
495
       
-
       
  let

     

       
496
       
496
       
-
       
    node-env = pkgs.buildEnv {

     

       
497
       
497
       
-
       
      name = "node";

     

       
498
       
498
       
-
       
      paths = libraries;

     

       
499
       
499
       
-
       
      pathsToLink = [

     

       
500
       
500
       
-
       
        "/lib/node_modules"

     

       
501
       
501
       
-
       
      ];

     

       
502
       
502
       
-
       
    };

     

       
503
       
503
       
-
       
  in writeDash name ''

     

       
504
       
504
       
-
       
    export NODE_PATH=${node-env}/lib/node_modules

     

       
505
       
505
       
-
       
    exec ${lib.getExe pkgs.nodejs} ${pkgs.writeText "js" content} "$@"

     

       
506
       
506
       
-
       
  '';

     

       
644
       
644
       
+
       
  writeJS =

     

       
645
       
645
       
+
       
    name:

     

       
646
       
646
       
+
       
    {

     

       
647
       
647
       
+
       
      libraries ? [ ],

     

       
648
       
648
       
+
       
    }:

     

       
649
       
649
       
+
       
    content:

     

       
650
       
650
       
+
       
    let

     

       
651
       
651
       
+
       
      node-env = pkgs.buildEnv {

     

       
652
       
652
       
+
       
        name = "node";

     

       
653
       
653
       
+
       
        paths = libraries;

     

       
654
       
654
       
+
       
        pathsToLink = [ "/lib/node_modules" ];

     

       
655
       
655
       
+
       
      };

     

       
656
       
656
       
+
       
    in

     

       
657
       
657
       
+
       
    writeDash name ''

     

       
658
       
658
       
+
       
      export NODE_PATH=${node-env}/lib/node_modules

     

       
659
       
659
       
+
       
      exec ${lib.getExe pkgs.nodejs} ${pkgs.writeText "js" content} "$@"

     

       
660
       
660
       
+
       
    '';

     

       
507
       
661
       
 
       


     

       
508
       
662
       
 
       
  # writeJSBin takes the same arguments as writeJS but outputs a directory (like writeScriptBin)

     

       
509
       
509
       
-
       
  writeJSBin = name:

     

       
510
       
510
       
-
       
    writeJS "/bin/${name}";

     

       
663
       
663
       
+
       
  writeJSBin = name: writeJS "/bin/${name}";

     

       
511
       
664
       
 
       


     

       
512
       
665
       
 
       
  awkFormatNginx = builtins.toFile "awkFormat-nginx.awk" ''

     

       
513
       
666
       
 
       
    awk -f

     
···

       
515
       
668
       
 
       
    /\{/{ctx++;idx=1}

     

       
516
       
669
       
 
       
    /\}/{ctx--}

     

       
517
       
670
       
 
       
    {id="";for(i=idx;i<ctx;i++)id=sprintf("%s%s", id, "\t");printf "%s%s\n", id, $0}

     

       
518
       
518
       
-
       
   '';

     

       
671
       
671
       
+
       
  '';

     

       
519
       
672
       
 
       


     

       
520
       
520
       
-
       
  writeNginxConfig = name: text: pkgs.runCommandLocal name {

     

       
521
       
521
       
-
       
    inherit text;

     

       
522
       
522
       
-
       
    passAsFile = [ "text" ];

     

       
523
       
523
       
-
       
    nativeBuildInputs = [ gixy ];

     

       
524
       
524
       
-
       
  } /* sh */ ''

     

       
525
       
525
       
-
       
    # nginx-config-formatter has an error - https://github.com/1connect/nginx-config-formatter/issues/16

     

       
526
       
526
       
-
       
    awk -f ${awkFormatNginx} "$textPath" | sed '/^\s*$/d' > $out

     

       
527
       
527
       
-
       
    gixy $out

     

       
528
       
528
       
-
       
  '';

     

       
673
       
673
       
+
       
  writeNginxConfig =

     

       
674
       
674
       
+
       
    name: text:

     

       
675
       
675
       
+
       
    pkgs.runCommandLocal name

     

       
676
       
676
       
+
       
      {

     

       
677
       
677
       
+
       
        inherit text;

     

       
678
       
678
       
+
       
        passAsFile = [ "text" ];

     

       
679
       
679
       
+
       
        nativeBuildInputs = [ gixy ];

     

       
680
       
680
       
+
       
      } # sh

     

       
681
       
681
       
+
       
      ''

     

       
682
       
682
       
+
       
        # nginx-config-formatter has an error - https://github.com/1connect/nginx-config-formatter/issues/16

     

       
683
       
683
       
+
       
        awk -f ${awkFormatNginx} "$textPath" | sed '/^\s*$/d' > $out

     

       
684
       
684
       
+
       
        gixy $out

     

       
685
       
685
       
+
       
      '';

     

       
529
       
686
       
 
       


     

       
530
       
687
       
 
       
  # writePerl takes a name an attributeset with libraries and some perl sourcecode and

     

       
531
       
688
       
 
       
  # returns an executable

     
···

       
535
       
692
       
 
       
  #     use boolean;

     

       
536
       
693
       
 
       
  #     print "Howdy!\n" if true;

     

       
537
       
694
       
 
       
  #   ''

     

       
538
       
538
       
-
       
  writePerl = name: { libraries ? [], ... } @ args:

     

       
695
       
695
       
+
       
  writePerl =

     

       
696
       
696
       
+
       
    name:

     

       
697
       
697
       
+
       
    {

     

       
698
       
698
       
+
       
      libraries ? [ ],

     

       
699
       
699
       
+
       
      ...

     

       
700
       
700
       
+
       
    }@args:

     

       
539
       
701
       
 
       
    makeScriptWriter (

     

       
540
       
540
       
-
       
      (builtins.removeAttrs args ["libraries"])

     

       
702
       
702
       
+
       
      (builtins.removeAttrs args [ "libraries" ])

     

       
541
       
703
       
 
       
      // {

     

       
542
       
704
       
 
       
        interpreter = "${lib.getExe (pkgs.perl.withPackages (p: libraries))}";

     

       
543
       
705
       
 
       
      }

     

       
544
       
706
       
 
       
    ) name;

     

       
545
       
707
       
 
       


     

       
546
       
708
       
 
       
  # writePerlBin takes the same arguments as writePerl but outputs a directory (like writeScriptBin)

     

       
547
       
547
       
-
       
  writePerlBin = name:

     

       
548
       
548
       
-
       
    writePerl "/bin/${name}";

     

       
709
       
709
       
+
       
  writePerlBin = name: writePerl "/bin/${name}";

     

       
549
       
710
       
 
       


     

       
550
       
711
       
 
       
  # makePythonWriter takes python and compatible pythonPackages and produces python script writer,

     

       
551
       
712
       
 
       
  # which validates the script with flake8 at build time. If any libraries are specified,

     

       
552
       
713
       
 
       
  # python.withPackages is used as interpreter, otherwise the "bare" python is used.

     

       
553
       
553
       
-
       
  makePythonWriter = python: pythonPackages: buildPythonPackages: name: { libraries ? [], flakeIgnore ? [], ... } @ args:

     

       
554
       
554
       
-
       
  let

     

       
555
       
555
       
-
       
    ignoreAttribute = optionalString (flakeIgnore != []) "--ignore ${concatMapStringsSep "," escapeShellArg flakeIgnore}";

     

       
556
       
556
       
-
       
  in

     

       
557
       
557
       
-
       
  makeScriptWriter

     

       
558
       
558
       
-
       
    (

     

       
559
       
559
       
-
       
      (builtins.removeAttrs args ["libraries" "flakeIgnore"])

     

       
714
       
714
       
+
       
  makePythonWriter =

     

       
715
       
715
       
+
       
    python: pythonPackages: buildPythonPackages: name:

     

       
716
       
716
       
+
       
    {

     

       
717
       
717
       
+
       
      libraries ? [ ],

     

       
718
       
718
       
+
       
      flakeIgnore ? [ ],

     

       
719
       
719
       
+
       
      ...

     

       
720
       
720
       
+
       
    }@args:

     

       
721
       
721
       
+
       
    let

     

       
722
       
722
       
+
       
      ignoreAttribute =

     

       
723
       
723
       
+
       
        optionalString (flakeIgnore != [ ])

     

       
724
       
724
       
+
       
          "--ignore ${concatMapStringsSep "," escapeShellArg flakeIgnore}";

     

       
725
       
725
       
+
       
    in

     

       
726
       
726
       
+
       
    makeScriptWriter (

     

       
727
       
727
       
+
       
      (builtins.removeAttrs args [

     

       
728
       
728
       
+
       
        "libraries"

     

       
729
       
729
       
+
       
        "flakeIgnore"

     

       
730
       
730
       
+
       
      ])

     

       
560
       
731
       
 
       
      // {

     

       
561
       
732
       
 
       
        interpreter =

     

       
562
       
733
       
 
       
          if pythonPackages != pkgs.pypy2Packages || pythonPackages != pkgs.pypy3Packages then

     

       
563
       
563
       
-
       
            if libraries == []

     

       
564
       
564
       
-
       
            then python.interpreter

     

       
565
       
565
       
-
       
            else (python.withPackages (ps: libraries)).interpreter

     

       
566
       
566
       
-
       
          else python.interpreter

     

       
567
       
567
       
-
       
        ;

     

       
568
       
568
       
-
       
        check = optionalString python.isPy3k (writeDash "pythoncheck.sh" ''

     

       
569
       
569
       
-
       
          exec ${buildPythonPackages.flake8}/bin/flake8 --show-source ${ignoreAttribute} "$1"

     

       
570
       
570
       
-
       
        '');

     

       
734
       
734
       
+
       
            if libraries == [ ] then python.interpreter else (python.withPackages (ps: libraries)).interpreter

     

       
735
       
735
       
+
       
          else

     

       
736
       
736
       
+
       
            python.interpreter;

     

       
737
       
737
       
+
       
        check = optionalString python.isPy3k (

     

       
738
       
738
       
+
       
          writeDash "pythoncheck.sh" ''

     

       
739
       
739
       
+
       
            exec ${buildPythonPackages.flake8}/bin/flake8 --show-source ${ignoreAttribute} "$1"

     

       
740
       
740
       
+
       
          ''

     

       
741
       
741
       
+
       
        );

     

       
571
       
742
       
 
       
      }

     

       
572
       
572
       
-
       
    )

     

       
573
       
573
       
-
       
    name;

     

       
743
       
743
       
+
       
    ) name;

     

       
574
       
744
       
 
       


     

       
575
       
745
       
 
       
  # writePyPy2 takes a name an attributeset with libraries and some pypy2 sourcecode and

     

       
576
       
746
       
 
       
  # returns an executable

     
···

       
587
       
757
       
 
       
  writePyPy2 = makePythonWriter pkgs.pypy2 pkgs.pypy2Packages buildPackages.pypy2Packages;

     

       
588
       
758
       
 
       


     

       
589
       
759
       
 
       
  # writePyPy2Bin takes the same arguments as writePyPy2 but outputs a directory (like writeScriptBin)

     

       
590
       
590
       
-
       
  writePyPy2Bin = name:

     

       
591
       
591
       
-
       
    writePyPy2 "/bin/${name}";

     

       
760
       
760
       
+
       
  writePyPy2Bin = name: writePyPy2 "/bin/${name}";

     

       
592
       
761
       
 
       


     

       
593
       
762
       
 
       
  # writePython3 takes a name an attributeset with libraries and some python3 sourcecode and

     

       
594
       
763
       
 
       
  # returns an executable

     
···

       
605
       
774
       
 
       
  writePython3 = makePythonWriter pkgs.python3 pkgs.python3Packages buildPackages.python3Packages;

     

       
606
       
775
       
 
       


     

       
607
       
776
       
 
       
  # writePython3Bin takes the same arguments as writePython3 but outputs a directory (like writeScriptBin)

     

       
608
       
608
       
-
       
  writePython3Bin = name:

     

       
609
       
609
       
-
       
    writePython3 "/bin/${name}";

     

       
777
       
777
       
+
       
  writePython3Bin = name: writePython3 "/bin/${name}";

     

       
610
       
778
       
 
       


     

       
611
       
779
       
 
       
  # writePyPy3 takes a name an attributeset with libraries and some pypy3 sourcecode and

     

       
612
       
780
       
 
       
  # returns an executable

     
···

       
623
       
791
       
 
       
  writePyPy3 = makePythonWriter pkgs.pypy3 pkgs.pypy3Packages buildPackages.pypy3Packages;

     

       
624
       
792
       
 
       


     

       
625
       
793
       
 
       
  # writePyPy3Bin takes the same arguments as writePyPy3 but outputs a directory (like writeScriptBin)

     

       
626
       
626
       
-
       
  writePyPy3Bin = name:

     

       
627
       
627
       
-
       
    writePyPy3 "/bin/${name}";

     

       
794
       
794
       
+
       
  writePyPy3Bin = name: writePyPy3 "/bin/${name}";

     

       
628
       
795
       
 
       


     

       
796
       
796
       
+
       
  makeFSharpWriter =

     

       
797
       
797
       
+
       
    {

     

       
798
       
798
       
+
       
      dotnet-sdk ? pkgs.dotnet-sdk,

     

       
799
       
799
       
+
       
      fsi-flags ? "",

     

       
800
       
800
       
+
       
      libraries ? _: [ ],

     

       
801
       
801
       
+
       
      ...

     

       
802
       
802
       
+
       
    }@args:

     

       
803
       
803
       
+
       
    nameOrPath:

     

       
804
       
804
       
+
       
    let

     

       
805
       
805
       
+
       
      fname = last (builtins.split "/" nameOrPath);

     

       
806
       
806
       
+
       
      path = if strings.hasSuffix ".fsx" nameOrPath then nameOrPath else "${nameOrPath}.fsx";

     

       
807
       
807
       
+
       
      _nugetDeps = mkNugetDeps {

     

       
808
       
808
       
+
       
        name = "${fname}-nuget-deps";

     

       
809
       
809
       
+
       
        nugetDeps = libraries;

     

       
810
       
810
       
+
       
      };

     

       
629
       
811
       
 
       


     

       
630
       
630
       
-
       
  makeFSharpWriter = { dotnet-sdk ? pkgs.dotnet-sdk, fsi-flags ? "", libraries ? _: [], ... } @ args: nameOrPath:

     

       
631
       
631
       
-
       
  let

     

       
632
       
632
       
-
       
    fname = last (builtins.split "/" nameOrPath);

     

       
633
       
633
       
-
       
    path = if strings.hasSuffix ".fsx" nameOrPath then nameOrPath else "${nameOrPath}.fsx";

     

       
634
       
634
       
-
       
    _nugetDeps = mkNugetDeps { name = "${fname}-nuget-deps"; nugetDeps = libraries; };

     

       
812
       
812
       
+
       
      nuget-source = mkNugetSource {

     

       
813
       
813
       
+
       
        name = "${fname}-nuget-source";

     

       
814
       
814
       
+
       
        description = "Nuget source with the dependencies for ${fname}";

     

       
815
       
815
       
+
       
        deps = [ _nugetDeps ];

     

       
816
       
816
       
+
       
      };

     

       
635
       
817
       
 
       


     

       
636
       
636
       
-
       
    nuget-source = mkNugetSource {

     

       
637
       
637
       
-
       
      name = "${fname}-nuget-source";

     

       
638
       
638
       
-
       
      description = "Nuget source with the dependencies for ${fname}";

     

       
639
       
639
       
-
       
      deps = [ _nugetDeps ];

     

       
640
       
640
       
-
       
    };

     

       
818
       
818
       
+
       
      fsi = writeBash "fsi" ''

     

       
819
       
819
       
+
       
        export HOME=$NIX_BUILD_TOP/.home

     

       
820
       
820
       
+
       
        export DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1

     

       
821
       
821
       
+
       
        export DOTNET_CLI_TELEMETRY_OPTOUT=1

     

       
822
       
822
       
+
       
        export DOTNET_NOLOGO=1

     

       
823
       
823
       
+
       
        script="$1"; shift

     

       
824
       
824
       
+
       
        ${lib.getExe dotnet-sdk} fsi --quiet --nologo --readline- ${fsi-flags} "$@" < "$script"

     

       
825
       
825
       
+
       
      '';

     

       
641
       
826
       
 
       


     

       
642
       
642
       
-
       
    fsi = writeBash "fsi" ''

     

       
643
       
643
       
-
       
      export HOME=$NIX_BUILD_TOP/.home

     

       
644
       
644
       
-
       
      export DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1

     

       
645
       
645
       
-
       
      export DOTNET_CLI_TELEMETRY_OPTOUT=1

     

       
646
       
646
       
-
       
      export DOTNET_NOLOGO=1

     

       
647
       
647
       
-
       
      script="$1"; shift

     

       
648
       
648
       
-
       
      ${lib.getExe dotnet-sdk} fsi --quiet --nologo --readline- ${fsi-flags} "$@" < "$script"

     

       
649
       
649
       
-
       
    '';

     

       
650
       
650
       
-
       


     

       
651
       
651
       
-
       
  in content: makeScriptWriter (

     

       
652
       
652
       
-
       
    (builtins.removeAttrs args ["dotnet-sdk" "fsi-flags" "libraries"])

     

       
653
       
653
       
-
       
    // {

     

       
654
       
654
       
-
       
      interpreter = fsi;

     

       
655
       
655
       
-
       
    }

     

       
656
       
656
       
-
       
  ) path

     

       
657
       
657
       
-
       
  ''

     

       
658
       
658
       
-
       
    #i "nuget: ${nuget-source}/lib"

     

       
659
       
659
       
-
       
    ${ content }

     

       
660
       
660
       
-
       
    exit 0

     

       
661
       
661
       
-
       
  '';

     

       
827
       
827
       
+
       
    in

     

       
828
       
828
       
+
       
    content:

     

       
829
       
829
       
+
       
    makeScriptWriter

     

       
830
       
830
       
+
       
      (

     

       
831
       
831
       
+
       
        (builtins.removeAttrs args [

     

       
832
       
832
       
+
       
          "dotnet-sdk"

     

       
833
       
833
       
+
       
          "fsi-flags"

     

       
834
       
834
       
+
       
          "libraries"

     

       
835
       
835
       
+
       
        ])

     

       
836
       
836
       
+
       
        // {

     

       
837
       
837
       
+
       
          interpreter = fsi;

     

       
838
       
838
       
+
       
        }

     

       
839
       
839
       
+
       
      )

     

       
840
       
840
       
+
       
      path

     

       
841
       
841
       
+
       
      ''

     

       
842
       
842
       
+
       
        #i "nuget: ${nuget-source}/lib"

     

       
843
       
843
       
+
       
        ${content}

     

       
844
       
844
       
+
       
        exit 0

     

       
845
       
845
       
+
       
      '';

     

       
662
       
846
       
 
       


     

       
663
       
663
       
-
       
  writeFSharp =

     

       
664
       
664
       
-
       
    makeFSharpWriter {};

     

       
847
       
847
       
+
       
  writeFSharp = makeFSharpWriter { };

     

       
665
       
848
       
 
       


     

       
666
       
666
       
-
       
  writeFSharpBin = name:

     

       
667
       
667
       
-
       
    writeFSharp "/bin/${name}";

     

       
849
       
849
       
+
       
  writeFSharpBin = name: writeFSharp "/bin/${name}";

     

       
668
       
850
       
 
       
}