/*******************************************************************************

* CLI - A simple command line interface.

* Copyright (C) 2016-2021 Daniele Pallastrelli

*

* Boost Software License - Version 1.0 - August 17th, 2003

*

* Permission is hereby granted, free of charge, to any person or organization

* obtaining a copy of the software and accompanying documentation covered by

* this license (the "Software") to use, reproduce, display, distribute,

* execute, and transmit the Software, and to prepare derivative works of the

* Software, and to permit third-parties to whom the Software is furnished to

* do so, all subject to the following:

*

* The copyright notices in the Software and this entire statement, including

* the above license grant, this restriction and the following disclaimer,

* must be included in all copies of the Software, in whole or in part, and

* all derivative works of the Software, unless such copies or derivative

* works are solely in the form of machine-executable object code generated by

* a source language processor.

*

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

* FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT

* SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE

* FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,

* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

* DEALINGS IN THE SOFTWARE.

******************************************************************************/

#ifndef CLI_CLI_H

#define CLI_CLI_H

#include <string>

#include <vector>

#include <unordered_map>

#include <memory>

#include <functional>

#include <algorithm>

#include <cctype> // std::isspace

#include <type_traits>

#include "terminalprofile.h"

#include "detail/history.h"

#include "detail/split.h"

#include "detail/fromstring.h"

#include "historystorage.h"

#include "volatilehistorystorage.h"

#include <iostream>

#include <utility>

namespace cli

{

// ********************************************************************

template < typename T > struct TypeDesc { static const char* Name() { return ""; } };

template <> struct TypeDesc< char > { static const char* Name() { return "<char>"; } };

template <> struct TypeDesc< unsigned char > { static const char* Name() { return "<unsigned char>"; } };

template <> struct TypeDesc< signed char > { static const char* Name() { return "<signed char>"; } };

template <> struct TypeDesc< short > { static const char* Name() { return "<short>"; } };

template <> struct TypeDesc< unsigned short > { static const char* Name() { return "<unsigned short>"; } };

template <> struct TypeDesc< int > { static const char* Name() { return "<int>"; } };

template <> struct TypeDesc< unsigned int > { static const char* Name() { return "<unsigned int>"; } };

template <> struct TypeDesc< long > { static const char* Name() { return "<long>"; } };

template <> struct TypeDesc< unsigned long > { static const char* Name() { return "<unsigned long>"; } };

template <> struct TypeDesc< long long > { static const char* Name() { return "<long long>"; } };

template <> struct TypeDesc< unsigned long long > { static const char* Name() { return "<unsigned long long>"; } };

template <> struct TypeDesc< float > { static const char* Name() { return "<float>"; } };

template <> struct TypeDesc< double > { static const char* Name() { return "<double>"; } };

template <> struct TypeDesc< long double > { static const char* Name() { return "<long double>"; } };

template <> struct TypeDesc< bool > { static const char* Name() { return "<bool>"; } };

template <> struct TypeDesc< std::string > { static const char* Name() { return "<string>"; } };

template <> struct TypeDesc< std::vector<std::string> > { static const char* Name() { return "<list of strings>"; } };

// ********************************************************************

// forward declarations

class Menu;

class CliSession;

class Cli

{

// inner class to provide a global output stream

class OutStream

{

public:

template <typename T>

OutStream& operator << (const T& msg)

{

for (auto out: ostreams)

*out << msg;

return *this;

}

// this is the type of std::cout

using CoutType = std::basic_ostream<char, std::char_traits<char> >;

// this is the function signature of std::endl

using StandardEndLine = CoutType &(*)(CoutType &);

// takes << std::endl

OutStream& operator << (StandardEndLine manip)

{

for (auto out: ostreams)

manip(*out);

return *this;

}

private:

friend class Cli;

void Register(std::ostream& o)

{

ostreams.push_back(&o);

}

void UnRegister(std::ostream& o)

{

ostreams.erase(std::remove(ostreams.begin(), ostreams.end(), &o), ostreams.end());

}

std::vector<std::ostream*> ostreams;

};

// end inner class

public:

~Cli() = default;

// disable value semantics

Cli(const Cli&) = delete;

Cli& operator = (const Cli&) = delete;

// enable move semantics

Cli(Cli&&) = default;

Cli& operator = (Cli&&) = default;

/// \deprecated Use the @c Cli::Cli(std::unique_ptr<Menu>,std::unique_ptr<HistoryStorage>)

/// overload version and the method @c Cli::ExitAction instead

[[deprecated("Use the other overload of Cli constructor and the method Cli::ExitAction instead")]]

explicit Cli(

std::unique_ptr<Menu>&& _rootMenu,

std::function< void(std::ostream&)> _exitAction,

std::unique_ptr<HistoryStorage>&& historyStorage = std::make_unique<VolatileHistoryStorage>()

) :

globalHistoryStorage(std::move(historyStorage)),

rootMenu(std::move(_rootMenu)),

exitAction(std::move(_exitAction))

{

}

/**

* @brief Construct a new Cli object having a given root menu that contains the first level commands available.

*

* @param _rootMenu is the @c Menu containing the first level commands available to the user.

* @param historyStorage is the policy for the storage of the cli commands history. You must pass an istance of

* a class derived from @c HistoryStorage. The library provides these policies:

* - @c VolatileHistoryStorage

* - @c FileHistoryStorage it's a persistent history. I.e., the command history is preserved after your application

* is restarted.

*

* However, you can develop your own, just derive a class from @c HistoryStorage .

*/

Cli(std::unique_ptr<Menu> _rootMenu, std::unique_ptr<HistoryStorage> historyStorage = std::make_unique<VolatileHistoryStorage>()) :

globalHistoryStorage(std::move(historyStorage)),

rootMenu(std::move(_rootMenu)),

exitAction{}

{

}

/**

* @brief Add a global exit action that is called every time a session (local or remote) gets the "exit" command.

*

* @param action the function to be called when a session exits, taking a @c std::ostream& parameter to write on that session console.

*/

void ExitAction(const std::function< void(std::ostream&)>& action) { exitAction = action; }

/**

* @brief Add an handler that will be called when a @c std::exception (or derived) is thrown inside a command handler.

* If an exception handler is not set, the exception will be logget on the session output stream.

*

* @param handler the function to be called when an exception is thrown, taking a @c std::ostream& parameter to write on that session console

* and the exception thrown.

*/

void StdExceptionHandler(const std::function< void(std::ostream&, const std::string& cmd, const std::exception&) >& handler)

{

exceptionHandler = handler;

}

/**

* @brief Get a global out stream object that can be used to print on every session currently connected (local and remote)

*

* @return OutStream& the reference to the global out stream writing on every session console.

*/

static OutStream& cout()

{

static OutStream s;

return s;

}

private:

friend class CliSession;

Menu* RootMenu() { return rootMenu.get(); }

void ExitAction( std::ostream& out )

{

if ( exitAction )

exitAction( out );

}

void StdExceptionHandler(std::ostream& out, const std::string& cmd, const std::exception& e)

{

if (exceptionHandler)

exceptionHandler(out, cmd, e);

else

out << e.what() << '\n';

}

static void Register(std::ostream& o) { cout().Register(o); }

static void UnRegister(std::ostream& o) { cout().UnRegister(o); }

void StoreCommands(const std::vector<std::string>& cmds)

{

globalHistoryStorage->Store(cmds);

}

std::vector<std::string> GetCommands() const

{

return globalHistoryStorage->Commands();

}

private:

std::unique_ptr<HistoryStorage> globalHistoryStorage;

std::unique_ptr<Menu> rootMenu; // just to keep it alive

std::function<void(std::ostream&)> exitAction;

std::function<void(std::ostream&, const std::string& cmd, const std::exception& )> exceptionHandler;

};

// ********************************************************************

class Command

{

public:

explicit Command(std::string _name) : name(std::move(_name)), enabled(true) {}

virtual ~Command() noexcept = default;

// disable copy and move semantics

Command(const Command&) = delete;

Command(Command&&) = delete;

Command& operator=(const Command&) = delete;

Command& operator=(Command&&) = delete;

virtual void Enable() { enabled = true; }

virtual void Disable() { enabled = false; }

virtual bool Exec(const std::vector<std::string>& cmdLine, CliSession& session) = 0;

virtual void Help(std::ostream& out) const = 0;

// Returns the collection of completions relatives to this command.

// For simple commands, provides a base implementation that use the name of the command

// for aggregate commands (i.e., Menu), the function is redefined to give the menu command

// and the subcommand recursively

virtual std::vector<std::string> GetCompletionRecursive(const std::string& line) const

{

if (!enabled) return {};

if (name.rfind(line, 0) == 0) return {name}; // name starts_with line

return {};

}

protected:

const std::string& Name() const { return name; }

bool IsEnabled() const { return enabled; }

private:

const std::string name;

bool enabled;

};

// ********************************************************************

// free utility function to get completions from a list of commands and the current line

inline std::vector<std::string> GetCompletions(

const std::shared_ptr<std::vector<std::shared_ptr<Command>>>& cmds,

const std::string& currentLine)

{

std::vector<std::string> result;

std::for_each(cmds->begin(), cmds->end(),

[&currentLine,&result](const auto& cmd)

{

auto c = cmd->GetCompletionRecursive(currentLine);

result.insert(

result.end(),

std::make_move_iterator(c.begin()),

std::make_move_iterator(c.end())

);

}

);

return result;

}

// ********************************************************************

// forward declaration

class CmdHandler;

class UserSession : public std::unordered_map<std::string, std::string>

{

public:

explicit UserSession(std::ostream& _out) noexcept : out(_out) {}

std::ostream& out;

TerminalProfile terminalProfile;

virtual ~UserSession() noexcept = default;

// disable value semantics

UserSession(const UserSession&) = delete;

UserSession& operator = (const UserSession&) = delete;

// disable move semantics

UserSession(UserSession&&) = delete;

UserSession& operator = (UserSession&&) = delete;

};

class CliSession : public UserSession

{

public:

CliSession(Cli& _cli, std::ostream& _out, std::size_t historySize = 100);

virtual ~CliSession() noexcept { Cli::UnRegister(out); }

// disable value semantics

CliSession(const CliSession&) = delete;

CliSession& operator = (const CliSession&) = delete;

// disable move semantics

CliSession(CliSession&&) = delete;

CliSession& operator = (CliSession&&) = delete;

void Feed( const std::string& cmd );

void Prompt();

void Current(Menu* menu) { current = menu; }

void Help() const;

void Exit()

{

exitAction(out);

cli.ExitAction(out);

auto cmds = history.GetCommands();

cli.StoreCommands(cmds);

}

void ExitAction(const std::function<void(std::ostream&)>& action)

{

exitAction = action;

}

void ShowHistory() const { history.Show(out); }

std::string PreviousCmd(const std::string& line)

{

return history.Previous(line);

}

std::string NextCmd()

{

return history.Next();

}

std::vector<std::string> GetCompletions(std::string currentLine) const;

private:

Cli& cli;

Menu* current;

std::unique_ptr<Menu> globalScopeMenu;

std::function< void(std::ostream&)> exitAction = []( std::ostream& ){};

detail::History history;

};

// ********************************************************************

class CmdHandler

{

public:

using CmdVec = std::vector<std::shared_ptr<Command>>;

CmdHandler() = default;

CmdHandler(std::weak_ptr<Command> c, std::weak_ptr<CmdVec> v) :

descriptor(c, v)

{}

void Enable() { descriptor.Enable(); }

void Disable() { descriptor.Disable(); }

void Remove() { descriptor.Remove(); }

private:

struct Descriptor

{

Descriptor() = default;

Descriptor(std::weak_ptr<Command> c, std::weak_ptr<CmdVec> v) :

cmd(std::move(c)), cmds(std::move(v))

{}

void Enable()

{

if (auto c = cmd.lock())

c->Enable();

}

void Disable()

{

if(auto c = cmd.lock())

c->Disable();

}

void Remove()

{

auto scmd = cmd.lock();

auto scmds = cmds.lock();

if (scmd && scmds)

{

auto i = std::find_if(

scmds->begin(),

scmds->end(),

[&](const auto& c){ return c.get() == scmd.get(); }

);

if (i != scmds->end())

scmds->erase(i);

}

}

std::weak_ptr<Command> cmd;

std::weak_ptr<CmdVec> cmds;

};

Descriptor descriptor;

};

// ********************************************************************

class Menu : public Command

{

public:

// disable value and move semantics

Menu(const Menu&) = delete;

Menu& operator = (const Menu&) = delete;

Menu(Menu&&) = delete;

Menu& operator = (Menu&&) = delete;

Menu() : Command({}), parent(nullptr), description(), cmds(std::make_shared<Cmds>()) {}

explicit Menu(const std::string& _name, std::string desc = "(menu)") :

Command(_name), parent(nullptr), description(std::move(desc)), cmds(std::make_shared<Cmds>())

{}

template <typename F>

CmdHandler Insert(const std::string& cmdName, F f, const std::string& help = "", const std::vector<std::string>& parDesc={})

{

// dispatch to private Insert methods

return Insert(cmdName, help, parDesc, f, &F::operator());

}

template <typename F>

CmdHandler Insert(const std::string& cmdName, const std::vector<std::string>& parDesc, F f, const std::string& help = "")

{

// dispatch to private Insert methods

return Insert(cmdName, help, parDesc, f, &F::operator());

}

CmdHandler Insert(std::unique_ptr<Command>&& cmd)

{

std::shared_ptr<Command> scmd(std::move(cmd));

CmdHandler c(scmd, cmds);

cmds->push_back(scmd);

return c;

}

CmdHandler Insert(std::unique_ptr<Menu>&& menu)

{

std::shared_ptr<Menu> smenu(std::move(menu));

CmdHandler c(smenu, cmds);

smenu->parent = this;

cmds->push_back(smenu);

return c;

}

bool Exec(const std::vector<std::string>& cmdLine, CliSession& session) override

{

if (!IsEnabled())

return false;

if (cmdLine[0] == Name())

{

if (cmdLine.size() == 1)

{

session.Current(this);

return true;

}

else

{

// check also for subcommands

std::vector<std::string > subCmdLine(cmdLine.begin()+1, cmdLine.end());

for (auto& cmd: *cmds)

if (cmd->Exec( subCmdLine, session )) return true;

}

}

return false;

}

bool ScanCmds(const std::vector<std::string>& cmdLine, CliSession& session)

{

if (!IsEnabled())

return false;

for (auto& cmd: *cmds)

if (cmd->Exec(cmdLine, session))

return true;

return (parent && parent->Exec(cmdLine, session));

}

std::string Prompt() const

{

return Name();

}

void MainHelp(std::ostream& out)

{

if (!IsEnabled()) return;

for (const auto& cmd: *cmds)

cmd->Help(out);

if (parent != nullptr)

parent->Help(out);

}

void Help(std::ostream& out) const override

{

if (!IsEnabled()) return;

out << " - " << Name() << "\n\t" << description << "\n";

}

// returns:

// - the completions of this menu command

// - the recursive completions of subcommands

// - the recursive completions of parent menu

std::vector<std::string> GetCompletions(const std::string& currentLine) const

{

auto result = cli::GetCompletions(cmds, currentLine);

if (parent != nullptr)

{

auto c = parent->GetCompletionRecursive(currentLine);

result.insert(result.end(), std::make_move_iterator(c.begin()), std::make_move_iterator(c.end()));

}

return result;

}

// returns:

// - the completion of this menu command

// - the recursive completions of the subcommands

std::vector<std::string> GetCompletionRecursive(const std::string& line) const override

{

if (line.rfind(Name(), 0) == 0) // line starts_with Name()

{

auto rest = line;

rest.erase(0, Name().size());

// trim_left(rest);

rest.erase(rest.begin(), std::find_if(rest.begin(), rest.end(), [](int ch) { return !std::isspace(ch); }));

std::vector<std::string> result;

for (const auto& cmd: *cmds)

{

auto cs = cmd->GetCompletionRecursive(rest);

for (const auto& c: cs)

result.push_back(Name() + ' ' + c); // concat submenu with command

}

return result;

}

return Command::GetCompletionRecursive(line);

}

private:

template <typename F, typename R, typename ... Args>

CmdHandler Insert(const std::string& name, const std::string& help, const std::vector<std::string>& parDesc, F& f, R (F::*)(UserSession& s, Args...) const);

template <typename F, typename R>

CmdHandler Insert(const std::string& name, const std::string& help, const std::vector<std::string>& parDesc, F& f, R (F::*)(UserSession& s, const std::vector<std::string>&) const);

template <typename F, typename R>

CmdHandler Insert(const std::string& name, const std::string& help, const std::vector<std::string>& parDesc, F& f, R (F::*)(UserSession& s, std::vector<std::string>) const);

Menu* parent{ nullptr };

const std::string description;

// using shared_ptr instead of unique_ptr to get a weak_ptr

// for the CmdHandler::Descriptor

using Cmds = std::vector<std::shared_ptr<Command>>;

std::shared_ptr<Cmds> cmds;

};

// ********************************************************************

template <typename F, typename ... Args>

struct Select;

template <typename F, typename P, typename ... Args>

struct Select<F, P, Args...>

{

template <typename InputIt>

static void Exec(const F& f, InputIt first, InputIt last)

{

assert( first != last );

assert( std::distance(first, last) == 1+sizeof...(Args) );

const P p = detail::from_string<typename std::decay<P>::type>(*first);

auto g = [&](auto ... pars){ f(p, pars...); };

Select<decltype(g), Args...>::Exec(g, std::next(first), last);

}

};

template <typename F>

struct Select<F>

{

template <typename InputIt>

static void Exec(const F& f, InputIt first, InputIt last)

{

// silence the unused warning in release mode when assert is disabled

static_cast<void>(first);

static_cast<void>(last);

assert(first == last);

f();

}

};

template <typename ... Args>

struct PrintDesc;

template <typename P, typename ... Args>

struct PrintDesc<P, Args...>

{

static void Dump(std::ostream& out)

{

out << " " << TypeDesc< typename std::decay<P>::type >::Name();

PrintDesc<Args...>::Dump(out);

}

};

template <>

struct PrintDesc<>

{

static void Dump(std::ostream& /*out*/) {}

};

// *******************************************

template <typename F, typename ... Args>

class VariadicFunctionCommand : public Command

{

public:

// disable value semantics

VariadicFunctionCommand(const VariadicFunctionCommand&) = delete;

VariadicFunctionCommand& operator = (const VariadicFunctionCommand&) = delete;

VariadicFunctionCommand(

const std::string& _name,

F fun,

std::string desc,

std::vector<std::string> parDesc

)

: Command(_name), func(std::move(fun)), description(std::move(desc)), parameterDesc(std::move(parDesc))

{

}

bool Exec(const std::vector< std::string >& cmdLine, CliSession& session) override

{

if (!IsEnabled()) return false;

const std::size_t paramSize = sizeof...(Args);

if (cmdLine.size() != paramSize+1) return false;

if (Name() == cmdLine[0])

{

try

{

auto g = [&](auto ... pars){ func( session, pars... ); };

Select<decltype(g), Args...>::Exec(g, std::next(cmdLine.begin()), cmdLine.end());

}

catch (std::bad_cast&)

{

return false;

}

return true;

}

return false;

}

void Help(std::ostream& out) const override

{

if (!IsEnabled()) return;

out << " - " << Name();

if (parameterDesc.empty())

PrintDesc<Args...>::Dump(out);

for (auto& s: parameterDesc)

out << " <" << s << '>';

out << "\n\t" << description << "\n";

}

private:

const F func;

const std::string description;

const std::vector<std::string> parameterDesc;

};

template <typename F>

class FreeformCommand : public Command

{

public:

// disable value semantics

FreeformCommand(const FreeformCommand&) = delete;

FreeformCommand& operator = (const FreeformCommand&) = delete;

FreeformCommand(

const std::string& _name,

F fun,

std::string desc,

std::vector<std::string> parDesc

)

: Command(_name), func(std::move(fun)), description(std::move(desc)), parameterDesc(std::move(parDesc))

{

}

bool Exec(const std::vector< std::string >& cmdLine, CliSession& session) override

{

if (!IsEnabled()) return false;

assert(!cmdLine.empty());

if (Name() == cmdLine[0])

{

func(session, std::vector<std::string>(std::next(cmdLine.begin()), cmdLine.end()));

return true;

}

return false;

}

void Help(std::ostream& out) const override

{

if (!IsEnabled()) return;

out << " - " << Name();

if (parameterDesc.empty())

PrintDesc<std::vector<std::string>>::Dump(out);

for (auto& s: parameterDesc)

out << " <" << s << '>';

out << "\n\t" << description << "\n";

}

private:

const F func;

const std::string description;

const std::vector<std::string> parameterDesc;

};

// ********************************************************************

// CliSession implementation

inline CliSession::CliSession(Cli& _cli, std::ostream& _out, std::size_t historySize) :

UserSession(_out),

cli(_cli),

current(cli.RootMenu()),

globalScopeMenu(std::make_unique< Menu >()),

history(historySize)

{

history.LoadCommands(cli.GetCommands());

Cli::Register(out);

globalScopeMenu->Insert(

"help",

[this](UserSession&){ Help(); },

"This help message"

);

globalScopeMenu->Insert(

"exit",

[this](UserSession&){ Exit(); },

"Quit the session"

);

#ifdef CLI_HISTORY_CMD

globalScopeMenu->Insert(

"history",

[this](UserSession&){ ShowHistory(); },

"Show the history"

);

#endif

}

inline void CliSession::Feed(const std::string& cmd)

{

std::vector<std::string> strs;

detail::split(strs, cmd);

if (strs.empty()) return; // just hit enter

history.NewCommand(cmd); // add anyway to history

try

{

// global cmds check

bool found = globalScopeMenu->ScanCmds(strs, *this);

// root menu recursive cmds check

if (!found) found = current->ScanCmds(strs, *this);

if (!found) // error msg if not found

out << "wrong command: " << cmd << '\n';

}

catch(const std::exception& e)

{

cli.StdExceptionHandler(out, cmd, e);

}

catch(...)

{

out << "Cli. Unknown exception caught handling command line \""

<< cmd

<< "\"\n";

}

}

inline void CliSession::Prompt()

{

out << terminalProfile.beforePrompt

<< current->Prompt()

<< terminalProfile.afterPrompt

<< "> "

<< std::flush;

}

inline void CliSession::Help() const

{

out << "Commands available:\n";

globalScopeMenu->MainHelp(out);

current->MainHelp( out );

}

inline std::vector<std::string> CliSession::GetCompletions(std::string currentLine) const

{

// trim_left(currentLine);

currentLine.erase(currentLine.begin(), std::find_if(currentLine.begin(), currentLine.end(), [](int ch) { return !std::isspace(ch); }));

auto v1 = globalScopeMenu->GetCompletions(currentLine);

auto v3 = current->GetCompletions(currentLine);

v1.insert(v1.end(), std::make_move_iterator(v3.begin()), std::make_move_iterator(v3.end()));

// removes duplicates (std::unique requires a sorted container)

std::sort(v1.begin(), v1.end());

auto ip = std::unique(v1.begin(), v1.end());

v1.resize(static_cast<std::size_t>(std::distance(v1.begin(), ip)));

return v1;

}

// Menu implementation

template <typename F, typename R, typename ... Args>

CmdHandler Menu::Insert(const std::string& cmdName, const std::string& help, const std::vector<std::string>& parDesc, F& f, R (F::*)(UserSession& s, Args...) const )

{

return Insert(std::make_unique<VariadicFunctionCommand<F, Args ...>>(cmdName, f, help, parDesc));

}

template <typename F, typename R>

CmdHandler Menu::Insert(const std::string& cmdName, const std::string& help, const std::vector<std::string>& parDesc, F& f, R (F::*)(UserSession& s, const std::vector<std::string>& args) const )

{

return Insert(std::make_unique<FreeformCommand<F>>(cmdName, f, help, parDesc));

}

template <typename F, typename R>

CmdHandler Menu::Insert(const std::string& cmdName, const std::string& help, const std::vector<std::string>& parDesc, F& f, R (F::*)(UserSession& s, std::vector<std::string> args) const )

{

return Insert(std::make_unique<FreeformCommand<F>>(cmdName, f, help, parDesc));

}

} // namespace cli

#endif // CLI_CLI_H