patch of not-for-upstream: nix: add nilla shell · round #0 · pull #1 · freshlybakedca.ke/git

+27

nilla.nix

···

       1
       1
       +
       # SPDX-FileCopyrightText: 2025 FreshlyBakedCake

     

       2
       2
       +
       #

     

       3
       3
       +
       # SPDX-License-Identifier: MIT

     

       4
       4
       +
       

     

       5
       5
       +
       let

     

       6
       6
       +
         pins = import ./npins;

     

       7
       7
       +
       

     

       8
       8
       +
         nilla = import pins.nilla;

     

       9
       9
       +
       in

     

       10
       10
       +
       nilla.create (

     

       11
       11
       +
         { config, lib }:

     

       12
       12
       +
         {

     

       13
       13
       +
           config = {

     

       14
       14
       +
             inputs.nixpkgs.src = pins.nixpkgs;

     

       15
       15
       +
             

     

       16
       16
       +
             shells.default = {

     

       17
       17
       +
               systems = [ "x86_64-linux" ];

     

       18
       18
       +
       

     

       19
       19
       +
               shell =

     

       20
       20
       +
                 { mkShell, git }:

     

       21
       21
       +
                 mkShell {

     

       22
       22
       +
                   inputsFrom = [ git ];

     

       23
       23
       +
                 };

     

       24
       24
       +
             };

     

       25
       25
       +
           };

     

       26
       26
       +
         }

     

       27
       27
       +
       )

+247

npins/default.nix

···

       1
       1
       +
       /*

     

       2
       2
       +
         This file is provided under the MIT licence:

     

       3
       3
       +
       

     

       4
       4
       +
         Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

     

       5
       5
       +
       

     

       6
       6
       +
         The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

     

       7
       7
       +
       

     

       8
       8
       +
         THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

     

       9
       9
       +
       */

     

       10
       10
       +
       # Generated by npins. Do not modify; will be overwritten regularly

     

       11
       11
       +
       let

     

       12
       12
       +
         # Backwards-compatibly make something that previously didn't take any arguments take some

     

       13
       13
       +
         # The function must return an attrset, and will unfortunately be eagerly evaluated

     

       14
       14
       +
         # Same thing, but it catches eval errors on the default argument so that one may still call it with other arguments

     

       15
       15
       +
         mkFunctor =

     

       16
       16
       +
           fn:

     

       17
       17
       +
           let

     

       18
       18
       +
             e = builtins.tryEval (fn { });

     

       19
       19
       +
           in

     

       20
       20
       +
           (if e.success then e.value else { error = fn { }; }) // { __functor = _self: fn; };

     

       21
       21
       +
       

     

       22
       22
       +
         # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/lists.nix#L295

     

       23
       23
       +
         range =

     

       24
       24
       +
           first: last: if first > last then [ ] else builtins.genList (n: first + n) (last - first + 1);

     

       25
       25
       +
       

     

       26
       26
       +
         # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/strings.nix#L257

     

       27
       27
       +
         stringToCharacters = s: map (p: builtins.substring p 1 s) (range 0 (builtins.stringLength s - 1));

     

       28
       28
       +
       

     

       29
       29
       +
         # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/strings.nix#L269

     

       30
       30
       +
         stringAsChars = f: s: concatStrings (map f (stringToCharacters s));

     

       31
       31
       +
         concatStrings = builtins.concatStringsSep "";

     

       32
       32
       +
       

     

       33
       33
       +
         # If the environment variable NPINS_OVERRIDE_${name} is set, then use

     

       34
       34
       +
         # the path directly as opposed to the fetched source.

     

       35
       35
       +
         # (Taken from Niv for compatibility)

     

       36
       36
       +
         mayOverride =

     

       37
       37
       +
           name: path:

     

       38
       38
       +
           let

     

       39
       39
       +
             envVarName = "NPINS_OVERRIDE_${saneName}";

     

       40
       40
       +
             saneName = stringAsChars (c: if (builtins.match "[a-zA-Z0-9]" c) == null then "_" else c) name;

     

       41
       41
       +
             ersatz = builtins.getEnv envVarName;

     

       42
       42
       +
           in

     

       43
       43
       +
           if ersatz == "" then

     

       44
       44
       +
             path

     

       45
       45
       +
           else

     

       46
       46
       +
             # this turns the string into an actual Nix path (for both absolute and

     

       47
       47
       +
             # relative paths)

     

       48
       48
       +
             builtins.trace "Overriding path of \"${name}\" with \"${ersatz}\" due to set \"${envVarName}\"" (

     

       49
       49
       +
               if builtins.substring 0 1 ersatz == "/" then

     

       50
       50
       +
                 /. + ersatz

     

       51
       51
       +
               else

     

       52
       52
       +
                 /. + builtins.getEnv "PWD" + "/${ersatz}"

     

       53
       53
       +
             );

     

       54
       54
       +
       

     

       55
       55
       +
         mkSource =

     

       56
       56
       +
           name: spec:

     

       57
       57
       +
           {

     

       58
       58
       +
             pkgs ? null,

     

       59
       59
       +
           }:

     

       60
       60
       +
           assert spec ? type;

     

       61
       61
       +
           let

     

       62
       62
       +
             # Unify across builtin and pkgs fetchers.

     

       63
       63
       +
             # `fetchGit` requires a wrapper because of slight API differences.

     

       64
       64
       +
             fetchers =

     

       65
       65
       +
               if pkgs == null then

     

       66
       66
       +
                 {

     

       67
       67
       +
                   inherit (builtins) fetchTarball fetchurl;

     

       68
       68
       +
                   # For some fucking reason, fetchGit has a different signature than the other builtin fetchers …

     

       69
       69
       +
                   fetchGit = args: (builtins.fetchGit args).outPath;

     

       70
       70
       +
                 }

     

       71
       71
       +
               else

     

       72
       72
       +
                 {

     

       73
       73
       +
                   fetchTarball =

     

       74
       74
       +
                     {

     

       75
       75
       +
                       url,

     

       76
       76
       +
                       sha256,

     

       77
       77
       +
                     }:

     

       78
       78
       +
                     pkgs.fetchzip {

     

       79
       79
       +
                       inherit url sha256;

     

       80
       80
       +
                       extension = "tar";

     

       81
       81
       +
                     };

     

       82
       82
       +
                   inherit (pkgs) fetchurl;

     

       83
       83
       +
                   fetchGit =

     

       84
       84
       +
                     {

     

       85
       85
       +
                       url,

     

       86
       86
       +
                       submodules,

     

       87
       87
       +
                       rev,

     

       88
       88
       +
                       name,

     

       89
       89
       +
                       narHash,

     

       90
       90
       +
                     }:

     

       91
       91
       +
                     pkgs.fetchgit {

     

       92
       92
       +
                       inherit url rev name;

     

       93
       93
       +
                       fetchSubmodules = submodules;

     

       94
       94
       +
                       hash = narHash;

     

       95
       95
       +
                     };

     

       96
       96
       +
                 };

     

       97
       97
       +
       

     

       98
       98
       +
             # Dispatch to the correct code path based on the type

     

       99
       99
       +
             path =

     

       100
       100
       +
               if spec.type == "Git" then

     

       101
       101
       +
                 mkGitSource fetchers spec

     

       102
       102
       +
               else if spec.type == "GitRelease" then

     

       103
       103
       +
                 mkGitSource fetchers spec

     

       104
       104
       +
               else if spec.type == "PyPi" then

     

       105
       105
       +
                 mkPyPiSource fetchers spec

     

       106
       106
       +
               else if spec.type == "Channel" then

     

       107
       107
       +
                 mkChannelSource fetchers spec

     

       108
       108
       +
               else if spec.type == "Tarball" then

     

       109
       109
       +
                 mkTarballSource fetchers spec

     

       110
       110
       +
               else if spec.type == "Container" then

     

       111
       111
       +
                 mkContainerSource pkgs spec

     

       112
       112
       +
               else

     

       113
       113
       +
                 builtins.throw "Unknown source type ${spec.type}";

     

       114
       114
       +
           in

     

       115
       115
       +
           spec // { outPath = mayOverride name path; };

     

       116
       116
       +
       

     

       117
       117
       +
         mkGitSource =

     

       118
       118
       +
           {

     

       119
       119
       +
             fetchTarball,

     

       120
       120
       +
             fetchGit,

     

       121
       121
       +
             ...

     

       122
       122
       +
           }:

     

       123
       123
       +
           {

     

       124
       124
       +
             repository,

     

       125
       125
       +
             revision,

     

       126
       126
       +
             url ? null,

     

       127
       127
       +
             submodules,

     

       128
       128
       +
             hash,

     

       129
       129
       +
             ...

     

       130
       130
       +
           }:

     

       131
       131
       +
           assert repository ? type;

     

       132
       132
       +
           # At the moment, either it is a plain git repository (which has an url), or it is a GitHub/GitLab repository

     

       133
       133
       +
           # In the latter case, there we will always be an url to the tarball

     

       134
       134
       +
           if url != null && !submodules then

     

       135
       135
       +
             fetchTarball {

     

       136
       136
       +
               inherit url;

     

       137
       137
       +
               sha256 = hash;

     

       138
       138
       +
             }

     

       139
       139
       +
           else

     

       140
       140
       +
             let

     

       141
       141
       +
               url =

     

       142
       142
       +
                 if repository.type == "Git" then

     

       143
       143
       +
                   repository.url

     

       144
       144
       +
                 else if repository.type == "GitHub" then

     

       145
       145
       +
                   "https://github.com/${repository.owner}/${repository.repo}.git"

     

       146
       146
       +
                 else if repository.type == "GitLab" then

     

       147
       147
       +
                   "${repository.server}/${repository.repo_path}.git"

     

       148
       148
       +
                 else

     

       149
       149
       +
                   throw "Unrecognized repository type ${repository.type}";

     

       150
       150
       +
               urlToName =

     

       151
       151
       +
                 url: rev:

     

       152
       152
       +
                 let

     

       153
       153
       +
                   matched = builtins.match "^.*/([^/]*)(\\.git)?$" url;

     

       154
       154
       +
       

     

       155
       155
       +
                   short = builtins.substring 0 7 rev;

     

       156
       156
       +
       

     

       157
       157
       +
                   appendShort = if (builtins.match "[a-f0-9]*" rev) != null then "-${short}" else "";

     

       158
       158
       +
                 in

     

       159
       159
       +
                 "${if matched == null then "source" else builtins.head matched}${appendShort}";

     

       160
       160
       +
               name = urlToName url revision;

     

       161
       161
       +
             in

     

       162
       162
       +
             fetchGit {

     

       163
       163
       +
               rev = revision;

     

       164
       164
       +
               narHash = hash;

     

       165
       165
       +
       

     

       166
       166
       +
               inherit name submodules url;

     

       167
       167
       +
             };

     

       168
       168
       +
       

     

       169
       169
       +
         mkPyPiSource =

     

       170
       170
       +
           { fetchurl, ... }:

     

       171
       171
       +
           {

     

       172
       172
       +
             url,

     

       173
       173
       +
             hash,

     

       174
       174
       +
             ...

     

       175
       175
       +
           }:

     

       176
       176
       +
           fetchurl {

     

       177
       177
       +
             inherit url;

     

       178
       178
       +
             sha256 = hash;

     

       179
       179
       +
           };

     

       180
       180
       +
       

     

       181
       181
       +
         mkChannelSource =

     

       182
       182
       +
           { fetchTarball, ... }:

     

       183
       183
       +
           {

     

       184
       184
       +
             url,

     

       185
       185
       +
             hash,

     

       186
       186
       +
             ...

     

       187
       187
       +
           }:

     

       188
       188
       +
           fetchTarball {

     

       189
       189
       +
             inherit url;

     

       190
       190
       +
             sha256 = hash;

     

       191
       191
       +
           };

     

       192
       192
       +
       

     

       193
       193
       +
         mkTarballSource =

     

       194
       194
       +
           { fetchTarball, ... }:

     

       195
       195
       +
           {

     

       196
       196
       +
             url,

     

       197
       197
       +
             locked_url ? url,

     

       198
       198
       +
             hash,

     

       199
       199
       +
             ...

     

       200
       200
       +
           }:

     

       201
       201
       +
           fetchTarball {

     

       202
       202
       +
             url = locked_url;

     

       203
       203
       +
             sha256 = hash;

     

       204
       204
       +
           };

     

       205
       205
       +
       

     

       206
       206
       +
         mkContainerSource =

     

       207
       207
       +
           pkgs:

     

       208
       208
       +
           {

     

       209
       209
       +
             image_name,

     

       210
       210
       +
             image_tag,

     

       211
       211
       +
             image_digest,

     

       212
       212
       +
             ...

     

       213
       213
       +
           }:

     

       214
       214
       +
           if pkgs == null then

     

       215
       215
       +
             builtins.throw "container sources require passing in a Nixpkgs value: https://github.com/andir/npins/blob/master/README.md#using-the-nixpkgs-fetchers"

     

       216
       216
       +
           else

     

       217
       217
       +
             pkgs.dockerTools.pullImage {

     

       218
       218
       +
               imageName = image_name;

     

       219
       219
       +
               imageDigest = image_digest;

     

       220
       220
       +
               finalImageTag = image_tag;

     

       221
       221
       +
             };

     

       222
       222
       +
       in

     

       223
       223
       +
       mkFunctor (

     

       224
       224
       +
         {

     

       225
       225
       +
           input ? ./sources.json,

     

       226
       226
       +
         }:

     

       227
       227
       +
         let

     

       228
       228
       +
           data =

     

       229
       229
       +
             if builtins.isPath input then

     

       230
       230
       +
               # while `readFile` will throw an error anyways if the path doesn't exist,

     

       231
       231
       +
               # we still need to check beforehand because *our* error can be caught but not the one from the builtin

     

       232
       232
       +
               # *piegames sighs*

     

       233
       233
       +
               if builtins.pathExists input then

     

       234
       234
       +
                 builtins.fromJSON (builtins.readFile input)

     

       235
       235
       +
               else

     

       236
       236
       +
                 throw "Input path ${toString input} does not exist"

     

       237
       237
       +
             else if builtins.isAttrs input then

     

       238
       238
       +
               input

     

       239
       239
       +
             else

     

       240
       240
       +
               throw "Unsupported input type ${builtins.typeOf input}, must be a path or an attrset";

     

       241
       241
       +
           version = data.version;

     

       242
       242
       +
         in

     

       243
       243
       +
         if version == 7 then

     

       244
       244
       +
           builtins.mapAttrs (name: spec: mkFunctor (mkSource name spec)) data.pins

     

       245
       245
       +
         else

     

       246
       246
       +
           throw "Unsupported format version ${toString version} in sources.json. Try running `npins upgrade`"

     

       247
       247
       +
       )

+27

npins/sources.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "pins": {

     

       3
       3
       +
           "nilla": {

     

       4
       4
       +
             "type": "GitRelease",

     

       5
       5
       +
             "repository": {

     

       6
       6
       +
               "type": "GitHub",

     

       7
       7
       +
               "owner": "nilla-nix",

     

       8
       8
       +
               "repo": "nilla"

     

       9
       9
       +
             },

     

       10
       10
       +
             "pre_releases": true,

     

       11
       11
       +
             "version_upper_bound": null,

     

       12
       12
       +
             "release_prefix": null,

     

       13
       13
       +
             "submodules": false,

     

       14
       14
       +
             "version": "v0.0.0-alpha.14",

     

       15
       15
       +
             "revision": "2e98ae315a592ad6b6de44670514c048dcc88dc7",

     

       16
       16
       +
             "url": "https://api.github.com/repos/nilla-nix/nilla/tarball/refs/tags/v0.0.0-alpha.14",

     

       17
       17
       +
             "hash": "sha256-15lwhWcMonJH6UholMMHDc+p2BoSpGA4AYGrsXQA9Do="

     

       18
       18
       +
           },

     

       19
       19
       +
           "nixpkgs": {

     

       20
       20
       +
             "type": "Channel",

     

       21
       21
       +
             "name": "nixpkgs-unstable",

     

       22
       22
       +
             "url": "https://releases.nixos.org/nixpkgs/nixpkgs-25.11pre887438.a7fc11be66bd/nixexprs.tar.xz",

     

       23
       23
       +
             "hash": "sha256-LDT9wuUZtjPfmviCcVWif5+7j4kBI2mWaZwjNNeg4eg="

     

       24
       24
       +
           }

     

       25
       25
       +
         },

     

       26
       26
       +
         "version": 7

     

       27
       27
       +
       }