2017-07-17 17:02:56 +00:00
|
|
|
#include "command.hh"
|
|
|
|
#include "globals.hh"
|
|
|
|
#include "eval.hh"
|
|
|
|
#include "eval-inline.hh"
|
|
|
|
#include "names.hh"
|
|
|
|
#include "get-drvs.hh"
|
2017-07-18 15:30:09 +00:00
|
|
|
#include "common-args.hh"
|
2018-05-12 18:00:59 +00:00
|
|
|
#include "shared.hh"
|
2020-04-20 13:27:09 +00:00
|
|
|
#include "eval-cache.hh"
|
|
|
|
#include "attr-path.hh"
|
2022-04-21 09:58:40 +00:00
|
|
|
#include "hilite.hh"
|
2017-07-17 17:02:56 +00:00
|
|
|
|
|
|
|
#include <regex>
|
2017-07-26 15:21:46 +00:00
|
|
|
#include <fstream>
|
2022-11-16 15:49:49 +00:00
|
|
|
#include <nlohmann/json.hpp>
|
2017-07-17 17:02:56 +00:00
|
|
|
|
|
|
|
using namespace nix;
|
2022-11-16 15:49:49 +00:00
|
|
|
using json = nlohmann::json;
|
2017-07-17 17:02:56 +00:00
|
|
|
|
2018-05-12 18:00:59 +00:00
|
|
|
std::string wrap(std::string prefix, std::string s)
|
|
|
|
{
|
2022-06-05 16:45:58 +00:00
|
|
|
return concatStrings(prefix, s, ANSI_NORMAL);
|
2018-05-12 18:00:59 +00:00
|
|
|
}
|
|
|
|
|
2020-04-16 13:36:15 +00:00
|
|
|
struct CmdSearch : InstallableCommand, MixJSON
|
2017-07-17 17:02:56 +00:00
|
|
|
{
|
2018-04-18 19:08:35 +00:00
|
|
|
std::vector<std::string> res;
|
2022-06-05 16:45:58 +00:00
|
|
|
std::vector<std::string> excludeRes;
|
2017-07-17 17:02:56 +00:00
|
|
|
|
|
|
|
CmdSearch()
|
|
|
|
{
|
2018-04-18 19:08:35 +00:00
|
|
|
expectArgs("regex", &res);
|
2022-06-05 16:45:58 +00:00
|
|
|
addFlag(Flag {
|
|
|
|
.longName = "exclude",
|
|
|
|
.shortName = 'e',
|
|
|
|
.description = "Hide packages whose attribute path, name or description contain *regex*.",
|
|
|
|
.labels = {"regex"},
|
2022-06-20 16:00:32 +00:00
|
|
|
.handler = {[this](std::string s) {
|
|
|
|
excludeRes.push_back(s);
|
|
|
|
}},
|
2022-06-05 16:45:58 +00:00
|
|
|
});
|
2017-07-17 17:02:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
std::string description() override
|
|
|
|
{
|
2020-12-08 17:09:30 +00:00
|
|
|
return "search for packages";
|
2017-07-17 17:02:56 +00:00
|
|
|
}
|
|
|
|
|
2020-12-08 17:09:30 +00:00
|
|
|
std::string doc() override
|
2017-09-07 18:42:11 +00:00
|
|
|
{
|
2020-12-08 17:09:30 +00:00
|
|
|
return
|
|
|
|
#include "search.md"
|
|
|
|
;
|
2017-09-07 18:42:11 +00:00
|
|
|
}
|
|
|
|
|
2020-04-16 13:36:15 +00:00
|
|
|
Strings getDefaultFlakeAttrPaths() override
|
|
|
|
{
|
2020-04-20 13:27:09 +00:00
|
|
|
return {
|
2023-01-23 15:07:34 +00:00
|
|
|
"packages." + settings.thisSystem.get(),
|
|
|
|
"legacyPackages." + settings.thisSystem.get()
|
2020-04-20 13:27:09 +00:00
|
|
|
};
|
2020-04-16 13:36:15 +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 run(ref<Store> store, ref<Installable> installable) override
|
2017-07-17 17:02:56 +00:00
|
|
|
{
|
|
|
|
settings.readOnlyMode = true;
|
2021-09-22 15:15:07 +00:00
|
|
|
evalSettings.enableImportFromDerivation.setDefault(false);
|
2017-07-17 17:02:56 +00:00
|
|
|
|
2018-02-25 22:38:13 +00:00
|
|
|
// Empty search string should match all packages
|
|
|
|
// Use "^" here instead of ".*" due to differences in resulting highlighting
|
|
|
|
// (see #1893 -- libc++ claims empty search string is not in POSIX grammar)
|
2020-04-20 13:27:09 +00:00
|
|
|
if (res.empty())
|
2018-04-18 19:08:35 +00:00
|
|
|
res.push_back("^");
|
|
|
|
|
|
|
|
std::vector<std::regex> regexes;
|
2022-06-05 16:45:58 +00:00
|
|
|
std::vector<std::regex> excludeRegexes;
|
2018-04-18 19:08:35 +00:00
|
|
|
regexes.reserve(res.size());
|
2022-06-05 16:45:58 +00:00
|
|
|
excludeRegexes.reserve(excludeRes.size());
|
2018-02-25 22:38:13 +00:00
|
|
|
|
2020-04-16 13:36:15 +00:00
|
|
|
for (auto & re : res)
|
2018-04-18 19:08:35 +00:00
|
|
|
regexes.push_back(std::regex(re, std::regex::extended | std::regex::icase));
|
2017-07-17 17:02:56 +00:00
|
|
|
|
2022-06-05 16:45:58 +00:00
|
|
|
for (auto & re : excludeRes)
|
|
|
|
excludeRegexes.emplace_back(re, std::regex::extended | std::regex::icase);
|
|
|
|
|
2017-07-17 17:02:56 +00:00
|
|
|
auto state = getEvalState();
|
|
|
|
|
2022-11-16 15:49:49 +00:00
|
|
|
std::optional<nlohmann::json> jsonOut;
|
|
|
|
if (json) jsonOut = json::object();
|
2017-07-18 15:30:09 +00:00
|
|
|
|
2020-04-20 13:27:09 +00:00
|
|
|
uint64_t results = 0;
|
2017-07-19 14:06:10 +00:00
|
|
|
|
2021-02-04 03:22:11 +00:00
|
|
|
std::function<void(eval_cache::AttrCursor & cursor, const std::vector<Symbol> & attrPath, bool initialRecurse)> visit;
|
2017-07-17 17:02:56 +00:00
|
|
|
|
2021-02-04 03:22:11 +00:00
|
|
|
visit = [&](eval_cache::AttrCursor & cursor, const std::vector<Symbol> & attrPath, bool initialRecurse)
|
2020-04-20 13:27:09 +00:00
|
|
|
{
|
2022-04-22 19:45:39 +00:00
|
|
|
auto attrPathS = state->symbols.resolve(attrPath);
|
|
|
|
|
2020-04-20 13:27:09 +00:00
|
|
|
Activity act(*logger, lvlInfo, actUnknown,
|
2022-04-22 19:45:39 +00:00
|
|
|
fmt("evaluating '%s'", concatStringsSep(".", attrPathS)));
|
2017-07-17 17:02:56 +00:00
|
|
|
try {
|
2020-04-20 13:27:09 +00:00
|
|
|
auto recurse = [&]()
|
|
|
|
{
|
|
|
|
for (const auto & attr : cursor.getAttrs()) {
|
2022-04-22 19:45:39 +00:00
|
|
|
auto cursor2 = cursor.getAttr(state->symbols[attr]);
|
2020-04-20 13:27:09 +00:00
|
|
|
auto attrPath2(attrPath);
|
|
|
|
attrPath2.push_back(attr);
|
2021-02-04 03:22:11 +00:00
|
|
|
visit(*cursor2, attrPath2, false);
|
2020-04-20 13:27:09 +00:00
|
|
|
}
|
|
|
|
};
|
2017-07-17 17:02:56 +00:00
|
|
|
|
2020-04-20 13:27:09 +00:00
|
|
|
if (cursor.isDerivation()) {
|
2022-04-20 14:39:47 +00:00
|
|
|
DrvName name(cursor.getAttr(state->sName)->getString());
|
2017-07-17 17:02:56 +00:00
|
|
|
|
2022-04-20 14:39:47 +00:00
|
|
|
auto aMeta = cursor.maybeGetAttr(state->sMeta);
|
|
|
|
auto aDescription = aMeta ? aMeta->maybeGetAttr(state->sDescription) : nullptr;
|
2020-04-20 13:27:09 +00:00
|
|
|
auto description = aDescription ? aDescription->getString() : "";
|
|
|
|
std::replace(description.begin(), description.end(), '\n', ' ');
|
2022-04-22 19:45:39 +00:00
|
|
|
auto attrPath2 = concatStringsSep(".", attrPathS);
|
2017-07-17 17:02:56 +00:00
|
|
|
|
2022-01-19 16:46:29 +00:00
|
|
|
std::vector<std::smatch> attrPathMatches;
|
|
|
|
std::vector<std::smatch> descriptionMatches;
|
|
|
|
std::vector<std::smatch> nameMatches;
|
|
|
|
bool found = false;
|
2017-07-17 17:02:56 +00:00
|
|
|
|
2022-06-05 16:45:58 +00:00
|
|
|
for (auto & regex : excludeRegexes) {
|
|
|
|
if (
|
|
|
|
std::regex_search(attrPath2, regex)
|
|
|
|
|| std::regex_search(name.name, regex)
|
|
|
|
|| std::regex_search(description, regex))
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-04-20 13:27:09 +00:00
|
|
|
for (auto & regex : regexes) {
|
2022-01-19 16:46:29 +00:00
|
|
|
found = false;
|
2022-01-24 13:47:34 +00:00
|
|
|
auto addAll = [&found](std::sregex_iterator it, std::vector<std::smatch> & vec) {
|
2022-01-19 18:59:02 +00:00
|
|
|
const auto end = std::sregex_iterator();
|
2022-01-24 13:47:34 +00:00
|
|
|
while (it != end) {
|
2022-01-19 18:59:02 +00:00
|
|
|
vec.push_back(*it++);
|
|
|
|
found = true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2022-01-24 13:47:34 +00:00
|
|
|
addAll(std::sregex_iterator(attrPath2.begin(), attrPath2.end(), regex), attrPathMatches);
|
|
|
|
addAll(std::sregex_iterator(name.name.begin(), name.name.end(), regex), nameMatches);
|
|
|
|
addAll(std::sregex_iterator(description.begin(), description.end(), regex), descriptionMatches);
|
2022-01-19 16:46:29 +00:00
|
|
|
|
2022-01-24 13:47:34 +00:00
|
|
|
if (!found)
|
2022-01-19 16:46:29 +00:00
|
|
|
break;
|
2018-04-18 19:08:35 +00:00
|
|
|
}
|
2017-07-17 17:02:56 +00:00
|
|
|
|
2022-01-19 16:46:29 +00:00
|
|
|
if (found)
|
|
|
|
{
|
2020-04-20 13:27:09 +00:00
|
|
|
results++;
|
2017-07-18 15:30:09 +00:00
|
|
|
if (json) {
|
2022-11-16 15:49:49 +00:00
|
|
|
(*jsonOut)[attrPath2] = {
|
|
|
|
{"pname", name.name},
|
|
|
|
{"version", name.version},
|
|
|
|
{"description", description},
|
|
|
|
};
|
2017-07-18 15:30:09 +00:00
|
|
|
} else {
|
2022-06-05 16:48:48 +00:00
|
|
|
auto name2 = hiliteMatches(name.name, nameMatches, ANSI_GREEN, "\e[0;2m");
|
2020-09-25 15:30:04 +00:00
|
|
|
if (results > 1) logger->cout("");
|
|
|
|
logger->cout(
|
2020-04-24 12:42:17 +00:00
|
|
|
"* %s%s",
|
2022-06-05 16:48:48 +00:00
|
|
|
wrap("\e[0;1m", hiliteMatches(attrPath2, attrPathMatches, ANSI_GREEN, "\e[0;1m")),
|
2020-04-24 12:42:17 +00:00
|
|
|
name.version != "" ? " (" + name.version + ")" : "");
|
2020-04-20 13:27:09 +00:00
|
|
|
if (description != "")
|
2020-09-25 15:30:04 +00:00
|
|
|
logger->cout(
|
2022-06-05 16:48:48 +00:00
|
|
|
" %s", hiliteMatches(description, descriptionMatches, ANSI_GREEN, ANSI_NORMAL));
|
2017-07-26 15:21:46 +00:00
|
|
|
}
|
|
|
|
}
|
2017-07-17 17:02:56 +00:00
|
|
|
}
|
|
|
|
|
2020-04-20 13:27:09 +00:00
|
|
|
else if (
|
|
|
|
attrPath.size() == 0
|
2022-04-22 19:45:39 +00:00
|
|
|
|| (attrPathS[0] == "legacyPackages" && attrPath.size() <= 2)
|
|
|
|
|| (attrPathS[0] == "packages" && attrPath.size() <= 2))
|
2020-04-20 13:27:09 +00:00
|
|
|
recurse();
|
2017-07-17 17:02:56 +00:00
|
|
|
|
2021-02-04 03:22:11 +00:00
|
|
|
else if (initialRecurse)
|
|
|
|
recurse();
|
|
|
|
|
2022-04-22 19:45:39 +00:00
|
|
|
else if (attrPathS[0] == "legacyPackages" && attrPath.size() > 2) {
|
2022-04-26 12:01:21 +00:00
|
|
|
auto attr = cursor.maybeGetAttr(state->sRecurseForDerivations);
|
2020-04-27 14:29:26 +00:00
|
|
|
if (attr && attr->getBool())
|
|
|
|
recurse();
|
2017-07-17 17:02:56 +00:00
|
|
|
}
|
|
|
|
|
2020-04-20 13:27:09 +00:00
|
|
|
} catch (EvalError & e) {
|
2022-04-22 19:45:39 +00:00
|
|
|
if (!(attrPath.size() > 0 && attrPathS[0] == "legacyPackages"))
|
2017-07-19 14:06:10 +00:00
|
|
|
throw;
|
2017-07-17 17:02:56 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2022-04-14 12:04:19 +00:00
|
|
|
for (auto & cursor : installable->getCursors(*state))
|
|
|
|
visit(*cursor, cursor->getAttrPath(), true);
|
2017-07-26 15:21:46 +00:00
|
|
|
|
2023-03-02 14:02:24 +00:00
|
|
|
if (json)
|
|
|
|
logger->cout("%s", *jsonOut);
|
2022-11-16 15:49:49 +00:00
|
|
|
|
2020-05-07 10:13:16 +00:00
|
|
|
if (!json && !results)
|
2018-05-12 18:00:59 +00:00
|
|
|
throw Error("no results for the given search term(s)!");
|
2017-07-17 17:02:56 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2020-10-06 11:36:55 +00:00
|
|
|
static auto rCmdSearch = registerCommand<CmdSearch>("search");
|