2022-03-26 10:32:38 +00:00
# include "globals.hh"
2019-10-14 12:40:16 +00:00
# include "installables.hh"
2023-02-03 16:21:47 +00:00
# include "installable-derived-path.hh"
2023-02-03 19:53:40 +00:00
# include "installable-attr-path.hh"
# include "installable-flake.hh"
2023-01-11 06:51:14 +00:00
# include "outputs-spec.hh"
2022-02-19 13:26:34 +00:00
# include "util.hh"
2017-04-25 10:06:32 +00:00
# include "command.hh"
2016-02-09 20:34:24 +00:00
# include "attr-path.hh"
2017-10-24 10:45:11 +00:00
# include "common-eval-args.hh"
2016-02-09 20:34:24 +00:00
# include "derivations.hh"
# include "eval-inline.hh"
# include "eval.hh"
2023-07-31 13:19:19 +00:00
# include "eval-settings.hh"
2016-02-09 20:34:24 +00:00
# include "get-drvs.hh"
# include "store-api.hh"
2017-04-25 09:20:37 +00:00
# include "shared.hh"
2019-06-05 14:51:54 +00:00
# include "flake/flake.hh"
2020-04-20 11:14:59 +00:00
# include "eval-cache.hh"
2020-03-30 12:03:28 +00:00
# include "url.hh"
2020-05-11 19:49:02 +00:00
# include "registry.hh"
2022-03-08 18:50:46 +00:00
# include "build-result.hh"
2017-04-25 09:20:37 +00:00
# include <regex>
2019-05-23 21:42:13 +00:00
# include <queue>
2016-02-09 20:34:24 +00:00
2020-10-23 04:59:01 +00:00
# include <nlohmann/json.hpp>
2016-02-09 20:34:24 +00:00
namespace nix {
2019-05-22 11:46:07 +00:00
MixFlakeOptions : : MixFlakeOptions ( )
2017-10-24 10:45:11 +00:00
{
2021-01-25 18:03:13 +00:00
auto category = " Common flake-related options " ;
2020-05-05 16:59:33 +00:00
addFlag ( {
. longName = " recreate-lock-file " ,
2021-01-13 13:18:04 +00:00
. description = " Recreate the flake's lock file from scratch. " ,
2021-01-25 18:03:13 +00:00
. category = category ,
2020-05-05 16:59:33 +00:00
. handler = { & lockFlags . recreateLockFile , true }
} ) ;
2019-05-14 09:34:45 +00:00
2020-05-05 16:59:33 +00:00
addFlag ( {
. longName = " no-update-lock-file " ,
2021-01-13 13:18:04 +00:00
. description = " Do not allow any updates to the flake's lock file. " ,
2021-01-25 18:03:13 +00:00
. category = category ,
2020-05-05 16:59:33 +00:00
. handler = { & lockFlags . updateLockFile , false }
} ) ;
2020-01-29 20:01:34 +00:00
2020-05-05 16:59:33 +00:00
addFlag ( {
. longName = " no-write-lock-file " ,
2021-01-13 13:18:04 +00:00
. description = " Do not write the flake's newly generated lock file. " ,
2021-01-25 18:03:13 +00:00
. category = category ,
2020-05-05 16:59:33 +00:00
. handler = { & lockFlags . writeLockFile , false }
} ) ;
2019-05-14 09:34:45 +00:00
2020-05-05 16:59:33 +00:00
addFlag ( {
. longName = " no-registries " ,
2021-07-21 12:27:37 +00:00
. description =
" Don't allow lookups in the flake registries. This option is deprecated; use `--no-use-registries`. " ,
2021-01-25 18:03:13 +00:00
. category = category ,
2021-07-02 12:36:14 +00:00
. handler = { [ & ] ( ) {
lockFlags . useRegistries = false ;
2021-07-21 12:27:37 +00:00
warn ( " '--no-registries' is deprecated; use '--no-use-registries' " ) ;
2021-07-02 12:36:14 +00:00
} }
2020-05-05 16:59:33 +00:00
} ) ;
2020-01-29 13:57:57 +00:00
2020-05-05 16:59:33 +00:00
addFlag ( {
. longName = " commit-lock-file " ,
2021-01-13 13:18:04 +00:00
. description = " Commit changes to the flake's lock file. " ,
2021-01-25 18:03:13 +00:00
. category = category ,
2020-05-05 16:59:33 +00:00
. handler = { & lockFlags . commitLockFile , true }
} ) ;
2020-02-05 13:48:49 +00:00
2020-05-05 16:59:33 +00:00
addFlag ( {
. longName = " update-input " ,
2021-01-13 13:18:04 +00:00
. description = " Update a specific flake input (ignoring its previous entry in the lock file). " ,
2021-01-25 18:03:13 +00:00
. category = category ,
2020-05-05 16:59:33 +00:00
. labels = { " input-path " } ,
. handler = { [ & ] ( std : : string s ) {
lockFlags . inputUpdates . insert ( flake : : parseInputPath ( s ) ) ;
2020-06-08 14:20:00 +00:00
} } ,
. completer = { [ & ] ( size_t , std : : string_view prefix ) {
2022-06-20 02:15:38 +00:00
needsFlakeInputCompletion = { std : : string ( prefix ) } ;
2020-05-05 16:59:33 +00:00
} }
} ) ;
2020-01-29 22:12:58 +00:00
2020-05-05 16:59:33 +00:00
addFlag ( {
. longName = " override-input " ,
2021-03-16 15:53:39 +00:00
. description = " Override a specific flake input (e.g. `dwarffs/nixpkgs`). This implies `--no-write-lock-file`. " ,
2021-01-25 18:03:13 +00:00
. category = category ,
2020-05-05 16:59:33 +00:00
. labels = { " input-path " , " flake-url " } ,
. handler = { [ & ] ( std : : string inputPath , std : : string flakeRef ) {
2021-03-16 15:53:39 +00:00
lockFlags . writeLockFile = false ;
2020-01-29 13:57:57 +00:00
lockFlags . inputOverrides . insert_or_assign (
2020-05-05 16:59:33 +00:00
flake : : parseInputPath ( inputPath ) ,
2022-02-04 02:51:47 +00:00
parseFlakeRef ( flakeRef , absPath ( " . " ) , true ) ) ;
2022-02-19 17:36:02 +00:00
} } ,
. completer = { [ & ] ( size_t n , std : : string_view prefix ) {
2022-06-19 15:54:27 +00:00
if ( n = = 0 )
2022-06-20 02:15:38 +00:00
needsFlakeInputCompletion = { std : : string ( prefix ) } ;
2022-06-19 15:54:27 +00:00
else if ( n = = 1 )
2022-02-19 17:36:02 +00:00
completeFlakeRef ( getEvalState ( ) - > store , prefix ) ;
2020-05-05 16:59:33 +00:00
} }
} ) ;
2020-07-01 18:23:39 +00:00
2023-03-13 20:08:52 +00:00
addFlag ( {
. longName = " reference-lock-file " ,
2023-03-14 11:02:03 +00:00
. description = " Read the given lock file instead of `flake.lock` within the top-level flake. " ,
2023-03-13 20:08:52 +00:00
. category = category ,
. labels = { " flake-lock-path " } ,
. handler = { [ & ] ( std : : string lockFilePath ) {
lockFlags . referenceLockFilePath = lockFilePath ;
} } ,
. completer = completePath
} ) ;
addFlag ( {
. longName = " output-lock-file " ,
2023-03-14 11:02:03 +00:00
. description = " Write the given lock file instead of `flake.lock` within the top-level flake. " ,
2023-03-13 20:08:52 +00:00
. category = category ,
. labels = { " flake-lock-path " } ,
. handler = { [ & ] ( std : : string lockFilePath ) {
lockFlags . outputLockFilePath = lockFilePath ;
} } ,
. completer = completePath
} ) ;
2020-07-01 18:23:39 +00:00
addFlag ( {
. longName = " inputs-from " ,
2021-01-13 13:18:04 +00:00
. description = " Use the inputs of the specified flake as registry entries. " ,
2021-01-25 18:03:13 +00:00
. category = category ,
2020-07-01 18:23:39 +00:00
. labels = { " flake-url " } ,
. handler = { [ & ] ( std : : string flakeRef ) {
auto evalState = getEvalState ( ) ;
auto flake = flake : : lockFlake (
* evalState ,
parseFlakeRef ( flakeRef , absPath ( " . " ) ) ,
{ . writeLockFile = false } ) ;
for ( auto & [ inputName , input ] : flake . lockFile . root - > inputs ) {
auto input2 = flake . lockFile . findInput ( { inputName } ) ; // resolve 'follows' nodes
if ( auto input3 = std : : dynamic_pointer_cast < const flake : : LockedNode > ( input2 ) ) {
overrideRegistry (
fetchers : : Input : : fromAttrs ( { { " type " , " indirect " } , { " id " , inputName } } ) ,
input3 - > lockedRef . input ,
{ } ) ;
}
}
} } ,
. completer = { [ & ] ( size_t , std : : string_view prefix ) {
completeFlakeRef ( getEvalState ( ) - > store , prefix ) ;
} }
} ) ;
2019-05-22 11:46:07 +00:00
}
2022-06-20 02:15:38 +00:00
void MixFlakeOptions : : completeFlakeInput ( std : : string_view prefix )
{
auto evalState = getEvalState ( ) ;
for ( auto & flakeRefS : getFlakesForCompletion ( ) ) {
auto flakeRef = parseFlakeRefWithFragment ( expandTilde ( flakeRefS ) , absPath ( " . " ) ) . first ;
auto flake = flake : : getFlake ( * evalState , flakeRef , true ) ;
for ( auto & input : flake . inputs )
if ( hasPrefix ( input . first , prefix ) )
completions - > add ( input . first ) ;
}
}
void MixFlakeOptions : : completionHook ( )
{
if ( auto & prefix = needsFlakeInputCompletion )
completeFlakeInput ( * prefix ) ;
}
2023-02-05 01:45:40 +00:00
SourceExprCommand : : SourceExprCommand ( )
2019-05-22 11:46:07 +00:00
{
2020-05-04 20:40:19 +00:00
addFlag ( {
. longName = " file " ,
. shortName = ' f ' ,
2022-03-16 18:48:50 +00:00
. description =
2022-12-01 00:57:02 +00:00
" Interpret [*installables*](@docroot@/command-ref/new-cli/nix.md#installables) as attribute paths relative to the Nix expression stored in *file*. "
2022-06-10 15:00:19 +00:00
" If *file* is the character -, then a Nix expression will be read from standard input. "
" Implies `--impure`. " ,
2021-01-25 18:03:13 +00:00
. category = installablesCategory ,
2020-05-04 20:40:19 +00:00
. labels = { " file " } ,
2020-05-10 19:35:07 +00:00
. handler = { & file } ,
. completer = completePath
2020-05-04 20:40:19 +00:00
} ) ;
2019-11-26 23:05:30 +00:00
2020-05-05 16:59:33 +00:00
addFlag ( {
2021-01-13 13:18:04 +00:00
. longName = " expr " ,
2022-12-01 00:57:02 +00:00
. description = " Interpret [*installables*](@docroot@/command-ref/new-cli/nix.md#installables) as attribute paths relative to the Nix expression *expr*. " ,
2021-01-25 18:03:13 +00:00
. category = installablesCategory ,
2020-05-05 16:59:33 +00:00
. labels = { " expr " } ,
. handler = { & expr }
} ) ;
2023-02-05 01:45:40 +00:00
}
2020-07-15 18:22:52 +00:00
2023-02-05 01:45:40 +00:00
MixReadOnlyOption : : MixReadOnlyOption ( )
{
addFlag ( {
. longName = " read-only " ,
. description =
" Do not instantiate each evaluated derivation. "
" This improves performance, but can cause errors when accessing "
" store paths of derivations during evaluation. " ,
. handler = { & settings . readOnlyMode , true } ,
} ) ;
2017-10-24 10:45:11 +00:00
}
Support non-x86_64-linux system types in flakes
A command like
$ nix run nixpkgs#hello
will now build the attribute 'packages.${system}.hello' rather than
'packages.hello'. Note that this does mean that the flake needs to
export an attribute for every system type it supports, and you can't
build on unsupported systems. So 'packages' typically looks like this:
packages = nixpkgs.lib.genAttrs ["x86_64-linux" "i686-linux"] (system: {
hello = ...;
});
The 'checks', 'defaultPackage', 'devShell', 'apps' and 'defaultApp'
outputs similarly are now attrsets that map system types to
derivations/apps. 'nix flake check' checks that the derivations for
all platforms evaluate correctly, but only builds the derivations in
'checks.${system}'.
Fixes #2861. (That issue also talks about access to ~/.config/nixpkgs
and --arg, but I think it's reasonable to say that flakes shouldn't
support those.)
The alternative to attribute selection is to pass the system type as
an argument to the flake's 'outputs' function, e.g. 'outputs = { self,
nixpkgs, system }: ...'. However, that approach would be at odds with
hermetic evaluation and make it impossible to enumerate the packages
provided by a flake.
2019-10-15 15:52:10 +00:00
Strings SourceExprCommand : : getDefaultFlakeAttrPaths ( )
{
2022-02-11 17:11:08 +00:00
return {
" packages. " + settings . thisSystem . get ( ) + " .default " ,
" defaultPackage. " + settings . thisSystem . get ( )
} ;
Support non-x86_64-linux system types in flakes
A command like
$ nix run nixpkgs#hello
will now build the attribute 'packages.${system}.hello' rather than
'packages.hello'. Note that this does mean that the flake needs to
export an attribute for every system type it supports, and you can't
build on unsupported systems. So 'packages' typically looks like this:
packages = nixpkgs.lib.genAttrs ["x86_64-linux" "i686-linux"] (system: {
hello = ...;
});
The 'checks', 'defaultPackage', 'devShell', 'apps' and 'defaultApp'
outputs similarly are now attrsets that map system types to
derivations/apps. 'nix flake check' checks that the derivations for
all platforms evaluate correctly, but only builds the derivations in
'checks.${system}'.
Fixes #2861. (That issue also talks about access to ~/.config/nixpkgs
and --arg, but I think it's reasonable to say that flakes shouldn't
support those.)
The alternative to attribute selection is to pass the system type as
an argument to the flake's 'outputs' function, e.g. 'outputs = { self,
nixpkgs, system }: ...'. However, that approach would be at odds with
hermetic evaluation and make it impossible to enumerate the packages
provided by a flake.
2019-10-15 15:52:10 +00:00
}
Strings SourceExprCommand : : getDefaultFlakeAttrPathPrefixes ( )
{
return {
// As a convenience, look for the attribute in
// 'outputs.packages'.
" packages. " + settings . thisSystem . get ( ) + " . " ,
// As a temporary hack until Nixpkgs is properly converted
// to provide a clean 'packages' set, look in 'legacyPackages'.
" legacyPackages. " + settings . thisSystem . get ( ) + " . "
} ;
}
2020-05-11 19:49:02 +00:00
void SourceExprCommand : : completeInstallable ( std : : string_view prefix )
{
2022-11-03 09:11:28 +00:00
try {
if ( file ) {
completionType = ctAttrs ;
2022-02-19 17:51:18 +00:00
2022-11-03 09:11:28 +00:00
evalSettings . pureEval = false ;
auto state = getEvalState ( ) ;
Expr * e = state - > parseExprFromFile (
resolveExprPath ( state - > checkSourcePath ( lookupFileArg ( * state , * file ) ) )
) ;
2021-07-03 12:19:10 +00:00
2022-11-03 09:11:28 +00:00
Value root ;
state - > eval ( e , root ) ;
2020-05-11 19:49:02 +00:00
2022-11-03 09:11:28 +00:00
auto autoArgs = getAutoArgs ( * state ) ;
2021-07-03 12:19:10 +00:00
2022-11-03 09:11:28 +00:00
std : : string prefix_ = std : : string ( prefix ) ;
auto sep = prefix_ . rfind ( ' . ' ) ;
std : : string searchWord ;
if ( sep ! = std : : string : : npos ) {
searchWord = prefix_ . substr ( sep + 1 , std : : string : : npos ) ;
prefix_ = prefix_ . substr ( 0 , sep ) ;
} else {
searchWord = prefix_ ;
prefix_ = " " ;
}
2021-07-03 12:19:10 +00:00
2022-11-03 09:11:28 +00:00
auto [ v , pos ] = findAlongAttrPath ( * state , prefix_ , * autoArgs , root ) ;
Value & v1 ( * v ) ;
state - > forceValue ( v1 , pos ) ;
Value v2 ;
state - > autoCallFunction ( * autoArgs , v1 , v2 ) ;
2021-07-03 12:19:10 +00:00
2022-11-03 09:11:28 +00:00
if ( v2 . type ( ) = = nAttrs ) {
for ( auto & i : * v2 . attrs ) {
std : : string name = state - > symbols [ i . name ] ;
if ( name . find ( searchWord ) = = 0 ) {
if ( prefix_ = = " " )
completions - > add ( name ) ;
else
completions - > add ( prefix_ + " . " + name ) ;
}
2021-07-05 19:37:33 +00:00
}
2021-07-03 12:19:10 +00:00
}
2022-11-03 09:11:28 +00:00
} else {
completeFlakeRefWithFragment (
getEvalState ( ) ,
lockFlags ,
getDefaultFlakeAttrPathPrefixes ( ) ,
getDefaultFlakeAttrPaths ( ) ,
prefix ) ;
2021-07-03 12:19:10 +00:00
}
2022-11-16 09:34:32 +00:00
} catch ( EvalError & ) {
// Don't want eval errors to mess-up with the completion engine, so let's just swallow them
2021-07-03 12:19:10 +00:00
}
2020-06-05 12:09:12 +00:00
}
void completeFlakeRefWithFragment (
ref < EvalState > evalState ,
flake : : LockFlags lockFlags ,
Strings attrPathPrefixes ,
const Strings & defaultFlakeAttrPaths ,
std : : string_view prefix )
{
2020-05-11 19:49:02 +00:00
/* Look for flake output attributes that match the
prefix . */
try {
auto hash = prefix . find ( ' # ' ) ;
2021-12-22 11:37:59 +00:00
if ( hash = = std : : string : : npos ) {
completeFlakeRef ( evalState - > store , prefix ) ;
} else {
2022-02-19 17:51:18 +00:00
completionType = ctAttrs ;
2020-05-11 19:49:02 +00:00
auto fragment = prefix . substr ( hash + 1 ) ;
auto flakeRefS = std : : string ( prefix . substr ( 0 , hash ) ) ;
2022-02-19 13:26:34 +00:00
auto flakeRef = parseFlakeRef ( expandTilde ( flakeRefS ) , absPath ( " . " ) ) ;
2020-05-11 19:49:02 +00:00
2020-06-05 12:09:12 +00:00
auto evalCache = openEvalCache ( * evalState ,
2020-08-07 12:13:24 +00:00
std : : make_shared < flake : : LockedFlake > ( lockFlake ( * evalState , flakeRef , lockFlags ) ) ) ;
2020-05-11 19:49:02 +00:00
auto root = evalCache - > getRoot ( ) ;
/* Complete 'fragment' relative to all the
attrpath prefixes as well as the root of the
flake . */
attrPathPrefixes . push_back ( " " ) ;
for ( auto & attrPathPrefixS : attrPathPrefixes ) {
2020-06-05 12:09:12 +00:00
auto attrPathPrefix = parseAttrPath ( * evalState , attrPathPrefixS ) ;
2020-05-11 19:49:02 +00:00
auto attrPathS = attrPathPrefixS + std : : string ( fragment ) ;
2020-06-05 12:09:12 +00:00
auto attrPath = parseAttrPath ( * evalState , attrPathS ) ;
2020-05-11 19:49:02 +00:00
std : : string lastAttr ;
if ( ! attrPath . empty ( ) & & ! hasSuffix ( attrPathS , " . " ) ) {
2022-04-22 19:45:39 +00:00
lastAttr = evalState - > symbols [ attrPath . back ( ) ] ;
2020-05-11 19:49:02 +00:00
attrPath . pop_back ( ) ;
}
auto attr = root - > findAlongAttrPath ( attrPath ) ;
if ( ! attr ) continue ;
2022-03-04 08:44:00 +00:00
for ( auto & attr2 : ( * attr ) - > getAttrs ( ) ) {
2022-04-22 19:45:39 +00:00
if ( hasPrefix ( evalState - > symbols [ attr2 ] , lastAttr ) ) {
2022-03-04 08:44:00 +00:00
auto attrPath2 = ( * attr ) - > getAttrPath ( attr2 ) ;
2020-05-11 19:49:02 +00:00
/* Strip the attrpath prefix. */
attrPath2 . erase ( attrPath2 . begin ( ) , attrPath2 . begin ( ) + attrPathPrefix . size ( ) ) ;
2022-04-22 19:45:39 +00:00
completions - > add ( flakeRefS + " # " + concatStringsSep ( " . " , evalState - > symbols . resolve ( attrPath2 ) ) ) ;
2020-05-11 19:49:02 +00:00
}
}
}
/* And add an empty completion for the default
attrpaths . */
if ( fragment . empty ( ) ) {
2020-06-05 12:09:12 +00:00
for ( auto & attrPath : defaultFlakeAttrPaths ) {
auto attr = root - > findAlongAttrPath ( parseAttrPath ( * evalState , attrPath ) ) ;
2020-05-11 19:49:02 +00:00
if ( ! attr ) continue ;
2020-10-09 07:39:51 +00:00
completions - > add ( flakeRefS + " # " ) ;
2020-05-11 19:49:02 +00:00
}
}
}
} catch ( Error & e ) {
warn ( e . msg ( ) ) ;
}
2020-05-11 20:10:33 +00:00
}
2020-06-05 12:09:12 +00:00
void completeFlakeRef ( ref < Store > store , std : : string_view prefix )
2020-05-11 20:10:33 +00:00
{
2023-03-17 14:33:48 +00:00
if ( ! experimentalFeatureSettings . isEnabled ( Xp : : Flakes ) )
2021-11-26 15:56:25 +00:00
return ;
2020-05-11 20:10:33 +00:00
if ( prefix = = " " )
2020-10-09 07:39:51 +00:00
completions - > add ( " . " ) ;
2020-05-11 20:10:33 +00:00
completeDir ( 0 , prefix ) ;
2020-05-11 19:49:02 +00:00
/* Look for registry entries that match the prefix. */
2020-06-05 12:09:12 +00:00
for ( auto & registry : fetchers : : getRegistries ( store ) ) {
2020-05-11 19:49:02 +00:00
for ( auto & entry : registry - > entries ) {
Remove TreeInfo
The attributes previously stored in TreeInfo (narHash, revCount,
lastModified) are now stored in Input. This makes it less arbitrary
what attributes are stored where.
As a result, the lock file format has changed. An entry like
"info": {
"lastModified": 1585405475,
"narHash": "sha256-bESW0n4KgPmZ0luxvwJ+UyATrC6iIltVCsGdLiphVeE="
},
"locked": {
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "b88ff468e9850410070d4e0ccd68c7011f15b2be",
"type": "github"
},
is now stored as
"locked": {
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "b88ff468e9850410070d4e0ccd68c7011f15b2be",
"type": "github",
"lastModified": 1585405475,
"narHash": "sha256-bESW0n4KgPmZ0luxvwJ+UyATrC6iIltVCsGdLiphVeE="
},
The 'Input' class is now a dumb set of attributes. All the fetcher
implementations subclass InputScheme, not Input. This simplifies the
API.
Also, fix substitution of flake inputs. This was broken since lazy
flake fetching started using fetchTree internally.
2020-05-29 22:44:11 +00:00
auto from = entry . from . to_string ( ) ;
2020-05-11 19:49:02 +00:00
if ( ! hasPrefix ( prefix , " flake: " ) & & hasPrefix ( from , " flake: " ) ) {
std : : string from2 ( from , 6 ) ;
if ( hasPrefix ( from2 , prefix ) )
2020-10-09 07:39:51 +00:00
completions - > add ( from2 ) ;
2020-05-11 19:49:02 +00:00
} else {
if ( hasPrefix ( from , prefix ) )
2020-10-09 07:39:51 +00:00
completions - > add ( from ) ;
2020-05-11 19:49:02 +00:00
}
}
}
}
2022-12-15 21:09:32 +00:00
DerivedPathWithInfo Installable : : toDerivedPath ( )
2017-09-06 14:03:22 +00:00
{
2021-05-17 06:45:08 +00:00
auto buildables = toDerivedPaths ( ) ;
2017-09-06 14:03:22 +00:00
if ( buildables . size ( ) ! = 1 )
throw Error ( " installable '%s' evaluates to %d derivations, where only one is expected " , what ( ) , buildables . size ( ) ) ;
return std : : move ( buildables [ 0 ] ) ;
}
2022-01-18 16:28:18 +00:00
static StorePath getDeriver (
ref < Store > store ,
const Installable & i ,
const StorePath & drvPath )
{
auto derivers = store - > queryValidDerivers ( drvPath ) ;
if ( derivers . empty ( ) )
throw Error ( " '%s' does not have a known deriver " , i . what ( ) ) ;
// FIXME: use all derivers?
return * derivers . begin ( ) ;
}
2020-04-20 11:13:52 +00:00
ref < eval_cache : : EvalCache > openEvalCache (
EvalState & state ,
2020-08-07 12:13:24 +00:00
std : : shared_ptr < flake : : LockedFlake > lockedFlake )
2020-04-20 11:13:52 +00:00
{
2020-08-04 03:46:28 +00:00
auto fingerprint = lockedFlake - > getFingerprint ( ) ;
2020-07-16 14:58:53 +00:00
return make_ref < nix : : eval_cache : : EvalCache > (
2020-08-07 12:13:24 +00:00
evalSettings . useEvalCache & & evalSettings . pureEval
2020-07-16 14:58:53 +00:00
? std : : optional { std : : cref ( fingerprint ) }
: std : : nullopt ,
2020-04-20 11:13:52 +00:00
state ,
2020-04-20 13:27:09 +00:00
[ & state , lockedFlake ] ( )
2020-04-20 11:13:52 +00:00
{
/* For testing whether the evaluation cache is
complete . */
if ( getEnv ( " NIX_ALLOW_EVAL " ) . value_or ( " 1 " ) = = " 0 " )
throw Error ( " not everything is cached, but evaluation is not allowed " ) ;
auto vFlake = state . allocValue ( ) ;
2020-04-20 13:27:09 +00:00
flake : : callFlake ( state , * lockedFlake , * vFlake ) ;
2020-04-20 11:13:52 +00:00
2023-01-19 12:23:04 +00:00
state . forceAttrs ( * vFlake , noPos , " while parsing cached flake data " ) ;
2020-04-20 11:13:52 +00:00
auto aOutputs = vFlake - > attrs - > get ( state . symbols . create ( " outputs " ) ) ;
assert ( aOutputs ) ;
return aOutputs - > value ;
2020-07-16 14:58:53 +00:00
} ) ;
2020-04-20 11:13:52 +00:00
}
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
Installables SourceExprCommand : : parseInstallables (
2019-04-08 14:11:17 +00:00
ref < Store > store , std : : vector < std : : string > ss )
2017-04-25 09:20:37 +00:00
{
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
Installables result ;
2016-02-09 20:34:24 +00:00
2019-11-26 23:05:30 +00:00
if ( file | | expr ) {
if ( file & & expr )
throw UsageError ( " '--file' and '--expr' are exclusive " ) ;
2019-04-08 14:11:17 +00:00
// FIXME: backward compatibility hack
2019-11-26 23:05:30 +00:00
if ( file ) evalSettings . pureEval = false ;
2017-04-25 13:18:05 +00:00
2019-04-08 14:11:17 +00:00
auto state = getEvalState ( ) ;
auto vFile = state - > allocValue ( ) ;
2016-02-09 20:34:24 +00:00
2022-03-16 18:48:50 +00:00
if ( file = = " - " ) {
auto e = state - > parseStdin ( ) ;
state - > eval ( e , * vFile ) ;
2022-12-07 11:58:58 +00:00
}
else if ( file )
2019-11-26 23:05:30 +00:00
state - > evalFile ( lookupFileArg ( * state , * file ) , * vFile ) ;
else {
2023-04-06 11:15:50 +00:00
auto e = state - > parseExprFromString ( * expr , state - > rootPath ( CanonPath : : fromCwd ( ) ) ) ;
2019-11-26 23:05:30 +00:00
state - > eval ( e , * vFile ) ;
}
2017-07-04 13:38:23 +00:00
2022-04-22 13:17:01 +00:00
for ( auto & s : ss ) {
2023-01-11 07:00:44 +00:00
auto [ prefix , extendedOutputsSpec ] = ExtendedOutputsSpec : : parse ( s ) ;
2022-04-22 13:17:01 +00:00
result . push_back (
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
make_ref < InstallableAttrPath > (
2023-02-03 19:53:40 +00:00
InstallableAttrPath : : parse (
2023-08-16 16:29:23 +00:00
state , * this , vFile , std : : move ( prefix ) , std : : move ( extendedOutputsSpec ) ) ) ) ;
2022-04-22 13:17:01 +00:00
}
2016-02-09 20:34:24 +00:00
2019-04-08 14:11:17 +00:00
} else {
2016-02-09 20:34:24 +00:00
2019-04-08 14:11:17 +00:00
for ( auto & s : ss ) {
2020-05-06 15:20:23 +00:00
std : : exception_ptr ex ;
2022-12-13 18:00:34 +00:00
auto [ prefix_ , extendedOutputsSpec_ ] = ExtendedOutputsSpec : : parse ( s ) ;
// To avoid clang's pedantry
auto prefix = std : : move ( prefix_ ) ;
auto extendedOutputsSpec = std : : move ( extendedOutputsSpec_ ) ;
2021-02-12 21:51:36 +00:00
2023-02-03 16:21:47 +00:00
if ( prefix . find ( ' / ' ) ! = std : : string : : npos ) {
2020-04-27 20:53:11 +00:00
try {
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
result . push_back ( make_ref < InstallableDerivedPath > (
2023-08-16 16:29:23 +00:00
InstallableDerivedPath : : parse ( store , prefix , extendedOutputsSpec . raw ) ) ) ;
2020-04-27 20:53:11 +00:00
continue ;
2020-07-14 11:56:18 +00:00
} catch ( BadStorePath & ) {
2020-04-27 20:53:11 +00:00
} catch ( . . . ) {
2020-05-06 15:20:23 +00:00
if ( ! ex )
ex = std : : current_exception ( ) ;
2020-04-27 20:53:11 +00:00
}
2020-05-06 15:20:23 +00:00
}
2020-04-27 20:53:11 +00:00
2020-05-06 15:20:23 +00:00
try {
2022-12-13 18:00:34 +00:00
auto [ flakeRef , fragment ] = parseFlakeRefWithFragment ( std : : string { prefix } , absPath ( " . " ) ) ;
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
result . push_back ( make_ref < InstallableFlake > (
2021-02-17 16:32:10 +00:00
this ,
getEvalState ( ) ,
std : : move ( flakeRef ) ,
2022-02-14 19:39:44 +00:00
fragment ,
2023-08-16 16:29:23 +00:00
std : : move ( extendedOutputsSpec ) ,
2022-02-14 19:39:44 +00:00
getDefaultFlakeAttrPaths ( ) ,
2021-02-17 16:32:10 +00:00
getDefaultFlakeAttrPathPrefixes ( ) ,
lockFlags ) ) ;
2020-05-06 15:20:23 +00:00
continue ;
} catch ( . . . ) {
ex = std : : current_exception ( ) ;
2019-04-08 14:22:04 +00:00
}
2020-04-27 20:53:11 +00:00
2020-05-06 15:20:23 +00:00
std : : rethrow_exception ( ex ) ;
2019-04-08 14:11:17 +00:00
}
2017-04-25 09:20:37 +00:00
}
2016-02-09 20:34:24 +00:00
2017-04-25 09:20:37 +00:00
return result ;
}
2016-02-09 20:34:24 +00:00
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
ref < Installable > SourceExprCommand : : parseInstallable (
2019-04-08 14:11:17 +00:00
ref < Store > store , const std : : string & installable )
2017-09-10 13:58:30 +00:00
{
2019-04-08 14:11:17 +00:00
auto installables = parseInstallables ( store , { installable } ) ;
2017-09-10 13:58:30 +00:00
assert ( installables . size ( ) = = 1 ) ;
return installables . front ( ) ;
}
Make the Derived Path family of types inductive for dynamic derivations
We want to be able to write down `foo.drv^bar.drv^baz`:
`foo.drv^bar.drv` is the dynamic derivation (since it is itself a
derivation output, `bar.drv` from `foo.drv`).
To that end, we create `Single{Derivation,BuiltPath}` types, that are
very similar except instead of having multiple outputs (in a set or
map), they have a single one. This is for everything to the left of the
rightmost `^`.
`NixStringContextElem` has an analogous change, and now can reuse
`SingleDerivedPath` at the top level. In fact, if we ever get rid of
`DrvDeep`, `NixStringContextElem` could be replaced with
`SingleDerivedPath` entirely!
Important note: some JSON formats have changed.
We already can *produce* dynamic derivations, but we can't refer to them
directly. Today, we can merely express building or example at the top
imperatively over time by building `foo.drv^bar.drv`, and then with a
second nix invocation doing `<result-from-first>^baz`, but this is not
declarative. The ethos of Nix of being able to write down the full plan
everything you want to do, and then execute than plan with a single
command, and for that we need the new inductive form of these types.
Co-authored-by: Robert Hensing <roberth@users.noreply.github.com>
Co-authored-by: Valentin Gagarin <valentin.gagarin@tweag.io>
2023-01-15 22:39:04 +00:00
static SingleBuiltPath getBuiltPath ( ref < Store > evalStore , ref < Store > store , const SingleDerivedPath & b )
{
return std : : visit (
overloaded {
[ & ] ( const SingleDerivedPath : : Opaque & bo ) - > SingleBuiltPath {
return SingleBuiltPath : : Opaque { bo . path } ;
} ,
[ & ] ( const SingleDerivedPath : : Built & bfd ) - > SingleBuiltPath {
auto drvPath = getBuiltPath ( evalStore , store , * bfd . drvPath ) ;
// Resolving this instead of `bfd` will yield the same result, but avoid duplicative work.
SingleDerivedPath : : Built truncatedBfd {
. drvPath = makeConstantStorePathRef ( drvPath . outPath ( ) ) ,
. output = bfd . output ,
} ;
auto outputPath = resolveDerivedPath ( * store , truncatedBfd , & * evalStore ) ;
return SingleBuiltPath : : Built {
. drvPath = make_ref < SingleBuiltPath > ( std : : move ( drvPath ) ) ,
. output = { bfd . output , outputPath } ,
} ;
} ,
} ,
b . raw ( ) ) ;
}
2022-11-21 09:49:01 +00:00
std : : vector < BuiltPathWithResult > Installable : : build (
2022-03-28 12:21:35 +00:00
ref < Store > evalStore ,
ref < Store > store ,
Realise mode ,
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
const Installables & installables ,
2022-03-28 12:21:35 +00:00
BuildMode bMode )
2021-05-17 06:45:08 +00:00
{
2022-11-21 09:49:01 +00:00
std : : vector < BuiltPathWithResult > res ;
for ( auto & [ _ , builtPathWithResult ] : build2 ( evalStore , store , mode , installables , bMode ) )
res . push_back ( builtPathWithResult ) ;
2021-05-17 06:45:08 +00:00
return res ;
}
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
std : : vector < std : : pair < ref < Installable > , BuiltPathWithResult > > Installable : : build2 (
2021-09-10 08:39:39 +00:00
ref < Store > evalStore ,
ref < Store > store ,
Realise mode ,
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
const Installables & installables ,
2021-09-10 08:39:39 +00:00
BuildMode bMode )
2017-04-25 09:20:37 +00:00
{
2020-07-15 18:05:42 +00:00
if ( mode = = Realise : : Nothing )
2017-07-14 15:10:13 +00:00
settings . readOnlyMode = true ;
2016-02-09 20:34:24 +00:00
2022-12-15 21:09:32 +00:00
struct Aux
{
2023-02-06 04:28:18 +00:00
ref < ExtraPathInfo > info ;
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
ref < Installable > installable ;
2022-12-15 21:09:32 +00:00
} ;
2021-04-05 13:48:18 +00:00
std : : vector < DerivedPath > pathsToBuild ;
2022-12-15 21:09:32 +00:00
std : : map < DerivedPath , std : : vector < Aux > > backmap ;
2017-07-14 15:10:13 +00:00
2017-09-06 14:03:22 +00:00
for ( auto & i : installables ) {
2022-03-28 12:21:35 +00:00
for ( auto b : i - > toDerivedPaths ( ) ) {
2022-12-15 21:09:32 +00:00
pathsToBuild . push_back ( b . path ) ;
backmap [ b . path ] . push_back ( { . info = b . info , . installable = i } ) ;
2022-03-28 12:21:35 +00:00
}
2017-09-06 14:03:22 +00:00
}
2016-02-09 20:34:24 +00:00
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
std : : vector < std : : pair < ref < Installable > , BuiltPathWithResult > > res ;
2022-03-28 12:21:35 +00:00
2022-03-08 18:50:46 +00:00
switch ( mode ) {
2022-03-28 12:21:35 +00:00
2022-03-08 18:50:46 +00:00
case Realise : : Nothing :
case Realise : : Derivation :
2017-09-06 14:03:22 +00:00
printMissing ( store , pathsToBuild , lvlError ) ;
2022-03-28 12:21:35 +00:00
for ( auto & path : pathsToBuild ) {
2022-12-15 21:09:32 +00:00
for ( auto & aux : backmap [ path ] ) {
2022-03-28 12:21:35 +00:00
std : : visit ( overloaded {
[ & ] ( const DerivedPath : : Built & bfd ) {
2023-01-11 23:57:18 +00:00
auto outputs = resolveDerivedPath ( * store , bfd , & * evalStore ) ;
2022-12-15 21:09:32 +00:00
res . push_back ( { aux . installable , {
Make the Derived Path family of types inductive for dynamic derivations
We want to be able to write down `foo.drv^bar.drv^baz`:
`foo.drv^bar.drv` is the dynamic derivation (since it is itself a
derivation output, `bar.drv` from `foo.drv`).
To that end, we create `Single{Derivation,BuiltPath}` types, that are
very similar except instead of having multiple outputs (in a set or
map), they have a single one. This is for everything to the left of the
rightmost `^`.
`NixStringContextElem` has an analogous change, and now can reuse
`SingleDerivedPath` at the top level. In fact, if we ever get rid of
`DrvDeep`, `NixStringContextElem` could be replaced with
`SingleDerivedPath` entirely!
Important note: some JSON formats have changed.
We already can *produce* dynamic derivations, but we can't refer to them
directly. Today, we can merely express building or example at the top
imperatively over time by building `foo.drv^bar.drv`, and then with a
second nix invocation doing `<result-from-first>^baz`, but this is not
declarative. The ethos of Nix of being able to write down the full plan
everything you want to do, and then execute than plan with a single
command, and for that we need the new inductive form of these types.
Co-authored-by: Robert Hensing <roberth@users.noreply.github.com>
Co-authored-by: Valentin Gagarin <valentin.gagarin@tweag.io>
2023-01-15 22:39:04 +00:00
. path = BuiltPath : : Built {
. drvPath = make_ref < SingleBuiltPath > ( getBuiltPath ( evalStore , store , * bfd . drvPath ) ) ,
. outputs = outputs ,
} ,
2022-12-15 21:09:32 +00:00
. info = aux . info } } ) ;
2022-03-28 12:21:35 +00:00
} ,
[ & ] ( const DerivedPath : : Opaque & bo ) {
2022-12-15 21:09:32 +00:00
res . push_back ( { aux . installable , {
. path = BuiltPath : : Opaque { bo . path } ,
. info = aux . info } } ) ;
2022-03-28 12:21:35 +00:00
} ,
} , path . raw ( ) ) ;
}
}
break ;
2022-03-08 18:50:46 +00:00
case Realise : : Outputs : {
2022-06-06 18:55:05 +00:00
if ( settings . printMissing )
2022-11-18 12:40:48 +00:00
printMissing ( store , pathsToBuild , lvlInfo ) ;
2022-06-06 18:55:05 +00:00
2022-03-08 18:50:46 +00:00
for ( auto & buildResult : store - > buildPathsWithResults ( pathsToBuild , bMode , evalStore ) ) {
if ( ! buildResult . success ( ) )
buildResult . rethrow ( ) ;
2022-03-28 12:21:35 +00:00
2022-12-15 21:09:32 +00:00
for ( auto & aux : backmap [ buildResult . path ] ) {
2022-03-28 12:21:35 +00:00
std : : visit ( overloaded {
[ & ] ( const DerivedPath : : Built & bfd ) {
std : : map < std : : string , StorePath > outputs ;
2023-04-14 22:18:32 +00:00
for ( auto & [ outputName , realisation ] : buildResult . builtOutputs )
outputs . emplace ( outputName , realisation . outPath ) ;
2022-12-15 21:09:32 +00:00
res . push_back ( { aux . installable , {
Make the Derived Path family of types inductive for dynamic derivations
We want to be able to write down `foo.drv^bar.drv^baz`:
`foo.drv^bar.drv` is the dynamic derivation (since it is itself a
derivation output, `bar.drv` from `foo.drv`).
To that end, we create `Single{Derivation,BuiltPath}` types, that are
very similar except instead of having multiple outputs (in a set or
map), they have a single one. This is for everything to the left of the
rightmost `^`.
`NixStringContextElem` has an analogous change, and now can reuse
`SingleDerivedPath` at the top level. In fact, if we ever get rid of
`DrvDeep`, `NixStringContextElem` could be replaced with
`SingleDerivedPath` entirely!
Important note: some JSON formats have changed.
We already can *produce* dynamic derivations, but we can't refer to them
directly. Today, we can merely express building or example at the top
imperatively over time by building `foo.drv^bar.drv`, and then with a
second nix invocation doing `<result-from-first>^baz`, but this is not
declarative. The ethos of Nix of being able to write down the full plan
everything you want to do, and then execute than plan with a single
command, and for that we need the new inductive form of these types.
Co-authored-by: Robert Hensing <roberth@users.noreply.github.com>
Co-authored-by: Valentin Gagarin <valentin.gagarin@tweag.io>
2023-01-15 22:39:04 +00:00
. path = BuiltPath : : Built {
. drvPath = make_ref < SingleBuiltPath > ( getBuiltPath ( evalStore , store , * bfd . drvPath ) ) ,
. outputs = outputs ,
} ,
2022-12-15 21:09:32 +00:00
. info = aux . info ,
. result = buildResult } } ) ;
2022-03-28 12:21:35 +00:00
} ,
[ & ] ( const DerivedPath : : Opaque & bo ) {
2022-12-15 21:09:32 +00:00
res . push_back ( { aux . installable , {
. path = BuiltPath : : Opaque { bo . path } ,
. info = aux . info ,
. result = buildResult } } ) ;
2022-03-28 12:21:35 +00:00
} ,
} , buildResult . path . raw ( ) ) ;
}
2022-03-08 18:50:46 +00:00
}
2022-03-28 12:21:35 +00:00
break ;
2022-03-08 18:50:46 +00:00
}
2022-03-28 12:21:35 +00:00
2022-03-08 18:50:46 +00:00
default :
assert ( false ) ;
}
2022-03-28 12:21:35 +00:00
return res ;
2017-09-06 14:03:22 +00:00
}
2022-03-02 12:54:08 +00:00
BuiltPaths Installable : : toBuiltPaths (
2021-07-16 14:04:47 +00:00
ref < Store > evalStore ,
2020-12-14 16:24:30 +00:00
ref < Store > store ,
Realise mode ,
OperateOn operateOn ,
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
const Installables & installables )
2017-09-06 14:03:22 +00:00
{
2022-11-21 09:49:01 +00:00
if ( operateOn = = OperateOn : : Output ) {
BuiltPaths res ;
for ( auto & p : Installable : : build ( evalStore , store , mode , installables ) )
res . push_back ( p . path ) ;
return res ;
} else {
2020-07-15 18:22:52 +00:00
if ( mode = = Realise : : Nothing )
settings . readOnlyMode = true ;
2021-05-17 06:45:08 +00:00
BuiltPaths res ;
2022-03-02 12:54:08 +00:00
for ( auto & drvPath : Installable : : toDerivations ( store , installables , true ) )
2021-05-17 06:45:08 +00:00
res . push_back ( BuiltPath : : Opaque { drvPath } ) ;
return res ;
2020-07-15 18:22:52 +00:00
}
2020-12-14 16:24:30 +00:00
}
2022-03-02 12:54:08 +00:00
StorePathSet Installable : : toStorePaths (
2021-07-16 14:04:47 +00:00
ref < Store > evalStore ,
ref < Store > store ,
2020-12-14 16:24:30 +00:00
Realise mode , OperateOn operateOn ,
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
const Installables & installables )
2020-12-14 16:24:30 +00:00
{
StorePathSet outPaths ;
2021-07-16 14:04:47 +00:00
for ( auto & path : toBuiltPaths ( evalStore , store , mode , operateOn , installables ) ) {
2021-05-17 06:45:08 +00:00
auto thisOutPaths = path . outPaths ( ) ;
outPaths . insert ( thisOutPaths . begin ( ) , thisOutPaths . end ( ) ) ;
}
2017-04-25 14:19:22 +00:00
return outPaths ;
2017-04-25 09:20:37 +00:00
}
2022-03-02 12:54:08 +00:00
StorePath Installable : : toStorePath (
2021-07-16 14:04:47 +00:00
ref < Store > evalStore ,
ref < Store > store ,
2020-07-15 18:22:52 +00:00
Realise mode , OperateOn operateOn ,
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
ref < Installable > installable )
2017-09-10 13:58:30 +00:00
{
2021-07-16 14:04:47 +00:00
auto paths = toStorePaths ( evalStore , store , mode , operateOn , { installable } ) ;
2017-09-10 13:58:30 +00:00
if ( paths . size ( ) ! = 1 )
2019-04-08 21:58:33 +00:00
throw Error ( " argument '%s' should evaluate to one store path " , installable - > what ( ) ) ;
2017-09-10 13:58:30 +00:00
2020-06-16 20:20:18 +00:00
return * paths . begin ( ) ;
2017-09-10 13:58:30 +00:00
}
2022-03-02 12:54:08 +00:00
StorePathSet Installable : : toDerivations (
2021-09-10 08:39:39 +00:00
ref < Store > store ,
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
const Installables & installables ,
2021-09-10 08:39:39 +00:00
bool useDeriver )
Add "nix show-derivation"
This debug command prints a store derivation in JSON format. For
example:
$ nix show-derivation nixpkgs.hello
{
"/nix/store/ayjwpwwiyy04nh9z71rsdgd3q7bra7ch-hello-2.10.drv": {
"outputs": {
"out": {
"path": "/nix/store/w5w4v29ql0qwqhczkdxs94ix2lh7ibgs-hello-2.10"
}
},
"inputSrcs": [
"/nix/store/9krlzvny65gdc8s7kpb6lkx8cd02c25b-default-builder.sh"
],
"inputDrvs": {
"/nix/store/13839aqdf6x4k3b785rw5f2l7857l6y3-bash-4.4-p12.drv": [
"out"
],
"/nix/store/vgdx7fdc7d4iirmnwj2py1nrvr5qwzj7-hello-2.10.tar.gz.drv": [
"out"
],
"/nix/store/x3kkd0vsqfflbvwf1055l9mr39bg0ms0-stdenv.drv": [
"out"
]
},
"platform": "x86_64-linux",
"builder": "/nix/store/qp5fw57d38bd1n07ss4zxh88zg67c3vg-bash-4.4-p12/bin/bash",
"args": [
"-e",
"/nix/store/9krlzvny65gdc8s7kpb6lkx8cd02c25b-default-builder.sh"
],
"env": {
"buildInputs": "",
"builder": "/nix/store/qp5fw57d38bd1n07ss4zxh88zg67c3vg-bash-4.4-p12/bin/bash",
"configureFlags": "",
"doCheck": "1",
"name": "hello-2.10",
"nativeBuildInputs": "",
"out": "/nix/store/w5w4v29ql0qwqhczkdxs94ix2lh7ibgs-hello-2.10",
"propagatedBuildInputs": "",
"propagatedNativeBuildInputs": "",
"src": "/nix/store/3x7dwzq014bblazs7kq20p9hyzz0qh8g-hello-2.10.tar.gz",
"stdenv": "/nix/store/6zngq1rdh0ans9qyckqimqibgnlvlfrm-stdenv",
"system": "x86_64-linux"
}
}
}
This removes the need for pp-aterm.
2017-09-25 11:43:35 +00:00
{
2019-12-05 18:11:09 +00:00
StorePathSet drvPaths ;
Add "nix show-derivation"
This debug command prints a store derivation in JSON format. For
example:
$ nix show-derivation nixpkgs.hello
{
"/nix/store/ayjwpwwiyy04nh9z71rsdgd3q7bra7ch-hello-2.10.drv": {
"outputs": {
"out": {
"path": "/nix/store/w5w4v29ql0qwqhczkdxs94ix2lh7ibgs-hello-2.10"
}
},
"inputSrcs": [
"/nix/store/9krlzvny65gdc8s7kpb6lkx8cd02c25b-default-builder.sh"
],
"inputDrvs": {
"/nix/store/13839aqdf6x4k3b785rw5f2l7857l6y3-bash-4.4-p12.drv": [
"out"
],
"/nix/store/vgdx7fdc7d4iirmnwj2py1nrvr5qwzj7-hello-2.10.tar.gz.drv": [
"out"
],
"/nix/store/x3kkd0vsqfflbvwf1055l9mr39bg0ms0-stdenv.drv": [
"out"
]
},
"platform": "x86_64-linux",
"builder": "/nix/store/qp5fw57d38bd1n07ss4zxh88zg67c3vg-bash-4.4-p12/bin/bash",
"args": [
"-e",
"/nix/store/9krlzvny65gdc8s7kpb6lkx8cd02c25b-default-builder.sh"
],
"env": {
"buildInputs": "",
"builder": "/nix/store/qp5fw57d38bd1n07ss4zxh88zg67c3vg-bash-4.4-p12/bin/bash",
"configureFlags": "",
"doCheck": "1",
"name": "hello-2.10",
"nativeBuildInputs": "",
"out": "/nix/store/w5w4v29ql0qwqhczkdxs94ix2lh7ibgs-hello-2.10",
"propagatedBuildInputs": "",
"propagatedNativeBuildInputs": "",
"src": "/nix/store/3x7dwzq014bblazs7kq20p9hyzz0qh8g-hello-2.10.tar.gz",
"stdenv": "/nix/store/6zngq1rdh0ans9qyckqimqibgnlvlfrm-stdenv",
"system": "x86_64-linux"
}
}
}
This removes the need for pp-aterm.
2017-09-25 11:43:35 +00:00
2021-09-30 21:31:21 +00:00
for ( const auto & i : installables )
for ( const auto & b : i - > toDerivedPaths ( ) )
2020-07-23 19:02:57 +00:00
std : : visit ( overloaded {
2021-09-30 21:31:21 +00:00
[ & ] ( const DerivedPath : : Opaque & bo ) {
Get rid of `.drv` special-casing for store path installables
The release notes document the change in behavior, I don't include it
here so there is no risk to it getting out of sync.
> Motivation
>> Plumbing CLI should be simple
Store derivation installations are intended as "plumbing": very simple
utilities for advanced users and scripts, and not what regular users
interact with. (Similarly, regular Git users will use branch and tag
names not explicit hashes for most things.)
The plumbing CLI should prize simplicity over convenience; that is its
raison d'etre. If the user provides a path, we should treat it the same
way not caring what sort of path it is.
>> Scripting
This is especially important for the scripting use-case. when arbitrary
paths are sent to e.g. `nix copy` and the script author wants consistent
behavior regardless of what those store paths are. Otherwise the script
author needs to be careful to filter out `.drv` ones, and then run `nix
copy` again with those paths and `--derivation`. That is not good!
>> Surprisingly low impact
Only two lines in the tests need changing, showing that the impact of
this is pretty light.
Many command, like `nix log` will continue to work with just the
derivation passed as before. This because we used to:
- Special case the drv path and replace it with it's outputs (what this
gets rid of).
- Turn those output path *back* into the original drv path.
Now we just skip that entire round trip!
> Context
Issue #7261 lays out a broader vision for getting rid of `--derivation`,
and has this as one of its dependencies. But we can do this with or
without that.
`Installable::toDerivations` is changed to handle the case of a
`DerivedPath::Opaque` ending in `.drv`, which is new: it simply doesn't
need to do any extra work in that case. On this basis, commands like
`nix {show-derivation,log} /nix/store/...-foo.drv` still work as before,
as described above.
When testing older daemons, the post-build-hook will be run against the
old CLI, so we need the old version of the post-build-hook to support
that use-case.
Co-authored-by: Travis A. Everett <travis.a.everett@gmail.com>
Co-authored-by: Valentin Gagarin <valentin.gagarin@tweag.io>
2022-12-16 03:44:14 +00:00
drvPaths . insert (
bo . path . isDerivation ( )
? bo . path
: useDeriver
? getDeriver ( store , * i , bo . path )
: throw Error ( " argument '%s' did not evaluate to a derivation " , i - > what ( ) ) ) ;
2020-07-23 19:02:57 +00:00
} ,
2021-09-30 21:31:21 +00:00
[ & ] ( const DerivedPath : : Built & bfd ) {
Make the Derived Path family of types inductive for dynamic derivations
We want to be able to write down `foo.drv^bar.drv^baz`:
`foo.drv^bar.drv` is the dynamic derivation (since it is itself a
derivation output, `bar.drv` from `foo.drv`).
To that end, we create `Single{Derivation,BuiltPath}` types, that are
very similar except instead of having multiple outputs (in a set or
map), they have a single one. This is for everything to the left of the
rightmost `^`.
`NixStringContextElem` has an analogous change, and now can reuse
`SingleDerivedPath` at the top level. In fact, if we ever get rid of
`DrvDeep`, `NixStringContextElem` could be replaced with
`SingleDerivedPath` entirely!
Important note: some JSON formats have changed.
We already can *produce* dynamic derivations, but we can't refer to them
directly. Today, we can merely express building or example at the top
imperatively over time by building `foo.drv^bar.drv`, and then with a
second nix invocation doing `<result-from-first>^baz`, but this is not
declarative. The ethos of Nix of being able to write down the full plan
everything you want to do, and then execute than plan with a single
command, and for that we need the new inductive form of these types.
Co-authored-by: Robert Hensing <roberth@users.noreply.github.com>
Co-authored-by: Valentin Gagarin <valentin.gagarin@tweag.io>
2023-01-15 22:39:04 +00:00
drvPaths . insert ( resolveDerivedPath ( * store , * bfd . drvPath ) ) ;
2020-07-23 19:02:57 +00:00
} ,
2022-12-15 21:09:32 +00:00
} , b . path . raw ( ) ) ;
Add "nix show-derivation"
This debug command prints a store derivation in JSON format. For
example:
$ nix show-derivation nixpkgs.hello
{
"/nix/store/ayjwpwwiyy04nh9z71rsdgd3q7bra7ch-hello-2.10.drv": {
"outputs": {
"out": {
"path": "/nix/store/w5w4v29ql0qwqhczkdxs94ix2lh7ibgs-hello-2.10"
}
},
"inputSrcs": [
"/nix/store/9krlzvny65gdc8s7kpb6lkx8cd02c25b-default-builder.sh"
],
"inputDrvs": {
"/nix/store/13839aqdf6x4k3b785rw5f2l7857l6y3-bash-4.4-p12.drv": [
"out"
],
"/nix/store/vgdx7fdc7d4iirmnwj2py1nrvr5qwzj7-hello-2.10.tar.gz.drv": [
"out"
],
"/nix/store/x3kkd0vsqfflbvwf1055l9mr39bg0ms0-stdenv.drv": [
"out"
]
},
"platform": "x86_64-linux",
"builder": "/nix/store/qp5fw57d38bd1n07ss4zxh88zg67c3vg-bash-4.4-p12/bin/bash",
"args": [
"-e",
"/nix/store/9krlzvny65gdc8s7kpb6lkx8cd02c25b-default-builder.sh"
],
"env": {
"buildInputs": "",
"builder": "/nix/store/qp5fw57d38bd1n07ss4zxh88zg67c3vg-bash-4.4-p12/bin/bash",
"configureFlags": "",
"doCheck": "1",
"name": "hello-2.10",
"nativeBuildInputs": "",
"out": "/nix/store/w5w4v29ql0qwqhczkdxs94ix2lh7ibgs-hello-2.10",
"propagatedBuildInputs": "",
"propagatedNativeBuildInputs": "",
"src": "/nix/store/3x7dwzq014bblazs7kq20p9hyzz0qh8g-hello-2.10.tar.gz",
"stdenv": "/nix/store/6zngq1rdh0ans9qyckqimqibgnlvlfrm-stdenv",
"system": "x86_64-linux"
}
}
}
This removes the need for pp-aterm.
2017-09-25 11:43:35 +00:00
return drvPaths ;
}
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
RawInstallablesCommand : : RawInstallablesCommand ( )
2020-05-11 13:46:18 +00:00
{
2023-01-12 19:35:22 +00:00
addFlag ( {
. longName = " stdin " ,
2023-06-12 12:40:17 +00:00
. description = " Read installables from the standard input. No default installable applied. " ,
2023-01-12 19:35:22 +00:00
. handler = { & readFromStdIn , true }
} ) ;
2020-05-11 13:46:18 +00:00
expectArgs ( {
. label = " installables " ,
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
. handler = { & rawInstallables } ,
2020-05-11 19:49:02 +00:00
. completer = { [ & ] ( size_t , std : : string_view prefix ) {
completeInstallable ( prefix ) ;
} }
2020-05-11 13:46:18 +00:00
} ) ;
}
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
void RawInstallablesCommand : : applyDefaultInstallables ( std : : vector < std : : string > & rawInstallables )
2023-02-04 03:02:39 +00:00
{
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
if ( rawInstallables . empty ( ) ) {
2022-03-26 10:32:37 +00:00
// FIXME: commands like "nix profile install" should not have a
2019-04-19 14:07:37 +00:00
// default, probably.
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
rawInstallables . push_back ( " . " ) ;
}
}
2023-01-12 19:35:22 +00:00
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
void RawInstallablesCommand : : run ( ref < Store > store )
{
2023-01-12 19:35:22 +00:00
if ( readFromStdIn & & ! isatty ( STDIN_FILENO ) ) {
std : : string word ;
while ( std : : cin > > word ) {
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
rawInstallables . emplace_back ( std : : move ( word ) ) ;
2023-01-12 19:35:22 +00:00
}
2023-06-11 17:33:38 +00:00
} else {
applyDefaultInstallables ( rawInstallables ) ;
2023-01-12 19:35:22 +00:00
}
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
run ( store , std : : move ( rawInstallables ) ) ;
2017-08-29 14:18:00 +00:00
}
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
std : : vector < std : : string > RawInstallablesCommand : : getFlakesForCompletion ( )
2020-06-08 14:20:00 +00:00
{
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
applyDefaultInstallables ( rawInstallables ) ;
return rawInstallables ;
}
void InstallablesCommand : : run ( ref < Store > store , std : : vector < std : : string > & & rawInstallables )
{
auto installables = parseInstallables ( store , rawInstallables ) ;
run ( store , std : : move ( installables ) ) ;
2020-06-08 14:20:00 +00:00
}
2023-02-05 01:45:40 +00:00
InstallableCommand : : InstallableCommand ( )
: SourceExprCommand ( )
2020-05-11 19:49:02 +00:00
{
expectArgs ( {
. label = " installable " ,
2020-05-12 09:53:32 +00:00
. optional = true ,
2020-05-11 19:49:02 +00:00
. handler = { & _installable } ,
. completer = { [ & ] ( size_t , std : : string_view prefix ) {
completeInstallable ( prefix ) ;
} }
} ) ;
}
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
void InstallableCommand : : run ( ref < Store > store )
{
auto installable = parseInstallable ( store , _installable ) ;
run ( store , std : : move ( installable ) ) ;
}
void BuiltPathsCommand : : applyDefaultInstallables ( std : : vector < std : : string > & rawInstallables )
2017-08-29 14:18:00 +00:00
{
Make command infra less stateful and more regular
Already, we had classes like `BuiltPathsCommand` and `StorePathsCommand`
which provided alternative `run` virtual functions providing the
implementation with more arguments. This was a very nice and easy way to
make writing command; just fill in the virtual functions and it is
fairly clear what to do.
However, exception to this pattern were `Installable{,s}Command`. These
two classes instead just had a field where the installables would be
stored, and various side-effecting `prepare` and `load` machinery too
fill them in. Command would wish out those fields.
This isn't so clear to use.
What this commit does is make those command classes like the others,
with richer `run` functions.
Not only does this restore the pattern making commands easier to write,
it has a number of other benefits:
- `prepare` and `load` are gone entirely! One command just hands just
hands off to the next.
- `useDefaultInstallables` because `defaultInstallables`. This takes
over `prepare` for the one case that needs it, and provides enough
flexiblity to handle `nix repl`'s idiosyncratic migration.
- We can use `ref` instead of `std::shared_ptr`. The former must be
initialized (so it is like Rust's `Box` rather than `Option<Box>`,
This expresses the invariant that the installable are in fact
initialized much better.
This is possible because since we just have local variables not
fields, we can stop worrying about the not-yet-initialized case.
- Fewer lines of code! (Finally I have a large refactor that makes the
number go down not up...)
- `nix repl` is now implemented in a clearer way.
The last item deserves further mention. `nix repl` is not like the other
installable commands because instead working from once-loaded
installables, it needs to be able to load them again and again.
To properly support this, we make a new superclass
`RawInstallablesCommand`. This class has the argument parsing and
completion logic, but does *not* hand off parsed installables but
instead just the raw string arguments.
This is exactly what `nix repl` needs, and allows us to instead of
having the logic awkwardly split between `prepare`,
`useDefaultInstallables,` and `load`, have everything right next to each
other. I think this will enable future simplifications of that argument
defaulting logic, but I am saving those for a future PR --- best to keep
code motion and more complicated boolean expression rewriting separate
steps.
The "diagnostic ignored `-Woverloaded-virtual`" pragma helps because C++
doesn't like our many `run` methods. In our case, we don't mind the
shadowing it all --- it is *intentional* that the derived class only
provides a `run` method, and doesn't call any of the overridden `run`
methods.
Helps with https://github.com/NixOS/rfcs/pull/134
2023-02-04 17:03:47 +00:00
if ( rawInstallables . empty ( ) & & ! all )
rawInstallables . push_back ( " . " ) ;
2016-02-09 20:34:24 +00:00
}
}