commit f61d02708f282f224ee4254c558967689645c212 · pyrox.dev/nixpkgs

+2 -4

pkgs/by-name/README.md

···

       1
       1
        
       # Name-based package directories

     

       2
       2
        
       

     

       3
       3
        
       The structure of this directory maps almost directly to top-level package attributes.

     

       4
       4
       -
       This is the recommended way to add new top-level packages to Nixpkgs [when possible](#limitations).

     

       4
       4
       +
       Add new top-level packages to Nixpkgs using this mechanism [whenever possible](#limitations).

     

       5
       5
        
       

     

       6
       6
       -
       Packages found in the named-based structure do not need to be explicitly added to the

     

       7
       7
       -
       `top-level/all-packages.nix` file unless they require overriding the default value

     

       8
       8
       -
       of an implicit attribute (see below).

     

       6
       6
       +
       Packages found in the name-based structure are automatically included, without needing to be added to `all-packages.nix`. However if the implicit attribute defaults need to be changed for a package, this [must still be declared in `all-packages.nix`](#changing-implicit-attribute-defaults).

     

       9
       7
        
       

     

       10
       8
        
       ## Example

     

       11
       9

+2

pkgs/test/nixpkgs-check-by-name/README.md

···

       45
       45
        
       

     

       46
       46
        
       - New manual definitions of `pkgs.${name}` (e.g. in `pkgs/top-level/all-packages.nix`) with `args = { }`

     

       47
       47
        
         (see [nix evaluation checks](#nix-evaluation-checks)) must not be introduced.

     

       48
       48
       +
       - New top-level packages defined using `pkgs.callPackage` must be defined with a package directory.

     

       49
       49
       +
         - Once a top-level package uses `pkgs/by-name`, it also can't be moved back out of it.

     

       48
       50
        
       

     

       49
       51
        
       ## Development

     

       50
       52

+4

pkgs/test/nixpkgs-check-by-name/default.nix

···

       9
       9
        
       }:

     

       10
       10
        
       let

     

       11
       11
        
         runtimeExprPath = ./src/eval.nix;

     

       12
       12
       +
         nixpkgsLibPath = ../../../lib;

     

       12
       13
        
         package =

     

       13
       14
        
           rustPlatform.buildRustPackage {

     

       14
       15
        
             name = "nixpkgs-check-by-name";

     
···

       30
       31
        
               export NIX_STATE_DIR=$TEST_ROOT/var/nix

     

       31
       32
        
               export NIX_STORE_DIR=$TEST_ROOT/store

     

       32
       33
        
       

     

       34
       34
       +
               export NIXPKGS_LIB_PATH=${nixpkgsLibPath}

     

       35
       35
       +
       

     

       33
       36
        
               # Ensure that even if tests run in parallel, we don't get an error

     

       34
       37
        
               # We'd run into https://github.com/NixOS/nix/issues/2706 unless the store is initialised first

     

       35
       38
        
               nix-store --init

     
···

       44
       47
        
             '';

     

       45
       48
        
             passthru.shell = mkShell {

     

       46
       49
        
               env.NIX_CHECK_BY_NAME_EXPR_PATH = toString runtimeExprPath;

     

       50
       50
       +
               env.NIXPKGS_LIB_PATH = toString nixpkgsLibPath;

     

       47
       51
        
               inputsFrom = [ package ];

     

       48
       52
        
             };

     

       49
       53
        
           };

+29 -7

pkgs/test/nixpkgs-check-by-name/src/eval.nix

···

       79
       79
        
               };

     

       80
       80
        
             };

     

       81
       81
        
       

     

       82
       82
       -
         attrInfos = map (name: [

     

       83
       83
       -
           name

     

       84
       84
       -
           (

     

       82
       82
       +
         byNameAttrs = builtins.listToAttrs (map (name: {

     

       83
       83
       +
           inherit name;

     

       84
       84
       +
           value.ByName =

     

       85
       85
        
             if ! pkgs ? ${name} then

     

       86
       86
        
               { Missing = null; }

     

       87
       87
        
             else

     

       88
       88
       -
               { Existing = attrInfo name pkgs.${name}; }

     

       89
       89
       -
           )

     

       90
       90
       -
         ]) attrs;

     

       88
       88
       +
               { Existing = attrInfo name pkgs.${name}; };

     

       89
       89
       +
         }) attrs);

     

       91
       90
        
       

     

       91
       91
       +
         # Information on all attributes that exist but are not in pkgs/by-name.

     

       92
       92
       +
         # We need this to enforce pkgs/by-name for new packages

     

       93
       93
       +
         nonByNameAttrs = builtins.mapAttrs (name: value:

     

       94
       94
       +
           let

     

       95
       95
       +
             output = attrInfo name value;

     

       96
       96
       +
             result = builtins.tryEval (builtins.deepSeq output null);

     

       97
       97
       +
           in

     

       98
       98
       +
           {

     

       99
       99
       +
             NonByName =

     

       100
       100
       +
               if result.success then

     

       101
       101
       +
                 { EvalSuccess = output; }

     

       102
       102
       +
               else

     

       103
       103
       +
                 { EvalFailure = null; };

     

       104
       104
       +
           }

     

       105
       105
       +
         ) (builtins.removeAttrs pkgs attrs);

     

       106
       106
       +
       

     

       107
       107
       +
         # All attributes

     

       108
       108
       +
         attributes = byNameAttrs // nonByNameAttrs;

     

       92
       109
        
       in

     

       93
       93
       -
       attrInfos

     

       110
       110
       +
       # We output them in the form [ [ <name> <value> ] ]` such that the Rust side

     

       111
       111
       +
       # doesn't need to sort them again to get deterministic behavior (good for testing)

     

       112
       112
       +
       map (name: [

     

       113
       113
       +
         name

     

       114
       114
       +
         attributes.${name}

     

       115
       115
       +
       ]) (builtins.attrNames attributes)

+89 -10

pkgs/test/nixpkgs-check-by-name/src/eval.rs

···

       2
       2
        
       use crate::ratchet;

     

       3
       3
        
       use crate::structure;

     

       4
       4
        
       use crate::validation::{self, Validation::Success};

     

       5
       5
       +
       use std::collections::HashMap;

     

       6
       6
       +
       use std::ffi::OsString;

     

       5
       7
        
       use std::path::Path;

     

       6
       8
        
       

     

       7
       9
        
       use anyhow::Context;

     
···

       12
       14
        
       

     

       13
       15
        
       /// Attribute set of this structure is returned by eval.nix

     

       14
       16
        
       #[derive(Deserialize)]

     

       17
       17
       +
       enum Attribute {

     

       18
       18
       +
           /// An attribute that should be defined via pkgs/by-name

     

       19
       19
       +
           ByName(ByNameAttribute),

     

       20
       20
       +
           /// An attribute not defined via pkgs/by-name

     

       21
       21
       +
           NonByName(NonByNameAttribute),

     

       22
       22
       +
       }

     

       23
       23
       +
       

     

       24
       24
       +
       #[derive(Deserialize)]

     

       25
       25
       +
       enum NonByNameAttribute {

     

       26
       26
       +
           /// The attribute doesn't evaluate

     

       27
       27
       +
           EvalFailure,

     

       28
       28
       +
           EvalSuccess(AttributeInfo),

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       #[derive(Deserialize)]

     

       15
       32
        
       enum ByNameAttribute {

     

       16
       33
        
           /// The attribute doesn't exist at all

     

       17
       34
        
           Missing,

     
···

       56
       73
        
       pub fn check_values(

     

       57
       74
        
           nixpkgs_path: &Path,

     

       58
       75
        
           package_names: Vec<String>,

     

       59
       59
       -
           eval_accessible_paths: &[&Path],

     

       76
       76
       +
           eval_nix_path: &HashMap<String, PathBuf>,

     

       60
       77
        
       ) -> validation::Result<ratchet::Nixpkgs> {

     

       61
       78
        
           // Write the list of packages we need to check into a temporary JSON file.

     

       62
       79
        
           // This can then get read by the Nix evaluation.

     
···

       105
       122
        
               .arg(nixpkgs_path);

     

       106
       123
        
       

     

       107
       124
        
           // Also add extra paths that need to be accessible

     

       108
       108
       -
           for path in eval_accessible_paths {

     

       125
       125
       +
           for (name, path) in eval_nix_path {

     

       109
       126
        
               command.arg("-I");

     

       110
       110
       -
               command.arg(path);

     

       127
       127
       +
               let mut name_value = OsString::new();

     

       128
       128
       +
               name_value.push(name);

     

       129
       129
       +
               name_value.push("=");

     

       130
       130
       +
               name_value.push(path);

     

       131
       131
       +
               command.arg(name_value);

     

       111
       132
        
           }

     

       112
       133
        
           command.args(["-I", &expr_path]);

     

       113
       134
        
           command.arg(expr_path);

     
···

       120
       141
        
               anyhow::bail!("Failed to run command {command:?}");

     

       121
       142
        
           }

     

       122
       143
        
           // Parse the resulting JSON value

     

       123
       123
       -
           let attributes: Vec<(String, ByNameAttribute)> = serde_json::from_slice(&result.stdout)

     

       144
       144
       +
           let attributes: Vec<(String, Attribute)> = serde_json::from_slice(&result.stdout)

     

       124
       145
        
               .with_context(|| {

     

       125
       146
        
                   format!(

     

       126
       147
        
                       "Failed to deserialise {}",

     
···

       133
       154
        
                   let relative_package_file = structure::relative_file_for_package(&attribute_name);

     

       134
       155
        
       

     

       135
       156
        
                   use ratchet::RatchetState::*;

     

       157
       157
       +
                   use Attribute::*;

     

       136
       158
        
                   use AttributeInfo::*;

     

       137
       159
        
                   use ByNameAttribute::*;

     

       138
       160
        
                   use CallPackageVariant::*;

     

       161
       161
       +
                   use NonByNameAttribute::*;

     

       139
       162
        
       

     

       140
       163
        
                   let check_result = match attribute_value {

     

       141
       141
       -
                       Missing => NixpkgsProblem::UndefinedAttr {

     

       164
       164
       +
                       // The attribute succeeds evaluation and is NOT defined in pkgs/by-name

     

       165
       165
       +
                       NonByName(EvalSuccess(attribute_info)) => {

     

       166
       166
       +
                           let uses_by_name = match attribute_info {

     

       167
       167
       +
                               // In these cases the package doesn't qualify for being in pkgs/by-name,

     

       168
       168
       +
                               // so the UsesByName ratchet is already as tight as it can be

     

       169
       169
       +
                               NonAttributeSet => Success(Tight),

     

       170
       170
       +
                               NonCallPackage => Success(Tight),

     

       171
       171
       +
                               // This is an odd case when _internalCallByNamePackageFile is used to define a package.

     

       172
       172
       +
                               CallPackage(CallPackageInfo {

     

       173
       173
       +
                                   call_package_variant: Auto,

     

       174
       174
       +
                                   ..

     

       175
       175
       +
                               }) => NixpkgsProblem::InternalCallPackageUsed {

     

       176
       176
       +
                                   attr_name: attribute_name.clone(),

     

       177
       177
       +
                               }

     

       178
       178
       +
                               .into(),

     

       179
       179
       +
                               // Only derivations can be in pkgs/by-name,

     

       180
       180
       +
                               // so this attribute doesn't qualify

     

       181
       181
       +
                               CallPackage(CallPackageInfo {

     

       182
       182
       +
                                   is_derivation: false,

     

       183
       183
       +
                                   ..

     

       184
       184
       +
                               }) => Success(Tight),

     

       185
       185
       +
       

     

       186
       186
       +
                               // The case of an attribute that qualifies:

     

       187
       187
       +
                               // - Uses callPackage

     

       188
       188
       +
                               // - Is a derivation

     

       189
       189
       +
                               CallPackage(CallPackageInfo {

     

       190
       190
       +
                                   is_derivation: true,

     

       191
       191
       +
                                   call_package_variant: Manual { path, empty_arg },

     

       192
       192
       +
                               }) => Success(Loose(ratchet::UsesByName {

     

       193
       193
       +
                                   call_package_path: path,

     

       194
       194
       +
                                   empty_arg,

     

       195
       195
       +
                               })),

     

       196
       196
       +
                           };

     

       197
       197
       +
                           uses_by_name.map(|x| ratchet::Package {

     

       198
       198
       +
                               empty_non_auto_called: Tight,

     

       199
       199
       +
                               uses_by_name: x,

     

       200
       200
       +
                           })

     

       201
       201
       +
                       }

     

       202
       202
       +
                       NonByName(EvalFailure) => {

     

       203
       203
       +
                           // This is a bit of an odd case: We don't even _know_ whether this attribute

     

       204
       204
       +
                           // would qualify for using pkgs/by-name. We can either:

     

       205
       205
       +
                           // - Assume it's not using pkgs/by-name, which has the problem that if a

     

       206
       206
       +
                           //   package evaluation gets broken temporarily, the fix can remove it from

     

       207
       207
       +
                           //   pkgs/by-name again

     

       208
       208
       +
                           // - Assume it's using pkgs/by-name already, which has the problem that if a

     

       209
       209
       +
                           //   package evaluation gets broken temporarily, fixing it requires a move to

     

       210
       210
       +
                           //   pkgs/by-name

     

       211
       211
       +
                           // We choose the latter, since we want to move towards pkgs/by-name, not away

     

       212
       212
       +
                           // from it

     

       213
       213
       +
                           Success(ratchet::Package {

     

       214
       214
       +
                               empty_non_auto_called: Tight,

     

       215
       215
       +
                               uses_by_name: Tight,

     

       216
       216
       +
                           })

     

       217
       217
       +
                       }

     

       218
       218
       +
                       ByName(Missing) => NixpkgsProblem::UndefinedAttr {

     

       142
       219
        
                           relative_package_file: relative_package_file.clone(),

     

       143
       220
        
                           package_name: attribute_name.clone(),

     

       144
       221
        
                       }

     

       145
       222
        
                       .into(),

     

       146
       146
       -
                       Existing(NonAttributeSet) => NixpkgsProblem::NonDerivation {

     

       223
       223
       +
                       ByName(Existing(NonAttributeSet)) => NixpkgsProblem::NonDerivation {

     

       147
       224
        
                           relative_package_file: relative_package_file.clone(),

     

       148
       225
        
                           package_name: attribute_name.clone(),

     

       149
       226
        
                       }

     

       150
       227
        
                       .into(),

     

       151
       151
       -
                       Existing(NonCallPackage) => NixpkgsProblem::WrongCallPackage {

     

       228
       228
       +
                       ByName(Existing(NonCallPackage)) => NixpkgsProblem::WrongCallPackage {

     

       152
       229
        
                           relative_package_file: relative_package_file.clone(),

     

       153
       230
        
                           package_name: attribute_name.clone(),

     

       154
       231
        
                       }

     

       155
       232
        
                       .into(),

     

       156
       156
       -
                       Existing(CallPackage(CallPackageInfo {

     

       233
       233
       +
                       ByName(Existing(CallPackage(CallPackageInfo {

     

       157
       234
        
                           is_derivation,

     

       158
       235
        
                           call_package_variant,

     

       159
       159
       -
                       })) => {

     

       236
       236
       +
                       }))) => {

     

       160
       237
        
                           let check_result = if !is_derivation {

     

       161
       238
        
                               NixpkgsProblem::NonDerivation {

     

       162
       239
        
                                   relative_package_file: relative_package_file.clone(),

     
···

       170
       247
        
                           check_result.and(match &call_package_variant {

     

       171
       248
        
                               Auto => Success(ratchet::Package {

     

       172
       249
        
                                   empty_non_auto_called: Tight,

     

       250
       250
       +
                                   uses_by_name: Tight,

     

       173
       251
        
                               }),

     

       174
       252
        
                               Manual { path, empty_arg } => {

     

       175
       253
        
                                   let correct_file = if let Some(call_package_path) = path {

     
···

       186
       264
        
                                           } else {

     

       187
       265
        
                                               Tight

     

       188
       266
        
                                           },

     

       267
       267
       +
                                           uses_by_name: Tight,

     

       189
       268
        
                                       })

     

       190
       269
        
                                   } else {

     

       191
       270
        
                                       NixpkgsProblem::WrongCallPackage {

     
···

       203
       282
        
           ));

     

       204
       283
        
       

     

       205
       284
        
           Ok(check_result.map(|elems| ratchet::Nixpkgs {

     

       206
       206
       -
               package_names,

     

       285
       285
       +
               package_names: elems.iter().map(|(name, _)| name.to_owned()).collect(),

     

       207
       286
        
               package_map: elems.into_iter().collect(),

     

       208
       287
        
           }))

     

       209
       288
        
       }

+28 -8

pkgs/test/nixpkgs-check-by-name/src/main.rs

···

       12
       12
        
       use anyhow::Context;

     

       13
       13
        
       use clap::Parser;

     

       14
       14
        
       use colored::Colorize;

     

       15
       15
       +
       use std::collections::HashMap;

     

       15
       16
        
       use std::io;

     

       16
       17
        
       use std::path::{Path, PathBuf};

     

       17
       18
        
       use std::process::ExitCode;

     
···

       44
       45
        
       

     

       45
       46
        
       fn main() -> ExitCode {

     

       46
       47
        
           let args = Args::parse();

     

       47
       47
       -
           match process(&args.base, &args.nixpkgs, &[], &mut io::stderr()) {

     

       48
       48
       +
           match process(

     

       49
       49
       +
               &args.base,

     

       50
       50
       +
               &args.nixpkgs,

     

       51
       51
       +
               &HashMap::new(),

     

       52
       52
       +
               &mut io::stderr(),

     

       53
       53
       +
           ) {

     

       48
       54
        
               Ok(true) => {

     

       49
       55
        
                   eprintln!("{}", "Validated successfully".green());

     

       50
       56
        
                   ExitCode::SUCCESS

     
···

       77
       83
        
       pub fn process<W: io::Write>(

     

       78
       84
        
           base_nixpkgs: &Path,

     

       79
       85
        
           main_nixpkgs: &Path,

     

       80
       80
       -
           eval_accessible_paths: &[&Path],

     

       86
       86
       +
           eval_nix_path: &HashMap<String, PathBuf>,

     

       81
       87
        
           error_writer: &mut W,

     

       82
       88
        
       ) -> anyhow::Result<bool> {

     

       83
       89
        
           // Check the main Nixpkgs first

     

       84
       84
       -
           let main_result = check_nixpkgs(main_nixpkgs, eval_accessible_paths, error_writer)?;

     

       90
       90
       +
           let main_result = check_nixpkgs(main_nixpkgs, eval_nix_path, error_writer)?;

     

       85
       91
        
           let check_result = main_result.result_map(|nixpkgs_version| {

     

       86
       92
        
               // If the main Nixpkgs doesn't have any problems, run the ratchet checks against the base

     

       87
       93
        
               // Nixpkgs

     

       88
       88
       -
               check_nixpkgs(base_nixpkgs, eval_accessible_paths, error_writer)?.result_map(

     

       94
       94
       +
               check_nixpkgs(base_nixpkgs, eval_nix_path, error_writer)?.result_map(

     

       89
       95
        
                   |base_nixpkgs_version| {

     

       90
       96
        
                       Ok(ratchet::Nixpkgs::compare(

     

       91
       97
        
                           base_nixpkgs_version,

     
···

       113
       119
        
       /// ratchet check against another result.

     

       114
       120
        
       pub fn check_nixpkgs<W: io::Write>(

     

       115
       121
        
           nixpkgs_path: &Path,

     

       116
       116
       -
           eval_accessible_paths: &[&Path],

     

       122
       122
       +
           eval_nix_path: &HashMap<String, PathBuf>,

     

       117
       123
        
           error_writer: &mut W,

     

       118
       124
        
       ) -> validation::Result<ratchet::Nixpkgs> {

     

       119
       125
        
           Ok({

     
···

       134
       140
        
               } else {

     

       135
       141
        
                   check_structure(&nixpkgs_path)?.result_map(|package_names|

     

       136
       142
        
                       // Only if we could successfully parse the structure, we do the evaluation checks

     

       137
       137
       -
                       eval::check_values(&nixpkgs_path, package_names, eval_accessible_paths))?

     

       143
       143
       +
                       eval::check_values(&nixpkgs_path, package_names, eval_nix_path))?

     

       138
       144
        
               }

     

       139
       145
        
           })

     

       140
       146
        
       }

     
···

       144
       150
        
           use crate::process;

     

       145
       151
        
           use crate::utils;

     

       146
       152
        
           use anyhow::Context;

     

       153
       153
       +
           use std::collections::HashMap;

     

       147
       154
        
           use std::fs;

     

       148
       155
        
           use std::path::Path;

     

       156
       156
       +
           use std::path::PathBuf;

     

       149
       157
        
           use tempfile::{tempdir_in, TempDir};

     

       150
       158
        
       

     

       151
       159
        
           #[test]

     
···

       226
       234
        
           }

     

       227
       235
        
       

     

       228
       236
        
           fn test_nixpkgs(name: &str, path: &Path, expected_errors: &str) -> anyhow::Result<()> {

     

       229
       229
       -
               let extra_nix_path = Path::new("tests/mock-nixpkgs.nix");

     

       237
       237
       +
               let eval_nix_path = HashMap::from([

     

       238
       238
       +
                   (

     

       239
       239
       +
                       "test-nixpkgs".to_string(),

     

       240
       240
       +
                       PathBuf::from("tests/mock-nixpkgs.nix"),

     

       241
       241
       +
                   ),

     

       242
       242
       +
                   (

     

       243
       243
       +
                       "test-nixpkgs/lib".to_string(),

     

       244
       244
       +
                       PathBuf::from(

     

       245
       245
       +
                           std::env::var("NIXPKGS_LIB_PATH")

     

       246
       246
       +
                               .with_context(|| "Could not get environment variable NIXPKGS_LIB_PATH")?,

     

       247
       247
       +
                       ),

     

       248
       248
       +
                   ),

     

       249
       249
       +
               ]);

     

       230
       250
        
       

     

       231
       251
        
               let base_path = path.join("base");

     

       232
       252
        
               let base_nixpkgs = if base_path.exists() {

     
···

       238
       258
        
               // We don't want coloring to mess up the tests

     

       239
       259
        
               let writer = temp_env::with_var("NO_COLOR", Some("1"), || -> anyhow::Result<_> {

     

       240
       260
        
                   let mut writer = vec![];

     

       241
       241
       -
                   process(base_nixpkgs, &path, &[&extra_nix_path], &mut writer)

     

       261
       261
       +
                   process(base_nixpkgs, &path, &eval_nix_path, &mut writer)

     

       242
       262
        
                       .with_context(|| format!("Failed test case {name}"))?;

     

       243
       263
        
                   Ok(writer)

     

       244
       264
        
               })?;

+61

pkgs/test/nixpkgs-check-by-name/src/nixpkgs_problem.rs

···

       1
       1
       +
       use crate::structure;

     

       1
       2
        
       use crate::utils::PACKAGE_NIX_FILENAME;

     

       2
       3
        
       use rnix::parser::ParseError;

     

       3
       4
        
       use std::ffi::OsString;

     
···

       86
       87
        
               line: usize,

     

       87
       88
        
               text: String,

     

       88
       89
        
               io_error: io::Error,

     

       90
       90
       +
           },

     

       91
       91
       +
           InternalCallPackageUsed {

     

       92
       92
       +
               attr_name: String,

     

       93
       93
       +
           },

     

       94
       94
       +
           MovedOutOfByName {

     

       95
       95
       +
               package_name: String,

     

       96
       96
       +
               call_package_path: Option<PathBuf>,

     

       97
       97
       +
               empty_arg: bool,

     

       98
       98
       +
           },

     

       99
       99
       +
           NewPackageNotUsingByName {

     

       100
       100
       +
               package_name: String,

     

       101
       101
       +
               call_package_path: Option<PathBuf>,

     

       102
       102
       +
               empty_arg: bool,

     

       89
       103
        
           },

     

       90
       104
        
       }

     

       91
       105
        
       

     
···

       213
       227
        
                           subpath.display(),

     

       214
       228
        
                           text,

     

       215
       229
        
                       ),

     

       230
       230
       +
                   NixpkgsProblem::InternalCallPackageUsed { attr_name } =>

     

       231
       231
       +
                       write!(

     

       232
       232
       +
                           f,

     

       233
       233
       +
                           "pkgs.{attr_name}: This attribute is defined using `_internalCallByNamePackageFile`, which is an internal function not intended for manual use.",

     

       234
       234
       +
                       ),

     

       235
       235
       +
                   NixpkgsProblem::MovedOutOfByName { package_name, call_package_path, empty_arg } => {

     

       236
       236
       +
                       let call_package_arg =

     

       237
       237
       +
                           if let Some(path) = &call_package_path {

     

       238
       238
       +
                               format!("./{}", path.display())

     

       239
       239
       +
                           } else {

     

       240
       240
       +
                               "...".into()

     

       241
       241
       +
                           };

     

       242
       242
       +
                       if *empty_arg {

     

       243
       243
       +
                           write!(

     

       244
       244
       +
                               f,

     

       245
       245
       +
                               "pkgs.{package_name}: This top-level package was previously defined in {}, but is now manually defined as `callPackage {call_package_arg} {{ }}` (e.g. in `pkgs/top-level/all-packages.nix`). Please move the package back and remove the manual `callPackage`.",

     

       246
       246
       +
                               structure::relative_file_for_package(package_name).display(),

     

       247
       247
       +
                               )

     

       248
       248
       +
                       } else {

     

       249
       249
       +
                           // This can happen if users mistakenly assume that for custom arguments,

     

       250
       250
       +
                           // pkgs/by-name can't be used.

     

       251
       251
       +
                           write!(

     

       252
       252
       +
                               f,

     

       253
       253
       +
                               "pkgs.{package_name}: This top-level package was previously defined in {}, but is now manually defined as `callPackage {call_package_arg} {{ ... }}` (e.g. in `pkgs/top-level/all-packages.nix`). While the manual `callPackage` is still needed, it's not necessary to move the package files.",

     

       254
       254
       +
                               structure::relative_file_for_package(package_name).display(),

     

       255
       255
       +
                               )

     

       256
       256
       +
                       }

     

       257
       257
       +
                   },

     

       258
       258
       +
                   NixpkgsProblem::NewPackageNotUsingByName { package_name, call_package_path, empty_arg } => {

     

       259
       259
       +
                       let call_package_arg =

     

       260
       260
       +
                           if let Some(path) = &call_package_path {

     

       261
       261
       +
                               format!("./{}", path.display())

     

       262
       262
       +
                           } else {

     

       263
       263
       +
                               "...".into()

     

       264
       264
       +
                           };

     

       265
       265
       +
                       let extra =

     

       266
       266
       +
                           if *empty_arg {

     

       267
       267
       +
                               "Since the second `callPackage` argument is `{ }`, no manual `callPackage` (e.g. in `pkgs/top-level/all-packages.nix`) is needed anymore."

     

       268
       268
       +
                           } else {

     

       269
       269
       +
                               "Since the second `callPackage` argument is not `{ }`, the manual `callPackage` (e.g. in `pkgs/top-level/all-packages.nix`) is still needed."

     

       270
       270
       +
                           };

     

       271
       271
       +
                       write!(

     

       272
       272
       +
                           f,

     

       273
       273
       +
                           "pkgs.{package_name}: This is a new top-level package of the form `callPackage {call_package_arg} {{ }}`. Please define it in {} instead. See `pkgs/by-name/README.md` for more details. {extra}",

     

       274
       274
       +
                           structure::relative_file_for_package(package_name).display(),

     

       275
       275
       +
                       )

     

       276
       276
       +
                   },

     

       216
       277
        
               }

     

       217
       278
        
           }

     

       218
       279
        
       }

+50 -8

pkgs/test/nixpkgs-check-by-name/src/ratchet.rs

···

       6
       6
        
       use crate::structure;

     

       7
       7
        
       use crate::validation::{self, Validation, Validation::Success};

     

       8
       8
        
       use std::collections::HashMap;

     

       9
       9
       +
       use std::path::PathBuf;

     

       9
       10
        
       

     

       10
       11
        
       /// The ratchet value for the entirety of Nixpkgs.

     

       11
       12
        
       #[derive(Default)]

     

       12
       13
        
       pub struct Nixpkgs {

     

       13
       13
       -
           /// Sorted list of attributes in package_map

     

       14
       14
       +
           /// Sorted list of packages in package_map

     

       14
       15
        
           pub package_names: Vec<String>,

     

       15
       16
        
           /// The ratchet values for all packages

     

       16
       17
        
           pub package_map: HashMap<String, Package>,

     
···

       29
       30
        
           }

     

       30
       31
        
       }

     

       31
       32
        
       

     

       32
       32
       -
       /// The ratchet value for a single package in `pkgs/by-name`

     

       33
       33
       +
       /// The ratchet value for a top-level package

     

       33
       34
        
       pub struct Package {

     

       34
       35
        
           /// The ratchet value for the check for non-auto-called empty arguments

     

       35
       36
        
           pub empty_non_auto_called: RatchetState<EmptyNonAutoCalled>,

     

       37
       37
       +
       

     

       38
       38
       +
           /// The ratchet value for the check for new packages using pkgs/by-name

     

       39
       39
       +
           pub uses_by_name: RatchetState<UsesByName>,

     

       36
       40
        
       }

     

       37
       41
        
       

     

       38
       42
        
       impl Package {

     

       39
       39
       -
           /// Validates the ratchet checks for a single package defined in `pkgs/by-name`

     

       43
       43
       +
           /// Validates the ratchet checks for a top-level package

     

       40
       44
        
           pub fn compare(name: &str, optional_from: Option<&Self>, to: &Self) -> Validation<()> {

     

       41
       41
       -
               RatchetState::<EmptyNonAutoCalled>::compare(

     

       42
       42
       -
                   name,

     

       43
       43
       -
                   optional_from.map(|x| &x.empty_non_auto_called),

     

       44
       44
       -
                   &to.empty_non_auto_called,

     

       45
       45
       -
               )

     

       45
       45
       +
               validation::sequence_([

     

       46
       46
       +
                   RatchetState::<EmptyNonAutoCalled>::compare(

     

       47
       47
       +
                       name,

     

       48
       48
       +
                       optional_from.map(|x| &x.empty_non_auto_called),

     

       49
       49
       +
                       &to.empty_non_auto_called,

     

       50
       50
       +
                   ),

     

       51
       51
       +
                   RatchetState::<UsesByName>::compare(

     

       52
       52
       +
                       name,

     

       53
       53
       +
                       optional_from.map(|x| &x.uses_by_name),

     

       54
       54
       +
                       &to.uses_by_name,

     

       55
       55
       +
                   ),

     

       56
       56
       +
               ])

     

       46
       57
        
           }

     

       47
       58
        
       }

     

       48
       59
        
       

     
···

       102
       113
        
               }

     

       103
       114
        
           }

     

       104
       115
        
       }

     

       116
       116
       +
       

     

       117
       117
       +
       /// The ratchet value of an attribute

     

       118
       118
       +
       /// for the check that new packages use pkgs/by-name

     

       119
       119
       +
       ///

     

       120
       120
       +
       /// This checks that all new package defined using callPackage must be defined via pkgs/by-name

     

       121
       121
       +
       /// It also checks that once a package uses pkgs/by-name, it can't switch back to all-packages.nix

     

       122
       122
       +
       #[derive(Clone)]

     

       123
       123
       +
       pub struct UsesByName {

     

       124
       124
       +
           /// The first callPackage argument, used for better errors

     

       125
       125
       +
           pub call_package_path: Option<PathBuf>,

     

       126
       126
       +
           /// Whether the second callPackage argument is empty, used for better errors

     

       127
       127
       +
           pub empty_arg: bool,

     

       128
       128
       +
       }

     

       129
       129
       +
       

     

       130
       130
       +
       impl ToNixpkgsProblem for UsesByName {

     

       131
       131
       +
           fn to_nixpkgs_problem(name: &str, a: &Self, existed_before: bool) -> NixpkgsProblem {

     

       132
       132
       +
               if existed_before {

     

       133
       133
       +
                   NixpkgsProblem::MovedOutOfByName {

     

       134
       134
       +
                       package_name: name.to_owned(),

     

       135
       135
       +
                       call_package_path: a.call_package_path.clone(),

     

       136
       136
       +
                       empty_arg: a.empty_arg,

     

       137
       137
       +
                   }

     

       138
       138
       +
               } else {

     

       139
       139
       +
                   NixpkgsProblem::NewPackageNotUsingByName {

     

       140
       140
       +
                       package_name: name.to_owned(),

     

       141
       141
       +
                       call_package_path: a.call_package_path.clone(),

     

       142
       142
       +
                       empty_arg: a.empty_arg,

     

       143
       143
       +
                   }

     

       144
       144
       +
               }

     

       145
       145
       +
           }

     

       146
       146
       +
       }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/broken-autocall/default.nix

···

       1
       1
        
       args:

     

       2
       2
        
       builtins.removeAttrs

     

       3
       3
       -
         (import ../mock-nixpkgs.nix { root = ./.; } args)

     

       3
       3
       +
         (import <test-nixpkgs> { root = ./.; } args)

     

       4
       4
        
         [ "foo" ]

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/empty-base/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/incorrect-shard/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+3

pkgs/test/nixpkgs-check-by-name/tests/internalCallPackage/all-packages.nix

···

       1
       1
       +
       self: super: {

     

       2
       2
       +
         foo = self._internalCallByNamePackageFile ./foo.nix;

     

       3
       3
       +
       }

+1

pkgs/test/nixpkgs-check-by-name/tests/internalCallPackage/default.nix

···

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1

pkgs/test/nixpkgs-check-by-name/tests/internalCallPackage/expected

···

       1
       1
       +
       pkgs.foo: This attribute is defined using `_internalCallByNamePackageFile`, which is an internal function not intended for manual use.

+1

pkgs/test/nixpkgs-check-by-name/tests/internalCallPackage/foo.nix

···

       1
       1
       +
       { someDrv }: someDrv

pkgs/test/nixpkgs-check-by-name/tests/internalCallPackage/pkgs/by-name/README.md

This is a binary file and will not be displayed.

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/invalid-package-name/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/invalid-shard-name/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/missing-package-nix/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+4 -20

pkgs/test/nixpkgs-check-by-name/tests/mock-nixpkgs.nix

···

       25
       25
        
       let

     

       26
       26
        
       

     

       27
       27
        
         # Simplified versions of lib functions

     

       28
       28
       -
         lib = {

     

       29
       29
       -
           fix = f: let x = f x; in x;

     

       30
       30
       -
       

     

       31
       31
       -
           extends = overlay: f: final:

     

       32
       32
       -
             let

     

       33
       33
       -
               prev = f final;

     

       34
       34
       -
             in

     

       35
       35
       -
             prev // overlay final prev;

     

       36
       36
       -
       

     

       37
       37
       -
           callPackageWith = autoArgs: fn: args:

     

       38
       38
       -
             let

     

       39
       39
       -
               f = if builtins.isFunction fn then fn else import fn;

     

       40
       40
       -
               fargs = builtins.functionArgs f;

     

       41
       41
       -
               allArgs = builtins.intersectAttrs fargs autoArgs // args;

     

       42
       42
       -
             in

     

       43
       43
       -
             f allArgs;

     

       44
       44
       -
       

     

       45
       45
       -
           isDerivation = value: value.type or null == "derivation";

     

       46
       46
       -
         };

     

       28
       28
       +
         lib = import <test-nixpkgs/lib>;

     

       47
       29
        
       

     

       48
       30
        
         # The base fixed-point function to populate the resulting attribute set

     

       49
       31
        
         pkgsFun = self: {

     

       50
       32
        
           inherit lib;

     

       51
       51
       -
           callPackage = lib.callPackageWith self;

     

       33
       33
       +
           newScope = extra: lib.callPackageWith (self // extra);

     

       34
       34
       +
           callPackage = self.newScope { };

     

       35
       35
       +
           callPackages = lib.callPackagesWith self;

     

       52
       36
        
           someDrv = { type = "derivation"; };

     

       53
       37
        
         };

     

       54
       38

+10

pkgs/test/nixpkgs-check-by-name/tests/move-to-non-by-name/all-packages.nix

···

       1
       1
       +
       self: super: {

     

       2
       2
       +
         foo1 = self.callPackage ({ someDrv }: someDrv) { };

     

       3
       3
       +
         foo2 = self.callPackage ./without-config.nix { };

     

       4
       4
       +
         foo3 = self.callPackage ({ someDrv, enableFoo }: someDrv) {

     

       5
       5
       +
           enableFoo = null;

     

       6
       6
       +
         };

     

       7
       7
       +
         foo4 = self.callPackage ./with-config.nix {

     

       8
       8
       +
           enableFoo = null;

     

       9
       9
       +
         };

     

       10
       10
       +
       }

+1

pkgs/test/nixpkgs-check-by-name/tests/move-to-non-by-name/base/default.nix

···

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1

pkgs/test/nixpkgs-check-by-name/tests/move-to-non-by-name/base/pkgs/by-name/fo/foo1/package.nix

···

       1
       1
       +
       { someDrv }: someDrv

+1

pkgs/test/nixpkgs-check-by-name/tests/move-to-non-by-name/base/pkgs/by-name/fo/foo2/package.nix

···

       1
       1
       +
       { someDrv }: someDrv

+1

pkgs/test/nixpkgs-check-by-name/tests/move-to-non-by-name/base/pkgs/by-name/fo/foo3/package.nix

···

       1
       1
       +
       { someDrv }: someDrv

+1

pkgs/test/nixpkgs-check-by-name/tests/move-to-non-by-name/base/pkgs/by-name/fo/foo4/package.nix

···

       1
       1
       +
       { someDrv }: someDrv

+1

pkgs/test/nixpkgs-check-by-name/tests/move-to-non-by-name/default.nix

···

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+4

pkgs/test/nixpkgs-check-by-name/tests/move-to-non-by-name/expected

···

       1
       1
       +
       pkgs.foo1: This top-level package was previously defined in pkgs/by-name/fo/foo1/package.nix, but is now manually defined as `callPackage ... { }` (e.g. in `pkgs/top-level/all-packages.nix`). Please move the package back and remove the manual `callPackage`.

     

       2
       2
       +
       pkgs.foo2: This top-level package was previously defined in pkgs/by-name/fo/foo2/package.nix, but is now manually defined as `callPackage ./without-config.nix { }` (e.g. in `pkgs/top-level/all-packages.nix`). Please move the package back and remove the manual `callPackage`.

     

       3
       3
       +
       pkgs.foo3: This top-level package was previously defined in pkgs/by-name/fo/foo3/package.nix, but is now manually defined as `callPackage ... { ... }` (e.g. in `pkgs/top-level/all-packages.nix`). While the manual `callPackage` is still needed, it's not necessary to move the package files.

     

       4
       4
       +
       pkgs.foo4: This top-level package was previously defined in pkgs/by-name/fo/foo4/package.nix, but is now manually defined as `callPackage ./with-config.nix { ... }` (e.g. in `pkgs/top-level/all-packages.nix`). While the manual `callPackage` is still needed, it's not necessary to move the package files.

pkgs/test/nixpkgs-check-by-name/tests/move-to-non-by-name/pkgs/by-name/README.md

This is a binary file and will not be displayed.

+1

pkgs/test/nixpkgs-check-by-name/tests/move-to-non-by-name/with-config.nix

···

       1
       1
       +
       { someDrv, enableFoo }: someDrv

+1

pkgs/test/nixpkgs-check-by-name/tests/move-to-non-by-name/without-config.nix

···

       1
       1
       +
       { someDrv }: someDrv

+11

pkgs/test/nixpkgs-check-by-name/tests/new-package-non-by-name/all-packages.nix

···

       1
       1
       +
       self: super: {

     

       2
       2
       +
         before = self.callPackage ({ someDrv }: someDrv) { };

     

       3
       3
       +
         new1 = self.callPackage ({ someDrv }: someDrv) { };

     

       4
       4
       +
         new2 = self.callPackage ./without-config.nix { };

     

       5
       5
       +
         new3 = self.callPackage ({ someDrv, enableNew }: someDrv) {

     

       6
       6
       +
           enableNew = null;

     

       7
       7
       +
         };

     

       8
       8
       +
         new4 = self.callPackage ./with-config.nix {

     

       9
       9
       +
           enableNew = null;

     

       10
       10
       +
         };

     

       11
       11
       +
       }

+5

pkgs/test/nixpkgs-check-by-name/tests/new-package-non-by-name/base/all-packages.nix

···

       1
       1
       +
       self: super: {

     

       2
       2
       +
       

     

       3
       3
       +
         before = self.callPackage ({ someDrv }: someDrv) { };

     

       4
       4
       +
       

     

       5
       5
       +
       }

+1

pkgs/test/nixpkgs-check-by-name/tests/new-package-non-by-name/base/default.nix

···

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

pkgs/test/nixpkgs-check-by-name/tests/new-package-non-by-name/base/pkgs/by-name/README.md

This is a binary file and will not be displayed.

+1

pkgs/test/nixpkgs-check-by-name/tests/new-package-non-by-name/default.nix

···

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+4

pkgs/test/nixpkgs-check-by-name/tests/new-package-non-by-name/expected

···

       1
       1
       +
       pkgs.new1: This is a new top-level package of the form `callPackage ... { }`. Please define it in pkgs/by-name/ne/new1/package.nix instead. See `pkgs/by-name/README.md` for more details. Since the second `callPackage` argument is `{ }`, no manual `callPackage` (e.g. in `pkgs/top-level/all-packages.nix`) is needed anymore.

     

       2
       2
       +
       pkgs.new2: This is a new top-level package of the form `callPackage ./without-config.nix { }`. Please define it in pkgs/by-name/ne/new2/package.nix instead. See `pkgs/by-name/README.md` for more details. Since the second `callPackage` argument is `{ }`, no manual `callPackage` (e.g. in `pkgs/top-level/all-packages.nix`) is needed anymore.

     

       3
       3
       +
       pkgs.new3: This is a new top-level package of the form `callPackage ... { }`. Please define it in pkgs/by-name/ne/new3/package.nix instead. See `pkgs/by-name/README.md` for more details. Since the second `callPackage` argument is not `{ }`, the manual `callPackage` (e.g. in `pkgs/top-level/all-packages.nix`) is still needed.

     

       4
       4
       +
       pkgs.new4: This is a new top-level package of the form `callPackage ./with-config.nix { }`. Please define it in pkgs/by-name/ne/new4/package.nix instead. See `pkgs/by-name/README.md` for more details. Since the second `callPackage` argument is not `{ }`, the manual `callPackage` (e.g. in `pkgs/top-level/all-packages.nix`) is still needed.

pkgs/test/nixpkgs-check-by-name/tests/new-package-non-by-name/pkgs/by-name/README.md

This is a binary file and will not be displayed.

+1

pkgs/test/nixpkgs-check-by-name/tests/new-package-non-by-name/with-config.nix

···

       1
       1
       +
       { someDrv, enableNew }: someDrv

+1

pkgs/test/nixpkgs-check-by-name/tests/new-package-non-by-name/without-config.nix

···

       1
       1
       +
       { someDrv }: someDrv

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/no-by-name/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+3

pkgs/test/nixpkgs-check-by-name/tests/no-eval/all-packages.nix

···

       1
       1
       +
       self: super: {

     

       2
       2
       +
         iDontEval = throw "I don't eval";

     

       3
       3
       +
       }

+1

pkgs/test/nixpkgs-check-by-name/tests/no-eval/default.nix

···

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1

pkgs/test/nixpkgs-check-by-name/tests/no-eval/pkgs/by-name/fo/foo/package.nix

···

       1
       1
       +
       { someDrv }: someDrv

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/non-attrs/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/non-derivation/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/one-letter/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+16

pkgs/test/nixpkgs-check-by-name/tests/only-callPackage-derivations/all-packages.nix

···

       1
       1
       +
       self: super: {

     

       2
       2
       +
         alternateCallPackage = self.myScope.callPackage ({ myScopeValue, someDrv }:

     

       3
       3
       +
           assert myScopeValue;

     

       4
       4
       +
           someDrv

     

       5
       5
       +
         ) { };

     

       6
       6
       +
       

     

       7
       7
       +
         myScope = self.lib.makeScope self.newScope (self: {

     

       8
       8
       +
           myScopeValue = true;

     

       9
       9
       +
         });

     

       10
       10
       +
       

     

       11
       11
       +
         myPackages = self.callPackages ({ someDrv }: {

     

       12
       12
       +
           a = someDrv;

     

       13
       13
       +
           b = someDrv;

     

       14
       14
       +
         }) { };

     

       15
       15
       +
         inherit (self.myPackages) a b;

     

       16
       16
       +
       }

+1

pkgs/test/nixpkgs-check-by-name/tests/only-callPackage-derivations/default.nix

···

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

pkgs/test/nixpkgs-check-by-name/tests/only-callPackage-derivations/pkgs/by-name/README.md

This is a binary file and will not be displayed.

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/override-different-file/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/override-empty-arg-gradual/base/default.nix

···

       1
       1
       -
       import ../../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/override-empty-arg-gradual/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/override-empty-arg/base/default.nix

···

       1
       1
       -
       import ../../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/override-empty-arg/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/override-no-call-package/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/override-no-file/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/override-success/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/package-dir-is-file/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/package-nix-dir/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/ref-absolute/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/ref-escape/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/ref-nix-path/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/ref-parse-failure/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/ref-path-subexpr/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/ref-success/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/shard-file/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+6

pkgs/test/nixpkgs-check-by-name/tests/sorted-order/all-packages.nix

···

       1
       1
       +
       self: super: {

     

       2
       2
       +
         a = self.callPackage ./pkgs/by-name/a/a/package.nix { };

     

       3
       3
       +
         b = self.callPackage ({ someDrv }: someDrv) { };

     

       4
       4
       +
         c = self.callPackage ./pkgs/by-name/c/c/package.nix { };

     

       5
       5
       +
         d = self.callPackage ({ someDrv }: someDrv) { };

     

       6
       6
       +
       }

+1

pkgs/test/nixpkgs-check-by-name/tests/sorted-order/default.nix

···

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+4

pkgs/test/nixpkgs-check-by-name/tests/sorted-order/expected

···

       1
       1
       +
       pkgs.a: This attribute is manually defined (most likely in pkgs/top-level/all-packages.nix), which is only allowed if the definition is of the form `pkgs.callPackage pkgs/by-name/a/a/package.nix { ... }` with a non-empty second argument.

     

       2
       2
       +
       pkgs.b: This is a new top-level package of the form `callPackage ... { }`. Please define it in pkgs/by-name/b/b/package.nix instead. See `pkgs/by-name/README.md` for more details. Since the second `callPackage` argument is `{ }`, no manual `callPackage` (e.g. in `pkgs/top-level/all-packages.nix`) is needed anymore.

     

       3
       3
       +
       pkgs.c: This attribute is manually defined (most likely in pkgs/top-level/all-packages.nix), which is only allowed if the definition is of the form `pkgs.callPackage pkgs/by-name/c/c/package.nix { ... }` with a non-empty second argument.

     

       4
       4
       +
       pkgs.d: This is a new top-level package of the form `callPackage ... { }`. Please define it in pkgs/by-name/d/d/package.nix instead. See `pkgs/by-name/README.md` for more details. Since the second `callPackage` argument is `{ }`, no manual `callPackage` (e.g. in `pkgs/top-level/all-packages.nix`) is needed anymore.

+1

pkgs/test/nixpkgs-check-by-name/tests/sorted-order/pkgs/by-name/a/a/package.nix

···

       1
       1
       +
       { someDrv }: someDrv

+1

pkgs/test/nixpkgs-check-by-name/tests/sorted-order/pkgs/by-name/c/c/package.nix

···

       1
       1
       +
       { someDrv }: someDrv

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/success/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/symlink-escape/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/symlink-invalid/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/uppercase/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }

+1 -1

pkgs/test/nixpkgs-check-by-name/tests/with-readme/default.nix

···

       1
       1
       -
       import ../mock-nixpkgs.nix { root = ./.; }

     

       1
       1
       +
       import <test-nixpkgs> { root = ./.; }