args.hh

Go to the documentation of this file.

#pragma once
 
#include "lix/libutil/async.hh"
#include "lix/libutil/experimental-features.hh"
#include "lix/libutil/json-fwd.hh"
#include "lix/libutil/types.hh"
#include "lix/libutil/ref.hh"
 
#include <functional>
#include <map>
#include <memory>
#include <limits>
 
#include <optional>
#include <set>
#include <filesystem>
 
 
namespace nix {
 
enum class HashType : char;
 
class MultiCommand;
 
class RootArgs;
 
class AddCompletions;
 
class Args
{
public:

    virtual std::string description() { return ""; }
 
    virtual bool forceImpureByDefault() { return false; }

    virtual std::string doc() { return ""; }
 
    virtual AsyncIoRoot & aio() = 0;
 
protected:

    static const size_t ArityAny = std::numeric_limits<size_t>::max();

    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)
        { }
 
        Handler(std::string * dest)
            : fun([=](std::vector<std::string> ss) { *dest = ss[0]; })
            , arity(1)
        { }
 
        Handler(std::optional<std::string> * dest)
            : 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)
        { }
 
        template<class I>
        Handler(I * dest)
            : fun([=](std::vector<std::string> ss) {
                *dest = string2IntWithUnitPrefix<I>(ss[0]);
              })
            , arity(1)
        { }
 
        template<class I>
        Handler(std::optional<I> * dest)
            : fun([=](std::vector<std::string> ss) {
                *dest = string2IntWithUnitPrefix<I>(ss[0]);
            })
            , arity(1)
        { }
    };

    typedef void CompleterFun(AddCompletions &, size_t, std::string_view);

    typedef std::function<CompleterFun> CompleterClosure;

    struct Flag
    {
        typedef std::shared_ptr<Flag> ptr;
 
        std::string longName;
        std::set<std::string> aliases;
        char shortName = 0;
        std::string description;
        std::string category;
        Strings labels;
        Handler handler;
        CompleterClosure completer;
 
        std::optional<ExperimentalFeature> experimentalFeature;
 
        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);

    struct ExpectedArg
    {
        std::string label;
        bool optional = false;
        Handler handler;
        CompleterClosure completer;
    };

    std::list<ExpectedArg> expectedArgs;
   std::list<ExpectedArg> processedArgs;

   virtual bool processArgs(const Strings & args, bool finish);
 
   virtual Strings::iterator rewriteArgs(Strings & args, Strings::iterator pos)
   {
       return pos;
   }
 
    std::set<std::string> hiddenCategories;

    virtual void initialFlagsProcessed() {}

    virtual std::optional<std::reference_wrapper<RootArgs>> asRootArgs() {
        return std::nullopt;
    }
 
public:
 
    void addFlag(Flag && flag);
 
    void removeFlag(const std::string & longName);
 
    void expectArgs(ExpectedArg && arg)
    {
        expectedArgs.emplace_back(std::move(arg));
    }

    void expectArg(const std::string & label, std::string * dest, bool optional = false)
    {
        expectArgs({
            .label = label,
            .optional = optional,
            .handler = {dest}
        });
    }

    void expectArgs(const std::string & label, std::vector<std::string> * dest)
    {
        expectArgs({
            .label = label,
            .handler = {dest}
        });
    }
 
    static CompleterFun completePath;
 
    static CompleterFun completeDir;
 
    virtual JSON toJSON();
 
    friend class MultiCommand;

    MultiCommand * parent = nullptr;

    RootArgs & getRoot();
};

struct Command : virtual public Args
{
    friend class MultiCommand;
 
    virtual ~Command() { }

    virtual void run() = 0;
 
    typedef int Category;
 
    static constexpr Category catDefault = 0;
    static constexpr Category catCustom = 1000;
 
    virtual std::optional<ExperimentalFeature> experimentalFeature ();
 
    virtual Category category() { return catDefault; }
};
 
using CommandMap = std::map<std::string, std::function<ref<Command>(AsyncIoRoot &)>>;

class MultiCommand : public Command
{
public:
    CommandMap commands;
    Strings customCommandSearchPaths;
    bool isExternalSubcommand;
 
    std::map<Command::Category, std::string> categories;

    std::optional<std::pair<std::string, ref<Command>>> command;
 
    MultiCommand(const CommandMap & commands, bool allowExternal = false);
 
    bool processFlag(Strings::iterator & pos, Strings::iterator end) override;
 
    bool processArgs(const Strings & args, bool finish) override;
 
    JSON toJSON() override;
};

class ExternalCommand : virtual public Command
{
    Strings externalArgv;
    AsyncIoRoot & aio_;
public:
    std::filesystem::path absoluteBinaryPath;
    static constexpr std::string_view lixExternalPrefix = "lix-";
 
    ExternalCommand(AsyncIoRoot & aio, std::filesystem::path absoluteBinaryPath);
 
    virtual bool processFlag(Strings::iterator & pos, Strings::iterator end) override;
    virtual bool processArgs(const Strings & args, bool finish) override;
    virtual void run() override;
    virtual std::optional<ExperimentalFeature> experimentalFeature () override {
        return Xp::LixCustomSubCommands;
    }
 
    // Create a custom category section.
    virtual Category category() override { return catCustom; }
 
    virtual AsyncIoRoot & aio() override { return aio_; }
};
 
/* This returns a Command handle
 * if the command name exist in one of the search paths and points to an executable regular file.
 *
 * i.e. if $searchpath/$command exist for any $searchpath in `searchPaths` and $searchpath/$command links to an executable regular file.
 */
std::optional<ref<Command>> searchForCustomSubcommand(const std::string_view & command, const Strings & searchPaths);
/* This will read all directories in searchPaths one by one and look for all executable regular files which starts with `$prefix-`.
 * Finally, it will return the list of commands stripped of their `$prefix` prefix.
 *
 * If you need to know about a specific command, prefer `searchForCustomSubcommand`.
 */
Strings searchForAllAvailableCustomSubcommands(const std::string_view & prefix, const Strings & searchPaths);
 
struct Completion {
    std::string completion;
    std::string description;
 
    bool operator<(const Completion & other) const;
};

class AddCompletions
{
public:

    enum class Type {
        Normal,
        Filenames,
        Attrs,
    };

    virtual void setType(Type type) = 0;

    virtual void add(std::string completion, std::string description = "") = 0;
};
 
}