lunaphied/lix
0
0
Fork 0
forked from lix-project/lix
Code Pull requests Activity

Clean up resolveSearchPathElem

Browse source 
We should use `std::optional<std::string>` not `std::pair<bool,
std::string>` for an optional string.
This commit is contained in:
John Ericson 2023-06-23 12:31:09 -04:00
parent 8d871e1822
commit 87dcd09047
3 changed files with 37 additions and 30 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
src/libexpr/eval.cc
View file

@ -571,22 +571,22 @@ EvalState::EvalState(
allowedPaths = PathSet(); allowedPaths = PathSet();
for (auto & i : searchPath) { for (auto & i : searchPath) {
auto r = resolveSearchPathElem(i); auto r = resolveSearchPathElem(i.path);
if (!r.first) continue; if (!r) continue;
auto path = r.second; auto path = *std::move(r);
if (store->isInStore(r.second)) { if (store->isInStore(path)) {
try { try {
StorePathSet closure; StorePathSet closure;
store->computeFSClosure(store->toStorePath(r.second).first, closure); store->computeFSClosure(store->toStorePath(path).first, closure);
for (auto & path : closure) for (auto & path : closure)
allowPath(path); allowPath(path);
} catch (InvalidPath &) { } catch (InvalidPath &) {
allowPath(r.second); allowPath(path);
} }
} else } else
allowPath(r.second); allowPath(path);
} }
} }

8
src/libexpr/eval.hh
View file

@ -317,7 +317,7 @@ private:
SearchPath searchPath; SearchPath searchPath;
std::map<std::string, std::pair<bool, std::string>> searchPathResolved; std::map<std::string, std::optional<std::string>> searchPathResolved;
/** /**
* Cache used by checkSourcePath(). * Cache used by checkSourcePath().
@ -434,9 +434,13 @@ public:
SourcePath findFile(SearchPath & searchPath, const std::string_view path, const PosIdx pos = noPos); SourcePath findFile(SearchPath & searchPath, const std::string_view path, const PosIdx pos = noPos);
/** /**
* Try to resolve a search path value (not the optinal key part)
*
* If the specified search path element is a URI, download it. * If the specified search path element is a URI, download it.
*
* If it is not found, return `std::nullopt`
*/ */
std::pair<bool, std::string> resolveSearchPathElem(const SearchPathElem & elem); std::optional<std::string> resolveSearchPathElem(const std::string & value);
/** /**
* Evaluate an expression to normal form * Evaluate an expression to normal form

45
src/libexpr/parser.y
View file

@ -772,9 +772,9 @@ SourcePath EvalState::findFile(SearchPath & searchPath, const std::string_view p
continue; continue;
suffix = path.size() == s ? "" : concatStrings("/", path.substr(s)); suffix = path.size() == s ? "" : concatStrings("/", path.substr(s));
} }
auto r = resolveSearchPathElem(i); auto r = resolveSearchPathElem(i.path);
if (!r.first) continue; if (!r) continue;
Path res = r.second + suffix; Path res = *r + suffix;
if (pathExists(res)) return CanonPath(canonPath(res)); if (pathExists(res)) return CanonPath(canonPath(res));
} }
@ -791,49 +791,52 @@ SourcePath EvalState::findFile(SearchPath & searchPath, const std::string_view p
} }
std::pair<bool, std::string> EvalState::resolveSearchPathElem(const SearchPathElem & elem) std::optional<std::string> EvalState::resolveSearchPathElem(const std::string & value)
{ {
auto i = searchPathResolved.find(elem.path); auto i = searchPathResolved.find(value);
if (i != searchPathResolved.end()) return i->second; if (i != searchPathResolved.end()) return i->second;
std::pair<bool, std::string> res; std::optional<std::string> res;
if (EvalSettings::isPseudoUrl(elem.path)) { if (EvalSettings::isPseudoUrl(value)) {
try { try {
auto storePath = fetchers::downloadTarball( auto storePath = fetchers::downloadTarball(
store, EvalSettings::resolvePseudoUrl(elem.path), "source", false).tree.storePath; store, EvalSettings::resolvePseudoUrl(value), "source", false).tree.storePath;
res = { true, store->toRealPath(storePath) }; res = { store->toRealPath(storePath) };
} catch (FileTransferError & e) { } catch (FileTransferError & e) {
logWarning({ logWarning({
.msg = hintfmt("Nix search path entry '%1%' cannot be downloaded, ignoring", elem.path) .msg = hintfmt("Nix search path entry '%1%' cannot be downloaded, ignoring", value)
}); });
res = { false, "" }; res = std::nullopt;
} }
} }
else if (hasPrefix(elem.path, "flake:")) { else if (hasPrefix(value, "flake:")) {
experimentalFeatureSettings.require(Xp::Flakes); experimentalFeatureSettings.require(Xp::Flakes);
auto flakeRef = parseFlakeRef(elem.path.substr(6), {}, true, false); auto flakeRef = parseFlakeRef(value.substr(6), {}, true, false);
debug("fetching flake search path element '%s''", elem.path); debug("fetching flake search path element '%s''", value);
auto storePath = flakeRef.resolve(store).fetchTree(store).first.storePath; auto storePath = flakeRef.resolve(store).fetchTree(store).first.storePath;
res = { true, store->toRealPath(storePath) }; res = { store->toRealPath(storePath) };
} }
else { else {
auto path = absPath(elem.path); auto path = absPath(value);
if (pathExists(path)) if (pathExists(path))
res = { true, path }; res = { path };
else { else {
logWarning({ logWarning({
.msg = hintfmt("Nix search path entry '%1%' does not exist, ignoring", elem.path) .msg = hintfmt("Nix search path entry '%1%' does not exist, ignoring", value)
}); });
res = { false, "" }; res = std::nullopt;
} }
} }
debug("resolved search path element '%s' to '%s'", elem.path, res.second); if (res)
debug("resolved search path element '%s' to '%s'", value, *res);
else
debug("failed to resolve search path element '%s'", value);
searchPathResolved[elem.path] = res; searchPathResolved[value] = res;
return res; return res;
} }