commit bccae9e7c0f234d41ae7c9aebbaaf4f65a27282c · pyrox.dev/nixpkgs

+44 -21

doc/languages-frameworks/dotnet.section.md

···

       99
       99
        
       To package Dotnet applications, you can use `buildDotnetModule`. This has similar arguments to `stdenv.mkDerivation`, with the following additions:

     

       100
       100
        
       

     

       101
       101
        
       * `projectFile` is used for specifying the dotnet project file, relative to the source root. These have `.sln` (entire solution) or `.csproj` (single project) file extensions. This can be a list of multiple projects as well. When omitted, will attempt to find and build the solution (`.sln`). If running into problems, make sure to set it to a file (or a list of files) with the `.csproj` extension - building applications as entire solutions is not fully supported by the .NET CLI.

     

       102
       102
       -
       * `nugetDeps` takes either a path to a `deps.nix` file, or a derivation. The `deps.nix` file can be generated using the script attached to `passthru.fetch-deps`. For compatibility, if the argument is a list of derivations, they will be added to `buildInputs`.

     

       102
       102
       +
       * `nugetDeps` should be a path to a JSON file, a path to a nix file (deprecated), a derivation, or a list of derivations. A `deps.json` file can be generated using the script attached to `passthru.fetch-deps`, which is the preferred method. All `nugetDeps` packages are added to `buildInputs`.

     

       103
       103
        
       ::: {.note}

     

       104
       104
       -
       For more detail about managing the `deps.nix` file, see [Generating and updating NuGet dependencies](#generating-and-updating-nuget-dependencies)

     

       104
       104
       +
       For more detail about managing the `deps.json` file, see [Generating and updating NuGet dependencies](#generating-and-updating-nuget-dependencies)

     

       105
       105
        
       :::

     

       106
       106
        
       

     

       107
       107
        
       * `packNupkg` is used to pack project as a `nupkg`, and installs it to `$out/share`. If set to `true`, the derivation can be used as a dependency for another dotnet project by adding it to `buildInputs`.

     
···

       133
       133
        
       * `dotnetPackFlags` can be used to pass flags to `dotnet pack`. Used only if `packNupkg` is set to `true`.

     

       134
       134
        
       * `dotnetFlags` can be used to pass flags to all of the above phases.

     

       135
       135
        
       

     

       136
       136
       -
       When packaging a new application, you need to fetch its dependencies. Create an empty `deps.nix`, set `nugetDeps = ./deps.nix`, then run `nix-build -A package.fetch-deps` to generate a script that will build the lockfile for you.

     

       136
       136
       +
       When packaging a new application, you need to fetch its dependencies. Create an empty `deps.json`, set `nugetDeps = ./deps.json`, then run `nix-build -A package.fetch-deps` to generate a script that will build the lockfile for you.

     

       137
       137
        
       

     

       138
       138
        
       Here is an example `default.nix`, using some of the previously discussed arguments:

     

       139
       139
        
       ```nix

     
···

       148
       148
        
         src = ./.;

     

       149
       149
        
       

     

       150
       150
        
         projectFile = "src/project.sln";

     

       151
       151
       -
         nugetDeps = ./deps.nix; # see "Generating and updating NuGet dependencies" section for details

     

       151
       151
       +
         nugetDeps = ./deps.json; # see "Generating and updating NuGet dependencies" section for details

     

       152
       152
        
       

     

       153
       153
        
         buildInputs = [ referencedProject ]; # `referencedProject` must contain `nupkg` in the folder structure.

     

       154
       154
        
       

     
···

       225
       225
        
       ## Generating and updating NuGet dependencies {#generating-and-updating-nuget-dependencies}

     

       226
       226
        
       

     

       227
       227
        
       When writing a new expression, you can use the generated `fetch-deps` script to initialise the lockfile.

     

       228
       228
       -
       After setting `nugetDeps` to the desired location of the lockfile (e.g. `./deps.nix`),

     

       228
       228
       +
       After setting `nugetDeps` to the desired location of the lockfile (e.g. `./deps.json`),

     

       229
       229
        
       build the script with `nix-build -A package.fetch-deps` and then run the result.

     

       230
       230
        
       (When the root attr is your package, it's simply `nix-build -A fetch-deps`.)

     

       231
       231
        
       

     
···

       236
       236
        
       ```bash

     

       237
       237
        
       $ dotnet restore --packages out

     

       238
       238
        
         Determining projects to restore...

     

       239
       239
       -
         Restored /home/lychee/Celeste64/Celeste64.csproj (in 1.21 sec).

     

       239
       239
       +
         Restored /home/ggg/git-credential-manager/src/shared/Git-Credential-Manager/Git-Credential-Manager.csproj (in 1.21 sec).

     

       240
       240
        
       ```

     

       241
       241
        
       

     

       242
       242
       -
       Next, use `nuget-to-nix` tool provided in nixpkgs to generate a lockfile to `deps.nix` from

     

       242
       242
       +
       Next, use `nuget-to-json` tool provided in nixpkgs to generate a lockfile to `deps.json` from

     

       243
       243
        
       the packages inside the `out` directory.

     

       244
       244
        
       

     

       245
       245
        
       ```bash

     

       246
       246
       -
       $ nuget-to-nix out > deps.nix

     

       246
       246
       +
       $ nuget-to-json out > deps.json

     

       247
       247
        
       ```

     

       248
       248
       -
       Which `nuget-to-nix` will generate an output similar to below

     

       249
       249
       -
       ```nix

     

       250
       250
       -
       { fetchNuGet }: [

     

       251
       251
       -
         (fetchNuGet { pname = "FosterFramework"; version = "0.1.15-alpha"; hash = "sha256-lM6eYgOGjl1fx6WFD7rnRi/YAQieM0mx60h0p5dr+l8="; })

     

       252
       252
       -
         (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-x64"; version = "8.0.1"; hash = "sha256-QbUQXjCzr8j8u/5X0af9jE++EugdoxMhT08F49MZX74="; })

     

       253
       253
       -
         (fetchNuGet { pname = "Microsoft.NET.ILLink.Tasks"; version = "8.0.1"; hash = "sha256-SopZpGaZ48/8dpUwDFDM3ix+g1rP4Yqs1PGuzRp+K7c="; })

     

       254
       254
       -
         (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-x64"; version = "8.0.1"; hash = "sha256-jajBI5GqG2IIcsIMgxTHfXbMapoXrZGl/EEhShwYq7w="; })

     

       255
       255
       -
         (fetchNuGet { pname = "SharpGLTF.Core"; version = "1.0.0-alpha0031"; hash = "sha256-Bs4baD5wNIH6wAbGK4Xaem0i3luQkOQs37izBWdFx1I="; })

     

       256
       256
       -
         (fetchNuGet { pname = "SharpGLTF.Runtime"; version = "1.0.0-alpha0031"; hash = "sha256-TwJO6b8ubmwBQh6NyHha8+JT5zHDJ4dROBbsEbUaa1M="; })

     

       257
       257
       -
         (fetchNuGet { pname = "Sledge.Formats"; version = "1.2.2"; hash = "sha256-0Ddhuwpu3wwIzA4NuPaEVdMkx6tUukh8uKD6nKoxFPg="; })

     

       258
       258
       -
         (fetchNuGet { pname = "Sledge.Formats.Map"; version = "1.1.5"; hash = "sha256-hkYJ2iWIz7vhPWlDOw2fvTenlh+4/D/37Z71tCEwnK8="; })

     

       259
       259
       -
         (fetchNuGet { pname = "System.Numerics.Vectors"; version = "4.5.0"; hash = "sha256-qdSTIFgf2htPS+YhLGjAGiLN8igCYJnCCo6r78+Q+c8="; })

     

       248
       248
       +
       Which `nuget-to-json` will generate an output similar to below

     

       249
       249
       +
       ```json

     

       250
       250
       +
       [

     

       251
       251
       +
         {

     

       252
       252
       +
           "pname": "Avalonia",

     

       253
       253
       +
           "version": "11.1.3",

     

       254
       254
       +
           "hash": "sha256-kz+k/vkuWoL0XBvRT8SadMOmmRCFk9W/J4k/IM6oYX0="

     

       255
       255
       +
         },

     

       256
       256
       +
         {

     

       257
       257
       +
           "pname": "Avalonia.Angle.Windows.Natives",

     

       258
       258
       +
           "version": "2.1.22045.20230930",

     

       259
       259
       +
           "hash": "sha256-RxPcWUT3b/+R3Tu5E5ftpr5ppCLZrhm+OTsi0SwW3pc="

     

       260
       260
       +
         },

     

       261
       261
       +
         {

     

       262
       262
       +
           "pname": "Avalonia.BuildServices",

     

       263
       263
       +
           "version": "0.0.29",

     

       264
       264
       +
           "hash": "sha256-WPHRMNowRnYSCh88DWNBCltWsLPyOfzXGzBqLYE7tRY="

     

       265
       265
       +
         },

     

       266
       266
       +
         // ...

     

       267
       267
       +
         {

     

       268
       268
       +
           "pname": "System.Runtime.CompilerServices.Unsafe",

     

       269
       269
       +
           "version": "6.0.0",

     

       270
       270
       +
           "hash": "sha256-bEG1PnDp7uKYz/OgLOWs3RWwQSVYm+AnPwVmAmcgp2I="

     

       271
       271
       +
         },

     

       272
       272
       +
         {

     

       273
       273
       +
           "pname": "System.Security.Cryptography.ProtectedData",

     

       274
       274
       +
           "version": "4.5.0",

     

       275
       275
       +
           "hash": "sha256-Z+X1Z2lErLL7Ynt2jFszku6/IgrngO3V1bSfZTBiFIc="

     

       276
       276
       +
         },

     

       277
       277
       +
         {

     

       278
       278
       +
           "pname": "Tmds.DBus.Protocol",

     

       279
       279
       +
           "version": "0.16.0",

     

       280
       280
       +
           "hash": "sha256-vKYEaa1EszR7alHj48R8G3uYArhI+zh2ZgiBv955E98="

     

       281
       281
       +
         }

     

       260
       282
        
       ]

     

       283
       283
       +
       

     

       261
       284
        
       ```

     

       262
       285
        
       

     

       263
       263
       -
       Finally, you move the `deps.nix` file to the appropriate location to be used by `nugetDeps`, then you're all set!

     

       286
       286
       +
       Finally, you move the `deps.json` file to the appropriate location to be used by `nugetDeps`, then you're all set!

     

       264
       287
        
       

     

       265
       288
        
       If you ever need to update the dependencies of a package, you instead do

     

       266
       289

+30 -10

pkgs/build-support/dotnet/add-nuget-deps/default.nix

···

       12
       12
        
       }:

     

       13
       13
        
       

     

       14
       14
        
       {

     

       15
       15
       +
         /**

     

       16
       16
       +
           A list of nuget packages.

     

       17
       17
       +
       

     

       18
       18
       +
           Should be a JSON file with arguments to `fetchNupkg`:

     

       19
       19
       +
       

     

       20
       20
       +
           ```json

     

       21
       21
       +
           [

     

       22
       22
       +
             {

     

       23
       23
       +
               "pname": "AsyncIO",

     

       24
       24
       +
               "version": "0.1.69",

     

       25
       25
       +
               "hash": "sha256-JQKq/U71NQTfPuUqj7z5bALe+d7G1o3GcI8kvVDxy6o="

     

       26
       26
       +
             }

     

       27
       27
       +
           ]

     

       28
       28
       +
           ```

     

       29
       29
       +
       

     

       30
       30
       +
           (to generate this file, use the script generated by `passthru.fetch-deps`)

     

       31
       31
       +
       

     

       32
       32
       +
           Or a derivation (or list of derivations) containing nuget packages.

     

       33
       33
       +
         */

     

       15
       34
        
         nugetDeps,

     

       16
       35
        
         overrideFetchAttrs ? x: { },

     

       17
       36
        
       }:

     
···

       20
       39
        
         attrs = if builtins.isFunction fnOrAttrs then fnOrAttrs finalAttrs else fnOrAttrs;

     

       21
       40
        
       

     

       22
       41
        
         deps =

     

       23
       23
       -
           if (nugetDeps != null) then

     

       24
       24
       -
             if lib.isDerivation nugetDeps then

     

       25
       25
       -
               [ nugetDeps ]

     

       26
       26
       -
             else if lib.isList nugetDeps then

     

       27
       27
       -
               nugetDeps

     

       28
       28
       -
             else

     

       29
       29
       -
               assert (lib.isPath nugetDeps);

     

       30
       30
       -
               callPackage nugetDeps { fetchNuGet = fetchNupkg; }

     

       42
       42
       +
           if nugetDeps == null then

     

       43
       43
       +
             [ ]

     

       44
       44
       +
           else if lib.isDerivation nugetDeps then

     

       45
       45
       +
             [ nugetDeps ]

     

       46
       46
       +
           else if lib.isList nugetDeps then

     

       47
       47
       +
             nugetDeps

     

       48
       48
       +
           else if lib.hasSuffix ".nix" nugetDeps then

     

       49
       49
       +
             assert (lib.isPath nugetDeps);

     

       50
       50
       +
             callPackage nugetDeps { fetchNuGet = fetchNupkg; }

     

       31
       51
        
           else

     

       32
       32
       -
             [ ];

     

       52
       52
       +
             builtins.map fetchNupkg (lib.importJSON nugetDeps);

     

       33
       53
        
       

     

       34
       54
        
         finalPackage = finalAttrs.finalPackage;

     

       35
       55
        
       

     
···

       84
       104
        
       

     

       85
       105
        
               in

     

       86
       106
        
               writeShellScript "${finalPackage.name}-fetch-deps" ''

     

       87
       87
       -
                 set -eu

     

       107
       107
       +
                 set -euo pipefail

     

       88
       108
        
       

     

       89
       109
        
                 echo 'fetching dependencies for' ${lib.escapeShellArg finalPackage.name} >&2

     

       90
       110

+2 -1

pkgs/test/dotnet/nuget-deps/default.nix

···

       38
       38
        
         )

     

       39
       39
        
         {

     

       40
       40
        
           "null" = null;

     

       41
       41
       -
           "file" = ./nuget-deps.nix;

     

       41
       41
       +
           "nix-file" = ./nuget-deps.nix;

     

       42
       42
       +
           "json-file" = ./nuget-deps.json;

     

       42
       43
        
           "derivation" = emptyDirectory;

     

       43
       44
        
           "list" = [ emptyDirectory ];

     

       44
       45
        
         }

pkgs/test/dotnet/nuget-deps/nuget-deps.json