Skip to content

Commit

Permalink
Reformat.
Browse files Browse the repository at this point in the history
  • Loading branch information
@grahamc
grahamc committed Jun 24, 2022
1 parent 80226be commit 70f5bc7
Show file tree
Hide file tree
Showing 308 changed files with 25,212 additions and 26,549 deletions.
190 changes: 107 additions & 83 deletions src/build-remote/build-remote.cc
View file

Large diffs are not rendered by default.

199 changes: 87 additions & 112 deletions src/libcmd/command.cc
View file
Original file line number Diff line number Diff line change
@@ -1,61 +1,51 @@
#include "command.hh"
#include "store-api.hh"
#include "local-fs-store.hh"
#include "derivations.hh"
#include "local-fs-store.hh"
#include "nixexpr.hh"
#include "profiles.hh"
#include "store-api.hh"

#include <nlohmann/json.hpp>

extern char * * environ __attribute__((weak));
extern char **environ __attribute__((weak));

namespace nix {

RegisterCommand::Commands * RegisterCommand::commands = nullptr;
RegisterCommand::Commands *RegisterCommand::commands = nullptr;

nix::Commands RegisterCommand::getCommandsFor(const std::vector<std::string> & prefix)
{
nix::Commands
RegisterCommand::getCommandsFor(const std::vector<std::string> &prefix) {
nix::Commands res;
for (auto & [name, command] : *RegisterCommand::commands)
for (auto &[name, command] : *RegisterCommand::commands)
if (name.size() == prefix.size() + 1) {
bool equal = true;
for (size_t i = 0; i < prefix.size(); ++i)
if (name[i] != prefix[i]) equal = false;
if (name[i] != prefix[i])
equal = false;
if (equal)
res.insert_or_assign(name[prefix.size()], command);
}
return res;
}

nlohmann::json NixMultiCommand::toJSON()
{
nlohmann::json NixMultiCommand::toJSON() {
// FIXME: use Command::toJSON() as well.
return MultiCommand::toJSON();
}

StoreCommand::StoreCommand()
{
}
StoreCommand::StoreCommand() {}

ref<Store> StoreCommand::getStore()
{
ref<Store> StoreCommand::getStore() {
if (!_store)
_store = createStore();
return ref<Store>(_store);
}

ref<Store> StoreCommand::createStore()
{
return openStore();
}
ref<Store> StoreCommand::createStore() { return openStore(); }

void StoreCommand::run()
{
run(getStore());
}
void StoreCommand::run() { run(getStore()); }

CopyCommand::CopyCommand()
{
CopyCommand::CopyCommand() {
addFlag({
.longName = "from",
.description = "URL of the source Nix store.",
Expand All @@ -71,64 +61,56 @@ CopyCommand::CopyCommand()
});
}

ref<Store> CopyCommand::createStore()
{
ref<Store> CopyCommand::createStore() {
return srcUri.empty() ? StoreCommand::createStore() : openStore(srcUri);
}

ref<Store> CopyCommand::getDstStore()
{
ref<Store> CopyCommand::getDstStore() {
if (srcUri.empty() && dstUri.empty())
throw UsageError("you must pass '--from' and/or '--to'");

return dstUri.empty() ? openStore() : openStore(dstUri);
}

EvalCommand::EvalCommand()
{
EvalCommand::EvalCommand() {
addFlag({
.longName = "debugger",
.description = "start an interactive environment if evaluation fails",
.handler = {&startReplOnEvalErrors, true},
});
}

EvalCommand::~EvalCommand()
{
EvalCommand::~EvalCommand() {
if (evalState)
evalState->printStats();
}

ref<Store> EvalCommand::getEvalStore()
{
ref<Store> EvalCommand::getEvalStore() {
if (!evalStore)
evalStore = evalStoreUrl ? openStore(*evalStoreUrl) : getStore();
return ref<Store>(evalStore);
}

ref<EvalState> EvalCommand::getEvalState()
{
ref<EvalState> EvalCommand::getEvalState() {
if (!evalState) {
evalState =
#if HAVE_BOEHMGC
#if HAVE_BOEHMGC
std::allocate_shared<EvalState>(traceable_allocator<EvalState>(),
searchPath, getEvalStore(), getStore())
#else
std::make_shared<EvalState>(
searchPath, getEvalStore(), getStore())
#endif
searchPath, getEvalStore(),
getStore())
#else
std::make_shared<EvalState>(searchPath, getEvalStore(), getStore())
#endif
;

if (startReplOnEvalErrors) {
evalState->debugRepl = &runRepl;
evalState->debugRepl = &runRepl;
};
}
return ref<EvalState>(evalState);
}

BuiltPathsCommand::BuiltPathsCommand(bool recursive)
: recursive(recursive)
{
BuiltPathsCommand::BuiltPathsCommand(bool recursive) : recursive(recursive) {
if (recursive)
addFlag({
.longName = "no-recursive",
Expand All @@ -153,27 +135,27 @@ BuiltPathsCommand::BuiltPathsCommand(bool recursive)
});
}

void BuiltPathsCommand::run(ref<Store> store)
{
void BuiltPathsCommand::run(ref<Store> store) {
BuiltPaths paths;
if (all) {
if (installables.size())
throw UsageError("'--all' does not expect arguments");
// XXX: Only uses opaque paths, ignores all the realisations
for (auto & p : store->queryAllValidPaths())
for (auto &p : store->queryAllValidPaths())
paths.push_back(BuiltPath::Opaque{p});
} else {
paths = Installable::toBuiltPaths(getEvalStore(), store, realiseMode, operateOn, installables);
paths = Installable::toBuiltPaths(getEvalStore(), store, realiseMode,
operateOn, installables);
if (recursive) {
// XXX: This only computes the store path closure, ignoring
// intermediate realisations
StorePathSet pathsRoots, pathsClosure;
for (auto & root : paths) {
for (auto &root : paths) {
auto rootFromThis = root.outPaths();
pathsRoots.insert(rootFromThis.begin(), rootFromThis.end());
}
store->computeFSClosure(pathsRoots, pathsClosure);
for (auto & path : pathsClosure)
for (auto &path : pathsClosure)
paths.push_back(BuiltPath::Opaque{path});
}
}
Expand All @@ -182,15 +164,12 @@ void BuiltPathsCommand::run(ref<Store> store)
}

StorePathsCommand::StorePathsCommand(bool recursive)
: BuiltPathsCommand(recursive)
{
}
: BuiltPathsCommand(recursive) {}

void StorePathsCommand::run(ref<Store> store, BuiltPaths && paths)
{
void StorePathsCommand::run(ref<Store> store, BuiltPaths &&paths) {
StorePathSet storePaths;
for (auto & builtPath : paths)
for (auto & p : builtPath.outPaths())
for (auto &builtPath : paths)
for (auto &p : builtPath.outPaths())
storePaths.insert(p);

auto sorted = store->topoSortPaths(storePaths);
Expand All @@ -199,87 +178,80 @@ void StorePathsCommand::run(ref<Store> store, BuiltPaths && paths)
run(store, std::move(sorted));
}

void StorePathCommand::run(ref<Store> store, std::vector<StorePath> && storePaths)
{
void StorePathCommand::run(ref<Store> store,
std::vector<StorePath> &&storePaths) {
if (storePaths.size() != 1)
throw UsageError("this command requires exactly one store path");

run(store, *storePaths.begin());
}

Strings editorFor(const Path & file, uint32_t line)
{
Strings editorFor(const Path &file, uint32_t line) {
auto editor = getEnv("EDITOR").value_or("cat");
auto args = tokenizeString<Strings>(editor);
if (line > 0 && (
editor.find("emacs") != std::string::npos ||
editor.find("nano") != std::string::npos ||
editor.find("vim") != std::string::npos ||
editor.find("kak") != std::string::npos))
if (line > 0 && (editor.find("emacs") != std::string::npos ||
editor.find("nano") != std::string::npos ||
editor.find("vim") != std::string::npos ||
editor.find("kak") != std::string::npos))
args.push_back(fmt("+%d", line));
args.push_back(file);
return args;
}

MixProfile::MixProfile()
{
addFlag({
.longName = "profile",
.description = "The profile to update.",
.labels = {"path"},
.handler = {&profile},
.completer = completePath
});
MixProfile::MixProfile() {
addFlag({.longName = "profile",
.description = "The profile to update.",
.labels = {"path"},
.handler = {&profile},
.completer = completePath});
}

void MixProfile::updateProfile(const StorePath & storePath)
{
if (!profile) return;
void MixProfile::updateProfile(const StorePath &storePath) {
if (!profile)
return;
auto store = getStore().dynamic_pointer_cast<LocalFSStore>();
if (!store) throw Error("'--profile' is not supported for this Nix store");
if (!store)
throw Error("'--profile' is not supported for this Nix store");
auto profile2 = absPath(*profile);
switchLink(profile2,
createGeneration(
ref<LocalFSStore>(store),
profile2, storePath));
createGeneration(ref<LocalFSStore>(store), profile2, storePath));
}

void MixProfile::updateProfile(const BuiltPaths & buildables)
{
if (!profile) return;
void MixProfile::updateProfile(const BuiltPaths &buildables) {
if (!profile)
return;

std::vector<StorePath> result;

for (auto & buildable : buildables) {
std::visit(overloaded {
[&](const BuiltPath::Opaque & bo) {
result.push_back(bo.path);
for (auto &buildable : buildables) {
std::visit(
overloaded{
[&](const BuiltPath::Opaque &bo) { result.push_back(bo.path); },
[&](const BuiltPath::Built &bfd) {
for (auto &output : bfd.outputs) {
result.push_back(output.second);
}
},
},
[&](const BuiltPath::Built & bfd) {
for (auto & output : bfd.outputs) {
result.push_back(output.second);
}
},
}, buildable.raw());
buildable.raw());
}

if (result.size() != 1)
throw UsageError("'--profile' requires that the arguments produce a single store path, but there are %d", result.size());
throw UsageError("'--profile' requires that the arguments produce a "
"single store path, but there are %d",
result.size());

updateProfile(result[0]);
}

MixDefaultProfile::MixDefaultProfile()
{
profile = getDefaultProfile();
}
MixDefaultProfile::MixDefaultProfile() { profile = getDefaultProfile(); }

MixEnvironment::MixEnvironment() : ignoreEnvironment(false)
{
MixEnvironment::MixEnvironment() : ignoreEnvironment(false) {
addFlag({
.longName = "ignore-environment",
.shortName = 'i',
.description = "Clear the entire environment (except those specified with `--keep`).",
.description = "Clear the entire environment (except those specified "
"with `--keep`).",
.handler = {&ignoreEnvironment, true},
});

Expand All @@ -303,22 +275,25 @@ MixEnvironment::MixEnvironment() : ignoreEnvironment(false)
void MixEnvironment::setEnviron() {
if (ignoreEnvironment) {
if (!unset.empty())
throw UsageError("--unset does not make sense with --ignore-environment");
throw UsageError(
"--unset does not make sense with --ignore-environment");

for (const auto & var : keep) {
for (const auto &var : keep) {
auto val = getenv(var.c_str());
if (val) stringsEnv.emplace_back(fmt("%s=%s", var.c_str(), val));
if (val)
stringsEnv.emplace_back(fmt("%s=%s", var.c_str(), val));
}

vectorEnv = stringsToCharPtrs(stringsEnv);
environ = vectorEnv.data();
} else {
if (!keep.empty())
throw UsageError("--keep does not make sense without --ignore-environment");
throw UsageError(
"--keep does not make sense without --ignore-environment");

for (const auto & var : unset)
for (const auto &var : unset)
unsetenv(var.c_str());
}
}

}
} // namespace nix
Loading

0 comments on commit 70f5bc7

Please sign in to comment.