lix/src/libutil/args.hh

296 lines
7.1 KiB
C++
Raw Normal View History

#pragma once
#include <iostream>
#include <map>
#include <memory>
#include <nlohmann/json_fwd.hpp>
#include "util.hh"
namespace nix {
enum HashType : char;
class MultiCommand;
class Args
{
public:
/**
* Parse the command line, throwing a UsageError if something goes
* wrong.
*/
void parseCmdline(const Strings & cmdline);
/**
* Return a short one-line description of the command.
*/
virtual std::string description() { return ""; }
virtual bool forceImpureByDefault() { return false; }
/**
* Return documentation about this command, in Markdown format.
*/
2020-12-07 12:04:24 +00:00
virtual std::string doc() { return ""; }
protected:
static const size_t ArityAny = std::numeric_limits<size_t>::max();
2020-05-11 13:46:18 +00:00
struct Handler
{
std::function<void(std::vector<std::string>)> fun;
size_t arity;
Handler() {}
Handler(std::function<void(std::vector<std::string>)> && fun)
: fun(std::move(fun))
, arity(ArityAny)
{ }
Handler(std::function<void()> && handler)
: fun([handler{std::move(handler)}](std::vector<std::string>) { handler(); })
, arity(0)
{ }
Handler(std::function<void(std::string)> && handler)
: fun([handler{std::move(handler)}](std::vector<std::string> ss) {
handler(std::move(ss[0]));
})
, arity(1)
{ }
Handler(std::function<void(std::string, std::string)> && handler)
: fun([handler{std::move(handler)}](std::vector<std::string> ss) {
handler(std::move(ss[0]), std::move(ss[1]));
})
, arity(2)
{ }
Handler(std::vector<std::string> * dest)
: fun([=](std::vector<std::string> ss) { *dest = ss; })
, arity(ArityAny)
{ }
2021-01-08 09:44:55 +00:00
Handler(std::string * dest)
: fun([=](std::vector<std::string> ss) { *dest = ss[0]; })
, arity(1)
{ }
Handler(std::optional<std::string> * dest)
2020-05-11 13:46:18 +00:00
: fun([=](std::vector<std::string> ss) { *dest = ss[0]; })
, arity(1)
{ }
template<class T>
Handler(T * dest, const T & val)
: fun([=](std::vector<std::string> ss) { *dest = val; })
, arity(0)
{ }
2021-01-08 09:44:55 +00:00
template<class I>
Handler(I * dest)
: fun([=](std::vector<std::string> ss) {
*dest = string2IntWithUnitPrefix<I>(ss[0]);
2021-01-08 09:44:55 +00:00
})
, arity(1)
{ }
2021-09-14 17:05:28 +00:00
template<class I>
Handler(std::optional<I> * dest)
: fun([=](std::vector<std::string> ss) {
*dest = string2IntWithUnitPrefix<I>(ss[0]);
})
, arity(1)
{ }
2020-05-11 13:46:18 +00:00
};
2021-01-25 18:03:13 +00:00
/* Options. */
struct Flag
{
typedef std::shared_ptr<Flag> ptr;
2020-05-04 20:40:19 +00:00
std::string longName;
std::set<std::string> aliases;
char shortName = 0;
std::string description;
std::string category;
2020-05-04 20:40:19 +00:00
Strings labels;
Handler handler;
2020-05-10 19:35:07 +00:00
std::function<void(size_t, std::string_view)> completer;
2020-05-04 20:40:19 +00:00
std::optional<ExperimentalFeature> experimentalFeature;
2020-05-04 20:40:19 +00:00
static Flag mkHashTypeFlag(std::string && longName, HashType * ht);
static Flag mkHashTypeOptFlag(std::string && longName, std::optional<HashType> * oht);
};
std::map<std::string, Flag::ptr> longFlags;
std::map<char, Flag::ptr> shortFlags;
virtual bool processFlag(Strings::iterator & pos, Strings::iterator end);
/* Positional arguments. */
struct ExpectedArg
{
std::string label;
2020-05-10 19:35:07 +00:00
bool optional = false;
2020-05-11 13:46:18 +00:00
Handler handler;
std::function<void(size_t, std::string_view)> completer;
};
std::list<ExpectedArg> expectedArgs;
virtual bool processArgs(const Strings & args, bool finish);
virtual Strings::iterator rewriteArgs(Strings & args, Strings::iterator pos)
{ return pos; }
std::set<std::string> hiddenCategories;
/**
* Called after all command line flags before the first non-flag
* argument (if any) have been processed.
*/
virtual void initialFlagsProcessed() {}
/**
* Called after the command line has been processed if we need to generate
* completions. Useful for commands that need to know the whole command line
* in order to know what completions to generate.
*/
virtual void completionHook() { }
public:
2020-05-04 20:40:19 +00:00
void addFlag(Flag && flag);
void removeFlag(const std::string & longName);
2020-05-11 13:46:18 +00:00
void expectArgs(ExpectedArg && arg)
{
expectedArgs.emplace_back(std::move(arg));
}
/**
* Expect a string argument.
*/
void expectArg(const std::string & label, std::string * dest, bool optional = false)
{
2020-05-11 13:46:18 +00:00
expectArgs({
.label = label,
.optional = optional,
2020-05-11 13:46:18 +00:00
.handler = {dest}
});
}
/**
* Expect 0 or more arguments.
*/
void expectArgs(const std::string & label, std::vector<std::string> * dest)
{
2020-05-11 13:46:18 +00:00
expectArgs({
.label = label,
.handler = {dest}
});
}
virtual nlohmann::json toJSON();
friend class MultiCommand;
MultiCommand * parent = nullptr;
private:
/**
* Experimental features needed when parsing args. These are checked
* after flag parsing is completed in order to support enabling
* experimental features coming after the flag that needs the
* experimental feature.
*/
std::set<ExperimentalFeature> flagExperimentalFeatures;
};
/**
* A command is an argument parser that can be executed by calling its
* run() method.
*/
struct Command : virtual public Args
{
friend class MultiCommand;
virtual ~Command() { }
/**
* Entry point to the command
*/
virtual void run() = 0;
2020-05-05 13:18:23 +00:00
typedef int Category;
static constexpr Category catDefault = 0;
virtual Category category() { return catDefault; }
};
typedef std::map<std::string, std::function<ref<Command>()>> Commands;
/**
* An argument parser that supports multiple subcommands,
* i.e. <command> <subcommand>.
*/
class MultiCommand : virtual public Args
{
public:
Commands commands;
2020-05-05 13:18:23 +00:00
std::map<Command::Category, std::string> categories;
/**
* Selected command, if any.
*/
2020-05-05 13:18:23 +00:00
std::optional<std::pair<std::string, ref<Command>>> command;
MultiCommand(const Commands & commands);
bool processFlag(Strings::iterator & pos, Strings::iterator end) override;
bool processArgs(const Strings & args, bool finish) override;
void completionHook() override;
nlohmann::json toJSON() override;
};
Strings argvToStrings(int argc, char * * argv);
struct Completion {
std::string completion;
std::string description;
bool operator<(const Completion & other) const;
};
class Completions : public std::set<Completion> {
public:
void add(std::string completion, std::string description = "");
};
extern std::shared_ptr<Completions> completions;
enum CompletionType {
ctNormal,
ctFilenames,
ctAttrs
};
extern CompletionType completionType;
2020-05-10 18:32:21 +00:00
2020-05-11 13:46:18 +00:00
void completePath(size_t, std::string_view prefix);
2020-05-10 19:35:07 +00:00
void completeDir(size_t, std::string_view prefix);
}