File commandlineparser.cpp#
File List > cli > commandlineparser.cpp
Go to the documentation of this file.
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: 2017-2019 Alejandro Sirgo Rica & Contributors
#include "commandlineparser.h"
#include "abstractlogger.h"
#include "src/utils/globalvalues.h"
#include <QApplication>
#include <QTextStream>
CommandLineParser::CommandLineParser()
: m_description(qApp->applicationName())
{}
namespace {
AbstractLogger out =
AbstractLogger::info(AbstractLogger::Stdout).enableMessageHeader(false);
AbstractLogger err = AbstractLogger::error(AbstractLogger::Stderr);
auto versionOption =
CommandOption({ "v", "version" },
QStringLiteral("Displays version information"));
auto helpOption =
CommandOption({ "h", "help" }, QStringLiteral("Displays this help"));
QString optionsToString(const QList<CommandOption>& options,
const QList<CommandArgument>& subcommands)
{
int size = 0; // track the largest size
QStringList dashedOptionList;
// save the dashed options and its size in order to print the description
// of every option at the same horizontal character position.
for (auto const& option : options) {
QStringList dashedOptions = option.dashedNames();
QString joinedDashedOptions = dashedOptions.join(QStringLiteral(", "));
if (!option.valueName().isEmpty()) {
joinedDashedOptions +=
QStringLiteral(" <%1>").arg(option.valueName());
}
if (joinedDashedOptions.length() > size) {
size = joinedDashedOptions.length();
}
dashedOptionList << joinedDashedOptions;
}
// check the length of the subcommands
for (auto const& subcommand : subcommands) {
if (subcommand.name().length() > size) {
size = subcommand.name().length();
}
}
// generate the text
QString result;
if (!dashedOptionList.isEmpty()) {
result += QObject::tr("Options") + ":\n";
QString linePadding =
QStringLiteral(" ").repeated(size + 4).prepend("\n");
for (int i = 0; i < options.length(); ++i) {
result += QStringLiteral(" %1 %2\n")
.arg(dashedOptionList.at(i).leftJustified(size, ' '))
.arg(options.at(i).description().replace(
QLatin1String("\n"), linePadding));
}
if (!subcommands.isEmpty()) {
result += QLatin1String("\n");
}
}
if (!subcommands.isEmpty()) {
result += QObject::tr("Subcommands") + ":\n";
}
for (const auto& subcommand : subcommands) {
result += QStringLiteral(" %1 %2\n")
.arg(subcommand.name().leftJustified(size, ' '))
.arg(subcommand.description());
}
return result;
}
} // unnamed namespace
bool CommandLineParser::processArgs(const QStringList& args,
QStringList::const_iterator& actualIt,
Node*& actualNode)
{
QString argument = *actualIt;
bool ok = true;
bool isValidArg = false;
for (Node& n : actualNode->subNodes) {
if (n.argument.name() == argument) {
actualNode = &n;
isValidArg = true;
break;
}
}
if (isValidArg) {
auto nextArg = actualNode->argument;
m_foundArgs.append(nextArg);
// check next is help
++actualIt;
ok = processIfOptionIsHelp(args, actualIt, actualNode);
--actualIt;
} else {
ok = false;
err << QStringLiteral("'%1' is not a valid argument.").arg(argument);
}
return ok;
}
bool CommandLineParser::processOptions(const QStringList& args,
QStringList::const_iterator& actualIt,
Node* const actualNode)
{
QString arg = *actualIt;
bool ok = true;
// track values
int equalsPos = arg.indexOf(QLatin1String("="));
QString valueStr;
if (equalsPos != -1) {
valueStr = arg.mid(equalsPos + 1); // right
arg = arg.mid(0, equalsPos); // left
}
// check format -x --xx...
bool isDoubleDashed = arg.startsWith(QLatin1String("--"));
ok = isDoubleDashed ? arg.length() > 3 : arg.length() == 2;
if (!ok) {
err << QStringLiteral("the option %1 has a wrong format.").arg(arg);
return ok;
}
arg = isDoubleDashed ? arg.remove(0, 2) : arg.remove(0, 1);
// get option
auto endIt = actualNode->options.cend();
auto optionIt = endIt;
for (auto i = actualNode->options.cbegin(); i != endIt; ++i) {
if ((*i).names().contains(arg)) {
optionIt = i;
break;
}
}
if (optionIt == endIt) {
QString argName = actualNode->argument.name();
if (argName.isEmpty()) {
argName = qApp->applicationName();
}
err << QStringLiteral("the option '%1' is not a valid option "
"for the argument '%2'.")
.arg(arg)
.arg(argName);
ok = false;
return ok;
}
// check presence of values
CommandOption option = *optionIt;
bool requiresValue = !(option.valueName().isEmpty());
if (!requiresValue && equalsPos != -1) {
err << QStringLiteral("the option '%1' contains a '=' and it doesn't "
"require a value.")
.arg(arg);
ok = false;
return ok;
} else if (requiresValue && valueStr.isEmpty()) {
// find in the next
if (actualIt + 1 != args.cend()) {
++actualIt;
} else {
err << QStringLiteral("Expected value after the option '%1'.")
.arg(arg);
ok = false;
return ok;
}
valueStr = *actualIt;
}
// check the value correctness
if (requiresValue) {
ok = option.checkValue(valueStr);
if (!ok) {
QString msg = option.errorMsg();
if (!msg.endsWith(QLatin1String("."))) {
msg += QLatin1String(".");
}
err << msg;
return ok;
}
option.setValue(valueStr);
}
m_foundOptions.append(option);
return ok;
}
bool CommandLineParser::parse(const QStringList& args)
{
m_foundArgs.clear();
m_foundOptions.clear();
bool ok = true;
Node* actualNode = &m_parseTree;
auto it = ++args.cbegin();
// check version option
QStringList dashedVersion = versionOption.dashedNames();
if (m_withVersion && args.length() > 1 &&
dashedVersion.contains(args.at(1))) {
if (args.length() == 2) {
printVersion();
m_foundOptions << versionOption;
} else {
err << "Invalid arguments after the version option.";
ok = false;
}
return ok;
}
// check help option
ok = processIfOptionIsHelp(args, it, actualNode);
// process the other args
for (; it != args.cend() && ok; ++it) {
const QString& val = *it;
if (val.startsWith(QLatin1String("-"))) {
ok = processOptions(args, it, actualNode);
} else {
ok = processArgs(args, it, actualNode);
}
}
if (!ok && !m_generalErrorMessage.isEmpty()) {
err.enableMessageHeader(false);
err << m_generalErrorMessage;
err.enableMessageHeader(true);
}
return ok;
}
CommandOption CommandLineParser::addVersionOption()
{
m_withVersion = true;
return versionOption;
}
CommandOption CommandLineParser::addHelpOption()
{
m_withHelp = true;
return helpOption;
}
bool CommandLineParser::AddArgument(const CommandArgument& arg,
const CommandArgument& parent)
{
bool res = true;
Node* n = findParent(parent);
if (n == nullptr) {
res = false;
} else {
Node child;
child.argument = arg;
n->subNodes.append(child);
}
return res;
}
bool CommandLineParser::AddOption(const CommandOption& option,
const CommandArgument& parent)
{
bool res = true;
Node* n = findParent(parent);
if (n == nullptr) {
res = false;
} else {
n->options.append(option);
}
return res;
}
bool CommandLineParser::AddOptions(const QList<CommandOption>& options,
const CommandArgument& parent)
{
bool res = true;
for (auto const& option : options) {
if (!AddOption(option, parent)) {
res = false;
break;
}
}
return res;
}
void CommandLineParser::setGeneralErrorMessage(const QString& msg)
{
m_generalErrorMessage = msg;
}
void CommandLineParser::setDescription(const QString& description)
{
m_description = description;
}
bool CommandLineParser::isSet(const CommandArgument& arg) const
{
return m_foundArgs.contains(arg);
}
bool CommandLineParser::isSet(const CommandOption& option) const
{
return m_foundOptions.contains(option);
}
QString CommandLineParser::value(const CommandOption& option) const
{
QString value = option.value();
for (const CommandOption& fOption : m_foundOptions) {
if (option == fOption) {
value = fOption.value();
break;
}
}
return value;
}
void CommandLineParser::printVersion()
{
out << GlobalValues::versionInfo();
}
void CommandLineParser::printHelp(QStringList args, const Node* node)
{
args.removeLast(); // remove the help, it's always the last
QString helpText;
// add usage info
QString argName = node->argument.name();
if (argName.isEmpty()) {
argName = qApp->applicationName();
}
QString argText =
node->subNodes.isEmpty() ? "" : "[" + QObject::tr("subcommands") + "]";
helpText += (QObject::tr("Usage") + ": %1 [%2-" + QObject::tr("options") +
QStringLiteral("] %3\n\n"))
.arg(args.join(QStringLiteral(" ")))
.arg(argName)
.arg(argText);
// short section about default behavior
helpText += QObject::tr("Per default runs Flameshot in the background and "
"adds a tray icon for configuration.");
helpText += "\n\n";
// add command options and subarguments
QList<CommandArgument> subcommands;
for (const Node& n : node->subNodes) {
subcommands.append(n.argument);
}
auto modifiedOptions = node->options;
if (m_withHelp) {
modifiedOptions << helpOption;
}
if (m_withVersion && node == &m_parseTree) {
modifiedOptions << versionOption;
}
helpText += optionsToString(modifiedOptions, subcommands);
// print it
out << helpText;
}
CommandLineParser::Node* CommandLineParser::findParent(
const CommandArgument& parent)
{
if (parent == CommandArgument()) {
return &m_parseTree;
}
// find the parent in the subNodes recursively
Node* res = nullptr;
for (auto& subNode : m_parseTree.subNodes) {
res = recursiveParentSearch(parent, subNode);
if (res != nullptr) {
break;
}
}
return res;
}
CommandLineParser::Node* CommandLineParser::recursiveParentSearch(
const CommandArgument& parent,
Node& node) const
{
Node* res = nullptr;
if (node.argument == parent) {
res = &node;
} else {
for (auto& subNode : node.subNodes) {
res = recursiveParentSearch(parent, subNode);
if (res != nullptr) {
break;
}
}
}
return res;
}
bool CommandLineParser::processIfOptionIsHelp(
const QStringList& args,
QStringList::const_iterator& actualIt,
Node*& actualNode)
{
bool ok = true;
auto dashedHelpNames = helpOption.dashedNames();
if (m_withHelp && actualIt != args.cend() &&
dashedHelpNames.contains(*actualIt)) {
if (actualIt + 1 == args.cend()) {
m_foundOptions << helpOption;
printHelp(args, actualNode);
actualIt++;
} else {
err << "Invalid arguments after the help option.";
ok = false;
}
}
return ok;
}