commit 5d979e79ce9bd8e26f3c31a0f8949d99020e16aa · pyrox.dev/nixpkgs

+7 -7

doc/build-helpers/dev-shell-tools.chapter.md

···

       20
       20
        
       

     

       21
       21
        
       ```nix

     

       22
       22
        
       devShellTools.valueToString (builtins.toFile "foo" "bar")

     

       23
       23
       -
       => "/nix/store/...-foo"

     

       23
       23
       +
       # => "/nix/store/...-foo"

     

       24
       24
        
       ```

     

       25
       25
        
       

     

       26
       26
        
       ```nix

     

       27
       27
        
       devShellTools.valueToString false

     

       28
       28
       -
       => ""

     

       28
       28
       +
       # => ""

     

       29
       29
        
       ```

     

       30
       30
        
       

     

       31
       31
        
       :::

     
···

       47
       47
        
           args = [ "-c" "${./builder.sh}" ];

     

       48
       48
        
         };

     

       49
       49
        
       }

     

       50
       50
       -
       => {

     

       51
       51
       -
         name = "foo";

     

       52
       52
       -
         buildInputs = "/nix/store/...-hello /nix/store/...-figlet";

     

       53
       53
       -
         builder = "/nix/store/...-bash";

     

       54
       54
       -
       }

     

       50
       50
       +
       # => {

     

       51
       51
       +
       #  name = "foo";

     

       52
       52
       +
       #  buildInputs = "/nix/store/...-hello /nix/store/...-figlet";

     

       53
       53
       +
       #  builder = "/nix/store/...-bash";

     

       54
       54
       +
       #}

     

       55
       55
        
       ```

     

       56
       56
        
       

     

       57
       57
        
       Note that `args` is not included, because Nix does not added it to the builder process environment.

+2 -2

doc/build-helpers/special/makesetuphook.section.md

···

       9
       9
        
         name = "something-hook";

     

       10
       10
        
         propagatedBuildInputs = [ pkgs.commandsomething ];

     

       11
       11
        
         depsTargetTargetPropagated = [ pkgs.libsomething ];

     

       12
       12
       -
       } ./script.sh;

     

       12
       12
       +
       } ./script.sh

     

       13
       13
        
       ```

     

       14
       14
        
       

     

       15
       15
        
       ### setup hook that depends on the hello package and runs hello and @shell@ is substituted with path to bash {#sec-pkgs.makeSetupHook-usage-example}

     
···

       42
       42
        
             }

     

       43
       43
        
             preConfigureHooks+=(_printHelloHook)

     

       44
       44
        
           ''

     

       45
       45
       -
         );

     

       45
       45
       +
         )

     

       46
       46
        
       ```

     

       47
       47
        
       

     

       48
       48
        
       ## Attributes {#sec-pkgs.makeSetupHook-attributes}

+6 -4

doc/hooks/memcached-test-hook.section.md

···

       20
       20
        
       

     

       21
       21
        
       If you use a custom `checkPhase`, remember to add the `runHook` calls:

     

       22
       22
        
       ```nix

     

       23
       23
       -
         checkPhase ''

     

       23
       23
       +
       {

     

       24
       24
       +
         checkPhase = ''

     

       24
       25
        
           runHook preCheck

     

       25
       26
        
       

     

       26
       27
        
           # ... your tests

     

       27
       28
        
       

     

       28
       29
        
           runHook postCheck

     

       29
       29
       -
         ''

     

       30
       30
       +
         '';

     

       31
       31
       +
       }

     

       30
       32
        
       ```

     

       31
       33
        
       

     

       32
       34
        
       ## Variables {#sec-memcachedTestHook-variables}

     
···

       48
       50
        
         ];

     

       49
       51
        
       

     

       50
       52
        
         preCheck = ''

     

       51
       51
       -
           memcachedTestPort=1234

     

       52
       52
       -
         ''

     

       53
       53
       +
           memcachedTestPort=1234;

     

       54
       54
       +
         '';

     

       53
       55
        
       }

+6 -4

doc/hooks/redis-test-hook.section.md

···

       21
       21
        
       

     

       22
       22
        
       If you use a custom `checkPhase`, remember to add the `runHook` calls:

     

       23
       23
        
       ```nix

     

       24
       24
       -
         checkPhase ''

     

       24
       24
       +
       {

     

       25
       25
       +
         checkPhase = ''

     

       25
       26
        
           runHook preCheck

     

       26
       27
        
       

     

       27
       28
        
           # ... your tests

     

       28
       29
        
       

     

       29
       30
        
           runHook postCheck

     

       30
       30
       -
         ''

     

       31
       31
       +
         '';

     

       32
       32
       +
       }

     

       31
       33
        
       ```

     

       32
       34
        
       

     

       33
       35
        
       ## Variables {#sec-redisTestHook-variables}

     
···

       55
       57
        
         ];

     

       56
       58
        
       

     

       57
       59
        
         preCheck = ''

     

       58
       58
       -
           redisTestPort=6390

     

       59
       59
       -
         ''

     

       60
       60
       +
           redisTestPort=6390;

     

       61
       61
       +
         '';

     

       60
       62
        
       }

+6

doc/languages-frameworks/android.section.md

···

       8
       8
        
       Use the `android-studio-full` attribute for a very complete Android SDK, including system images:

     

       9
       9
        
       

     

       10
       10
        
       ```nix

     

       11
       11
       +
       {

     

       11
       12
        
       buildInputs = [ android-studio-full ];

     

       13
       13
       +
       }

     

       12
       14
        
       ```

     

       13
       15
        
       

     

       14
       16
        
       This is identical to:

     

       15
       17
        
       

     

       16
       18
        
       ```nix

     

       19
       19
       +
       {

     

       17
       20
        
       buildInputs = [ androidStudioPackages.stable.full ];

     

       21
       21
       +
       }

     

       18
       22
        
       ```

     

       19
       23
        
       

     

       20
       24
        
       Alternatively, you can pass composeAndroidPackages to the `withSdk` passthru:

     

       21
       25
        
       

     

       22
       26
        
       ```nix

     

       27
       27
       +
       {

     

       23
       28
        
       buildInputs = [

     

       24
       29
        
         (android-studio.withSdk (androidenv.composeAndroidPackages {

     

       25
       30
        
           includeNDK = true;

     

       26
       31
        
         }).androidsdk)

     

       27
       32
        
       ];

     

       33
       33
       +
       }

     

       28
       34
        
       ```

     

       29
       35
        
       

     

       30
       36
        
       These will export `ANDROID_SDK_ROOT` and `ANDROID_NDK_ROOT` to the SDK and NDK directories

+6 -2

doc/languages-frameworks/astal.section.md

···

       11
       11
        
         pname = "hyprpanel";

     

       12
       12
        
         version = "1.0.0";

     

       13
       13
        
       

     

       14
       14
       -
         src = fetchFromGitHub { ... };

     

       14
       14
       +
         src = fetchFromGitHub {

     

       15
       15
       +
           #...

     

       16
       16
       +
         };

     

       15
       17
        
       

     

       16
       18
        
         # change your entry file (default is `app.ts`)

     

       17
       19
        
         entry = "app.ts";

     
···

       32
       34
        
         # GTK 4 support is opt-in

     

       33
       35
        
         enableGtk4 = true;

     

       34
       36
        
       

     

       35
       35
       -
         meta = { ... };

     

       37
       37
       +
         meta = {

     

       38
       38
       +
           #...

     

       39
       39
       +
         };

     

       36
       40
        
       }

     

       37
       41
        
       ```

     

       38
       42

+1 -1

doc/languages-frameworks/factor.section.md

···

       125
       125
        
         version = "1.0";

     

       126
       126
        
       

     

       127
       127
        
         src = fetchurl {

     

       128
       128
       -
           url = "https://some-forge.org/foo-${finalAttrs.version}.tar.gz"

     

       128
       128
       +
           url = "https://some-forge.org/foo-${finalAttrs.version}.tar.gz";

     

       129
       129
        
         };

     

       130
       130
        
       })

     

       131
       131
        
       ```

+20 -8

doc/languages-frameworks/javascript.section.md

···

       323
       323
        
           npmRoot = ./.;

     

       324
       324
        
           fetcherOpts = {

     

       325
       325
        
             # Pass 'curlOptsList' to 'pkgs.fetchurl' while fetching 'axios'

     

       326
       326
       -
             { "node_modules/axios" = { curlOptsList = [ "--verbose" ]; }; }

     

       326
       326
       +
             "node_modules/axios" = { curlOptsList = [ "--verbose" ]; };

     

       327
       327
        
           };

     

       328
       328
        
         };

     

       329
       329
        
       

     
···

       410
       410
        
         pname = "foo";

     

       411
       411
        
         version = "0-unstable-1980-01-01";

     

       412
       412
        
       

     

       413
       413
       -
         src = ...;

     

       413
       413
       +
         src = {

     

       414
       414
       +
           #...

     

       415
       415
       +
         };

     

       414
       416
        
       

     

       415
       417
        
         nativeBuildInputs = [

     

       416
       418
        
           nodejs

     
···

       439
       441
        
         pname = "foo";

     

       440
       442
        
         version = "0-unstable-1980-01-01";

     

       441
       443
        
       

     

       442
       442
       -
         src = ...;

     

       444
       444
       +
         src = {

     

       445
       445
       +
           # ...

     

       446
       446
       +
         };

     

       443
       447
        
       

     

       444
       448
        
         pnpmInstallFlags = [ "--shamefully-hoist" ];

     

       445
       449
        
       

     
···

       466
       470
        
       ```

     

       467
       471
        
       

     

       468
       472
        
       ```nix

     

       469
       469
       -
         ...

     

       473
       473
       +
       {

     

       474
       474
       +
         # ...

     

       470
       475
        
         pnpmDeps = pnpm.fetchDeps {

     

       471
       471
       -
           ...

     

       476
       476
       +
           # ...

     

       472
       477
        
           sourceRoot = "${finalAttrs.src.name}/frontend";

     

       473
       478
        
         };

     

       474
       479
        
       

     

       475
       480
        
         # by default the working directory is the extracted source

     

       476
       481
        
         pnpmRoot = "frontend";

     

       482
       482
       +
       }

     

       477
       483
        
       ```

     

       478
       484
        
       

     

       479
       485
        
       #### PNPM Workspaces {#javascript-pnpm-workspaces}

     
···

       484
       490
        
       For example:

     

       485
       491
        
       

     

       486
       492
        
       ```nix

     

       487
       487
       -
       ...

     

       493
       493
       +
       {

     

       494
       494
       +
       # ...

     

       488
       495
        
       pnpmWorkspaces = [ "@astrojs/language-server" ];

     

       489
       496
        
       pnpmDeps = pnpm.fetchDeps {

     

       490
       497
        
         inherit (finalAttrs) pnpmWorkspaces;

     

       491
       491
       -
         ...

     

       498
       498
       +
         #...

     

       499
       499
       +
       };

     

       492
       500
        
       }

     

       493
       501
        
       ```

     

       494
       502
        
       

     
···

       498
       506
        
       Usually in such cases, you'd want to use `pnpm --filter=<pnpm workspace name> build` to build your project, as `npmHooks.npmBuildHook` probably won't work. A `buildPhase` based on the following example will probably fit most workspace projects:

     

       499
       507
        
       

     

       500
       508
        
       ```nix

     

       509
       509
       +
       {

     

       501
       510
        
       buildPhase = ''

     

       502
       511
        
         runHook preBuild

     

       503
       512
        
       

     
···

       505
       514
        
       

     

       506
       515
        
         runHook postBuild

     

       507
       516
        
       '';

     

       517
       517
       +
       }

     

       508
       518
        
       ```

     

       509
       519
        
       

     

       510
       520
        
       #### Additional PNPM Commands and settings {#javascript-pnpm-extraCommands}

     
···

       513
       523
        
       set `prePnpmInstall` to the right commands to run. For example:

     

       514
       524
        
       

     

       515
       525
        
       ```nix

     

       526
       526
       +
       {

     

       516
       527
        
       prePnpmInstall = ''

     

       517
       528
        
         pnpm config set dedupe-peer-dependants false

     

       518
       529
        
       '';

     

       519
       530
        
       pnpmDeps = pnpm.fetchDeps {

     

       520
       531
        
         inherit (finalAttrs) prePnpmInstall;

     

       521
       521
       -
         ...

     

       532
       532
       +
         # ...

     

       522
       533
        
       };

     

       534
       534
       +
       }

     

       523
       535
        
       ```

     

       524
       536
        
       

     

       525
       537
        
       In this example, `prePnpmInstall` will be run by both `pnpm.configHook` and by the `pnpm.fetchDeps` builder.

+2 -2

doc/languages-frameworks/maven.section.md

···

       91
       91
        
       

     

       92
       92
        
         # old mvnHash of 1.2.0 maven dependencies

     

       93
       93
        
         mvnHash = "sha256-N9XC1pg6Y4sUiBWIQUf16QSXCuiAPpXEHGlgApviF4I=";

     

       94
       94
       -
       });

     

       94
       94
       +
       })

     

       95
       95
        
       ```

     

       96
       96
        
       :::

     

       97
       97
        
       

     
···

       129
       129
        
           "org.apache.maven.surefire:surefire-junit-platform:3.1.2"

     

       130
       130
        
           "org.junit.platform:junit-platform-launcher:1.10.0"

     

       131
       131
        
         ];

     

       132
       132
       -
       };

     

       132
       132
       +
       }

     

       133
       133
        
       ```

     

       134
       134
        
       :::

     

       135
       135

+8

doc/languages-frameworks/neovim.section.md

···

       116
       116
        
       

     

       117
       117
        
       For instance:

     

       118
       118
        
       ```nix

     

       119
       119
       +
       {

     

       119
       120
        
       rtp-nvim = neovimUtils.buildNeovimPlugin {

     

       120
       121
        
           luaAttr = luaPackages.rtp-nvim;

     

       121
       122
        
       };

     

       123
       123
       +
       }

     

       122
       124
        
       ```

     

       123
       125
        
       To update these packages, you should use the lua updater rather than vim's.

     

       124
       126
        
       

     
···

       164
       166
        
       To only check a specific module, add it manually to the plugin definition [overrides](https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/editors/vim/plugins/overrides.nix).

     

       165
       167
        
       

     

       166
       168
        
       ```nix

     

       169
       169
       +
       {

     

       167
       170
        
         gitsigns-nvim = super.gitsigns-nvim.overrideAttrs {

     

       168
       171
        
           dependencies = [ self.plenary-nvim ];

     

       169
       172
        
           nvimRequireCheck = "gitsigns";

     

       170
       173
        
         };

     

       174
       174
       +
       }

     

       171
       175
        
       ```

     

       172
       176
        
       Some plugins will have lua modules that require a user configuration to function properly or can contain optional lua modules that we dont want to test requiring.

     

       173
       177
        
       We can skip specific modules using `nvimSkipModules`. Similar to `nvimRequireCheck`, it accepts a list of strings.

     

       174
       178
        
       - `nvimSkipModules = [ MODULE1 MODULE2 ];`

     

       175
       179
        
       

     

       176
       180
        
       ```nix

     

       181
       181
       +
       {

     

       177
       182
        
         asyncrun-vim = super.asyncrun-vim.overrideAttrs {

     

       178
       183
        
           nvimSkipModules = [

     

       179
       184
        
             # vim plugin with optional toggleterm integration

     
···

       181
       186
        
             "asyncrun.toggleterm2"

     

       182
       187
        
           ];

     

       183
       188
        
         };

     

       189
       189
       +
       }

     

       184
       190
        
       ```

     

       185
       191
        
       

     

       186
       192
        
       In rare cases, we might not want to actually test loading lua modules for a plugin. In those cases, we can disable `neovimRequireCheck` with `doCheck = false;`.

     

       187
       193
        
       

     

       188
       194
        
       This can be manually added through plugin definition overrides in the [overrides.nix](https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/editors/vim/plugins/overrides.nix).

     

       189
       195
        
       ```nix

     

       196
       196
       +
       {

     

       190
       197
        
         vim-test = super.vim-test.overrideAttrs {

     

       191
       198
        
           # Vim plugin with a test lua file

     

       192
       199
        
           doCheck = false;

     

       193
       200
        
         };

     

       201
       201
       +
       }

     

       194
       202
        
       ```