commit b1044bdc9d0c66c7182116cce971f108dd7c8d02 · pyrox.dev/nixpkgs

+3 -1

doc/languages-frameworks/dotnet.section.md

···

       138
       138
        
         src = ./.;

     

       139
       139
        
       

     

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

     

       141
       141
       -
         nugetDeps = ./deps.nix; # File generated with `nix-build -A package.passthru.fetch-deps`.

     

       141
       141
       +
         # File generated with `nix-build -A package.passthru.fetch-deps`.

     

       142
       142
       +
         # To run fetch-deps when this file does not yet exist, set nugetDeps to null

     

       143
       143
       +
         nugetDeps = ./deps.nix;

     

       142
       144
        
       

     

       143
       145
        
         projectReferences = [ referencedProject ]; # `referencedProject` must contain `nupkg` in the folder structure.

     

       144
       146

+17 -1

pkgs/build-support/dotnet/build-dotnet-module/default.nix

···

       158
       158
        
           dotnet-sdk

     

       159
       159
        
         ];

     

       160
       160
        
       

     

       161
       161
       +
         # Parse the version attr into a format acceptable for the Version msbuild property

     

       162
       162
       +
         # The actual version attr is saved in InformationalVersion, which accepts an arbitrary string

     

       163
       163
       +
         versionForDotnet = if !(lib.hasAttr "version" args) || args.version == null

     

       164
       164
       +
         then null else let

     

       165
       165
       +
           components = lib.pipe args.version [

     

       166
       166
       +
             lib.splitVersion

     

       167
       167
       +
             (lib.filter (x: (lib.strings.match "[0-9]+" x) != null))

     

       168
       168
       +
             (lib.filter (x: (lib.toInt x) < 65535)) # one version component in dotnet has to fit in 16 bits

     

       169
       169
       +
           ];

     

       170
       170
       +
         in if (lib.length components) == 0

     

       171
       171
       +
         then null

     

       172
       172
       +
         else lib.concatStringsSep "." ((lib.take 4 components)

     

       173
       173
       +
           ++ (if (lib.length components) < 4

     

       174
       174
       +
              then lib.replicate (4 - (lib.length components)) "0"

     

       175
       175
       +
              else [ ]));

     

       176
       176
       +
       

     

       161
       177
        
         makeWrapperArgs = args.makeWrapperArgs or [ ] ++ [

     

       162
       178
        
           "--prefix LD_LIBRARY_PATH : ${dotnet-sdk.icu}/lib"

     

       163
       179
        
         ];

     
···

       172
       188
        
       

     

       173
       189
        
         passthru = {

     

       174
       190
        
           inherit nuget-source;

     

       175
       175
       -
         } // lib.optionalAttrs (nugetDepsFile != null) {

     

       191
       191
       +
         } // lib.optionalAttrs (!lib.isDerivation nugetDeps) {

     

       176
       192
        
           fetch-deps =

     

       177
       193
        
             let

     

       178
       194
        
               flags = dotnetFlags ++ dotnetRestoreFlags;

+7 -2

pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-build-hook.sh

···

       24
       24
        
               dotnetBuildFlags+=("-p:UseAppHost=true")

     

       25
       25
        
           fi

     

       26
       26
        
       

     

       27
       27
       +
           local versionFlags=()

     

       27
       28
        
           if [ "${version-}" ]; then

     

       28
       28
       -
               local -r versionFlag="-p:Version=${version-}"

     

       29
       29
       +
               versionFlags+=("-p:InformationalVersion=${version-}")

     

       30
       30
       +
           fi

     

       31
       31
       +
       

     

       32
       32
       +
           if [ "${versionForDotnet-}" ]; then

     

       33
       33
       +
               versionFlags+=("-p:Version=${versionForDotnet-}")

     

       29
       34
        
           fi

     

       30
       35
        
       

     

       31
       36
        
           dotnetBuild() {

     
···

       43
       48
        
                   -p:Deterministic=true \

     

       44
       49
        
                   --configuration "@buildType@" \

     

       45
       50
        
                   --no-restore \

     

       46
       46
       -
                   ${versionFlag-} \

     

       51
       51
       +
                   ${versionFlags[@]} \

     

       47
       52
        
                   ${runtimeIdFlags[@]} \

     

       48
       53
        
                   ${dotnetBuildFlags[@]}  \

     

       49
       54
        
                   ${dotnetFlags[@]}