Tests/CMakeLib/testArgumentParser.cxx

/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file LICENSE.rst or https://cmake.org/licensing for details.  */

#include <map>
#include <set>
#include <string>
#include <utility>
#include <vector>

#include <cm/optional>
#include <cm/string_view>
#include <cmext/string_view>

#include "cmArgumentParser.h"
#include "cmArgumentParserTypes.h"

#include "testCommon.h"

namespace {
struct Result : ArgumentParser::ParseResult
{
  struct SubResult : ParseResult
  {
    ArgumentParser::NonEmpty<std::string> SubCommand;
    bool SubOption = false;
    ArgumentParser::NonEmpty<std::string> SubString;
    ArgumentParser::NonEmpty<std::vector<std::string>> SubList;
    std::vector<cm::string_view> ParsedKeywords;
  };

  bool Option1 = false;
  bool Option2 = false;

  std::string String1;
  cm::optional<std::string> String2;
  cm::optional<std::string> String3;
  ArgumentParser::Maybe<std::string> String4;
  ArgumentParser::NonEmpty<std::string> String5;
  ArgumentParser::NonEmpty<std::string> String6;

  ArgumentParser::NonEmpty<std::vector<std::string>> List1;
  ArgumentParser::NonEmpty<std::vector<std::string>> List2;
  cm::optional<ArgumentParser::NonEmpty<std::vector<std::string>>> List3;
  cm::optional<ArgumentParser::NonEmpty<std::vector<std::string>>> List4;
  cm::optional<ArgumentParser::NonEmpty<std::vector<std::string>>> List5;
  cm::optional<ArgumentParser::MaybeEmpty<std::vector<std::string>>> List6;

  ArgumentParser::MaybeEmpty<std::vector<std::vector<std::string>>> Multi1;
  ArgumentParser::MaybeEmpty<std::vector<std::vector<std::string>>> Multi2;
  cm::optional<
    ArgumentParser::MaybeEmpty<std::vector<std::vector<std::string>>>>
    Multi3;
  cm::optional<
    ArgumentParser::MaybeEmpty<std::vector<std::vector<std::string>>>>
    Multi4;

  cm::optional<std::string> Pos0;
  cm::optional<std::string> Pos1;
  cm::optional<std::string> Pos2;
  ArgumentParser::MaybeEmpty<std::vector<std::string>> TrailingPos;

  bool Func0_ = false;
  ArgumentParser::Continue Func0(cm::string_view)
  {
    Func0_ = true;
    return ArgumentParser::Continue::No;
  }

  std::string Func1_;
  ArgumentParser::Continue Func1(cm::string_view arg)
  {
    Func1_ = std::string(arg);
    return ArgumentParser::Continue::No;
  }

  std::map<std::string, std::vector<std::string>> Func2_;
  ArgumentParser::Continue Func2(cm::string_view key, cm::string_view arg)
  {
    Func2_[std::string(key)].emplace_back(arg);
    return key == "FUNC_2b" ? ArgumentParser::Continue::Yes
                            : ArgumentParser::Continue::No;
  }

  std::vector<std::string> Func3_;
  ArgumentParser::Continue Func3(cm::string_view arg)
  {
    Func3_.emplace_back(arg);
    return ArgumentParser::Continue::Yes;
  }

  std::map<std::string, std::vector<std::string>> Func4_;
  ArgumentParser::Continue Func4(cm::string_view key, cm::string_view arg)
  {
    Func4_[std::string(key)].emplace_back(arg);
    return key == "FUNC_4b" ? ArgumentParser::Continue::Yes
                            : ArgumentParser::Continue::No;
  }

  cm::optional<SubResult> Sub;
  ArgumentParser::NonEmpty<std::string> Parent;

  ArgumentParser::Maybe<std::string> UnboundMaybe{ 'u', 'n', 'b', 'o',
                                                   'u', 'n', 'd' };
  ArgumentParser::MaybeEmpty<std::vector<std::string>> UnboundMaybeEmpty{
    1, "unbound"
  };
  ArgumentParser::NonEmpty<std::vector<std::string>> UnboundNonEmpty{
    1, "unbound"
  };
  ArgumentParser::NonEmpty<std::string> UnboundNonEmptyStr{ 'u', 'n', 'b', 'o',
                                                            'u', 'n', 'd' };

  std::vector<cm::string_view> ParsedKeywords;
};

struct Derived : Result
{
};

std::initializer_list<cm::string_view> const args = {
  /* clang-format off */
  "pos0",                    // position index 0
  "OPTION_1",                // option
  "pos2",                    // position index 2, ignored because after keyword
  // "OPTION_2",             // option that is not present
  "STRING_1",                // string arg missing value
  "STRING_2", "foo", "bar",  // string arg + unparsed value, presence captured
  // "STRING_3",             // string arg that is not present
  "STRING_4",                // string arg allowed to be missing value
  "STRING_5", "foo",         // string arg that is not empty
  "STRING_6", "",            // string arg that is empty
  "LIST_1",                  // list arg missing values
  "LIST_2", "foo", "bar",    // list arg with 2 elems
  "LIST_3", "bar",           // list arg ...
  "LIST_3", "foo",           // ... with continuation
  "LIST_4",                  // list arg missing values, presence captured
  // "LIST_5",               // list arg that is not present
  "LIST_6",                  // list arg allowed to be empty
  "MULTI_2",                 // multi list with 0 lists
  "MULTI_3", "foo", "bar",   // multi list with first list with two elems
  "MULTI_3", "bar", "foo",   // multi list with second list with two elems
  // "MULTI_4",              // multi list arg that is not present
  "FUNC_0",                  // callback arg missing value
  "FUNC_1", "foo", "ign1",   // callback with one arg + unparsed value
  "FUNC_2a", "foo", "ign2",  // callback with keyword-dependent arg count
  "FUNC_2b", "bar", "zot",   // callback with keyword-dependent arg count
  "FUNC_3", "foo", "bar",    // callback with list arg ...
  "FUNC_4a", "foo", "ign4",  // callback with keyword-dependent arg count
  "FUNC_4b", "bar", "zot",   // callback with keyword-dependent arg count
  "SUB_CMD",  "foo",         // switch to subparser and set Sub::SUB_CMD to foo
  "SUB_OPTION",              // subparser option
  "SUB_STRING", "sub_value", // subparser string
  "SUB_LIST", "a", "b", "c", // subparser list
  // Return to main parser (simulate another main option if needed)
  "PARENT", "value",
};

struct ResultTrailingPos : public ArgumentParser::ParseResult
{
  bool Option1 = false;
  ArgumentParser::NonEmpty<std::vector<std::string>> List1;

  cm::optional<std::string> Pos0;
  cm::optional<std::string> Pos1;
  ArgumentParser::NonEmpty<std::vector<std::string>> TrailingPos;
};

struct DerivedTrailingPos : ResultTrailingPos
{
};

std::initializer_list<cm::string_view> const args_trailingpos = {
  /* clang-format off */
  "pos0",                    // position index 0
  "pos1",                    // position index 1
  "pos_trailing0",           // trailing positional 0
  "pos_trailing1",           // trailing positional 1
  "OPTION_1",                // option
  "LIST_1", "foo", "bar",    // list arg with 2 elems
  /* clang-format on */
};

bool verifyResult(Result const& result,
                  std::vector<std::string> const& unparsedArguments)
{
  static std::vector<std::string> const foobar = { "foo", "bar" };
  static std::vector<std::string> const barfoo = { "bar", "foo" };
  static std::vector<std::string> const unbound = { "unbound" };
  static std::vector<cm::string_view> const parsedKeywords = {
    /* clang-format off */
    "OPTION_1",
    "STRING_1",
    "STRING_2",
    "STRING_4",
    "STRING_5",
    "STRING_6",
    "LIST_1",
    "LIST_2",
    "LIST_3",
    "LIST_3",
    "LIST_4",
    "LIST_6",
    "MULTI_2",
    "MULTI_3",
    "MULTI_3",
    "FUNC_0",
    "FUNC_1",
    "FUNC_2a",
    "FUNC_2b",
    "FUNC_3",
    "FUNC_4a",
    "FUNC_4b",
    "SUB_CMD",
    "PARENT",
    /* clang-format on */
  };

  static std::vector<cm::string_view> subParsedKeywords = {
    "SUB_CMD", "SUB_OPTION", "SUB_STRING", "SUB_LIST"
  };

  static std::map<std::string, std::vector<std::string>> const func2map = {
    { "FUNC_2a", { "foo" } }, { "FUNC_2b", { "bar", "zot" } }
  };
  static std::map<std::string, std::vector<std::string>> const func4map = {
    { "FUNC_4a", { "foo" } }, { "FUNC_4b", { "bar", "zot" } }
  };
  static std::map<cm::string_view, std::string> const keywordErrors = {
    { "STRING_1"_s, "  missing required value\n" },
    { "STRING_6"_s, "  empty string not allowed\n" },
    { "LIST_1"_s, "  missing required value\n" },
    { "LIST_4"_s, "  missing required value\n" },
    { "FUNC_0"_s, "  missing required value\n" }
  };
  static std::vector<std::string> const unparsed = { "pos2", "bar", "ign1",
                                                     "ign2", "ign4" };

  ASSERT_TRUE(!result);

  ASSERT_TRUE(result.Option1);
  ASSERT_TRUE(!result.Option2);

  ASSERT_TRUE(result.String1.empty());
  ASSERT_TRUE(result.String2);
  ASSERT_TRUE(*result.String2 == "foo");
  ASSERT_TRUE(!result.String3);
  ASSERT_TRUE(result.String4.empty());
  ASSERT_TRUE(result.String5 == "foo");
  ASSERT_TRUE(result.String6.empty());

  ASSERT_TRUE(result.List1.empty());
  ASSERT_TRUE(result.List2 == foobar);
  ASSERT_TRUE(result.List3);
  ASSERT_TRUE(*result.List3 == barfoo);
  ASSERT_TRUE(result.List4);
  ASSERT_TRUE(result.List4->empty());
  ASSERT_TRUE(!result.List5);
  ASSERT_TRUE(result.List6);
  ASSERT_TRUE(result.List6->empty());

  ASSERT_TRUE(result.Multi1.empty());
  ASSERT_TRUE(result.Multi2.size() == 1);
  ASSERT_TRUE(result.Multi2[0].empty());
  ASSERT_TRUE(result.Multi3);
  ASSERT_TRUE((*result.Multi3).size() == 2);
  ASSERT_TRUE((*result.Multi3)[0] == foobar);
  ASSERT_TRUE((*result.Multi3)[1] == barfoo);
  ASSERT_TRUE(!result.Multi4);

  ASSERT_TRUE(result.Pos0 == "pos0");
  ASSERT_TRUE(!result.Pos1);
  ASSERT_TRUE(!result.Pos2);
  ASSERT_TRUE(result.TrailingPos.empty());

  ASSERT_TRUE(result.Func0_ == false);
  ASSERT_TRUE(result.Func1_ == "foo");
  ASSERT_TRUE(result.Func2_ == func2map);
  ASSERT_TRUE(result.Func3_ == foobar);
  ASSERT_TRUE(result.Func4_ == func4map);

  ASSERT_TRUE(unparsedArguments == unparsed);

  ASSERT_TRUE(result.UnboundMaybe == "unbound");
  ASSERT_TRUE(result.UnboundMaybeEmpty == unbound);
  ASSERT_TRUE(result.UnboundNonEmpty == unbound);
  ASSERT_TRUE(result.UnboundNonEmptyStr == "unbound");

  ASSERT_TRUE(result.Sub->SubCommand == "foo");
  ASSERT_TRUE(result.Sub->SubOption);
  ASSERT_TRUE(result.Sub->SubString == "sub_value");
  ASSERT_TRUE(result.Sub->SubList ==
              std::vector<std::string>({ "a", "b", "c" }));
  ASSERT_TRUE(result.Parent == "value");

  ASSERT_TRUE(result.Sub->ParsedKeywords == subParsedKeywords);
  ASSERT_TRUE(result.ParsedKeywords == parsedKeywords);

  ASSERT_TRUE(result.GetKeywordErrors().size() == keywordErrors.size());
  for (auto const& ke : result.GetKeywordErrors()) {
    auto const ki = keywordErrors.find(ke.first);
    ASSERT_TRUE(ki != keywordErrors.end());
    ASSERT_TRUE(ke.second.size() == 1);
    ASSERT_TRUE(*ke.second.begin() == ki->second);
  }

  return true;
}

bool verifyResult(ResultTrailingPos const& result,
                  std::vector<std::string> const& unparsedArguments)
{
  static std::vector<std::string> const foobar = { "foo", "bar" };
  static std::vector<std::string> const trailing = { "pos_trailing0",
                                                     "pos_trailing1" };

  ASSERT_TRUE(result);
  ASSERT_TRUE(unparsedArguments.empty());

  ASSERT_TRUE(result.Option1);
  ASSERT_TRUE(result.List1 == foobar);

  ASSERT_TRUE(result.Pos0 == "pos0");
  ASSERT_TRUE(result.Pos1 == "pos1");
  ASSERT_TRUE(result.TrailingPos == trailing);

  return true;
}

bool testArgumentParserDynamic()
{
  Result result;
  result.Sub = Result::SubResult();

  std::vector<std::string> unparsedArguments;

  std::function<ArgumentParser::Continue(cm::string_view, cm::string_view)>
    func4 = [&result](cm::string_view key,
                      cm::string_view arg) -> ArgumentParser::Continue {
    return result.Func4(key, arg);
  };

  cmArgumentParser<void> parserDynamic;
  parserDynamic.Bind("OPTION_1"_s, result.Option1);
  ASSERT_TRUE(parserDynamic.HasKeyword("OPTION_1"_s));
  ASSERT_TRUE(!parserDynamic.HasKeyword("NOT_AN_OPTION"_s));

  auto subParser = cmArgumentParser<void>{}
                     .Bind("SUB_CMD"_s, result.Sub->SubCommand)
                     .Bind("SUB_OPTION"_s, result.Sub->SubOption)
                     .Bind("SUB_STRING"_s, result.Sub->SubString)
                     .Bind("SUB_LIST"_s, result.Sub->SubList)
                     .BindParsedKeywords(result.Sub->ParsedKeywords);

  static_cast<ArgumentParser::ParseResult&>(result) =
    cmArgumentParser<void>{}
      .Bind(0, result.Pos0)
      .Bind(1, result.Pos1)
      .Bind(2, result.Pos2)
      .BindTrailingArgs(result.TrailingPos)
      .Bind("OPTION_1"_s, result.Option1)
      .Bind("OPTION_2"_s, result.Option2)
      .Bind("STRING_1"_s, result.String1)
      .Bind("STRING_2"_s, result.String2)
      .Bind("STRING_3"_s, result.String3)
      .Bind("STRING_4"_s, result.String4)
      .Bind("STRING_5"_s, result.String5)
      .Bind("STRING_6"_s, result.String6)
      .Bind("LIST_1"_s, result.List1)
      .Bind("LIST_2"_s, result.List2)
      .Bind("LIST_3"_s, result.List3)
      .Bind("LIST_4"_s, result.List4)
      .Bind("LIST_5"_s, result.List5)
      .Bind("LIST_6"_s, result.List6)
      .Bind("MULTI_1"_s, result.Multi1)
      .Bind("MULTI_2"_s, result.Multi2)
      .Bind("MULTI_3"_s, result.Multi3)
      .Bind("MULTI_4"_s, result.Multi4)
      .Bind("FUNC_0"_s,
            [&result](cm::string_view arg) -> ArgumentParser::Continue {
              return result.Func0(arg);
            })
      .Bind("FUNC_1"_s,
            [&result](cm::string_view arg) -> ArgumentParser::Continue {
              return result.Func1(arg);
            })
      .Bind("FUNC_2a"_s,
            [&result](cm::string_view key, cm::string_view arg)
              -> ArgumentParser::Continue { return result.Func2(key, arg); })
      .Bind("FUNC_2b"_s,
            [&result](cm::string_view key, cm::string_view arg)
              -> ArgumentParser::Continue { return result.Func2(key, arg); })
      .Bind("FUNC_3"_s,
            [&result](cm::string_view arg) -> ArgumentParser::Continue {
              return result.Func3(arg);
            })
      .Bind("FUNC_4a"_s, func4)
      .Bind("FUNC_4b"_s, func4)
      .BindSubParser("SUB_CMD"_s, subParser, result.Sub)
      .Bind("PARENT"_s, result.Parent)
      .BindParsedKeywords(result.ParsedKeywords)
      .Parse(args, &unparsedArguments);

  if (!verifyResult(result, unparsedArguments)) {
    return false;
  }

  unparsedArguments.clear();

  ResultTrailingPos result_trailing;
  static_cast<ArgumentParser::ParseResult&>(result_trailing) =
    cmArgumentParser<void>{}
      .Bind(0, result_trailing.Pos0)
      .Bind(1, result_trailing.Pos1)
      .BindTrailingArgs(result_trailing.TrailingPos)
      .Bind("OPTION_1"_s, result_trailing.Option1)
      .Bind("LIST_1"_s, result_trailing.List1)
      .Parse(args_trailingpos, &unparsedArguments);

  return verifyResult(result_trailing, unparsedArguments);
}

static auto const parserStaticFunc4 =
  [](Result& result, cm::string_view key,
     cm::string_view arg) -> ArgumentParser::Continue {
  return result.Func4(key, arg);
};

#define BIND_ALL(name, resultType)                                            \
  /* Define the sub-parser first */                                           \
  static auto sub##name =                                                     \
    cmArgumentParser<resultType::SubResult>{}                                 \
      .Bind("SUB_CMD"_s, &resultType::SubResult::SubCommand)                  \
      .Bind("SUB_OPTION"_s, &resultType::SubResult::SubOption)                \
      .Bind("SUB_STRING"_s, &resultType::SubResult::SubString)                \
      .Bind("SUB_LIST"_s, &resultType::SubResult::SubList)                    \
      .BindParsedKeywords(&resultType::SubResult::ParsedKeywords);            \
                                                                              \
  /* Define the main parser, which uses the sub-parser */                     \
  static const auto name =                                                    \
    cmArgumentParser<resultType>{}                                            \
      .Bind(0, &resultType::Pos0)                                             \
      .Bind(1, &resultType::Pos1)                                             \
      .Bind(2, &resultType::Pos2)                                             \
      .BindTrailingArgs(&resultType::TrailingPos)                             \
      .Bind("OPTION_1"_s, &resultType::Option1)                               \
      .Bind("OPTION_2"_s, &resultType::Option2)                               \
      .Bind("STRING_1"_s, &resultType::String1)                               \
      .Bind("STRING_2"_s, &resultType::String2)                               \
      .Bind("STRING_3"_s, &resultType::String3)                               \
      .Bind("STRING_4"_s, &resultType::String4)                               \
      .Bind("STRING_5"_s, &resultType::String5)                               \
      .Bind("STRING_6"_s, &resultType::String6)                               \
      .Bind("LIST_1"_s, &resultType::List1)                                   \
      .Bind("LIST_2"_s, &resultType::List2)                                   \
      .Bind("LIST_3"_s, &resultType::List3)                                   \
      .Bind("LIST_4"_s, &resultType::List4)                                   \
      .Bind("LIST_5"_s, &resultType::List5)                                   \
      .Bind("LIST_6"_s, &resultType::List6)                                   \
      .Bind("MULTI_1"_s, &resultType::Multi1)                                 \
      .Bind("MULTI_2"_s, &resultType::Multi2)                                 \
      .Bind("MULTI_3"_s, &resultType::Multi3)                                 \
      .Bind("MULTI_4"_s, &resultType::Multi4)                                 \
      .Bind("FUNC_0"_s, &resultType::Func0)                                   \
      .Bind("FUNC_1"_s, &resultType::Func1)                                   \
      .Bind("FUNC_2a"_s, &resultType::Func2)                                  \
      .Bind("FUNC_2b"_s, &resultType::Func2)                                  \
      .Bind("FUNC_3"_s,                                                       \
            [](resultType& result, cm::string_view arg)                       \
              -> ArgumentParser::Continue { return result.Func3(arg); })      \
      .Bind("FUNC_4a"_s, parserStaticFunc4)                                   \
      .Bind("FUNC_4b"_s, parserStaticFunc4)                                   \
      .BindSubParser("SUB_CMD"_s, sub##name, &resultType::Sub)                \
      .Bind("PARENT"_s, &resultType::Parent)                                  \
      .BindParsedKeywords(&resultType::ParsedKeywords);

BIND_ALL(parserStatic, Result);
BIND_ALL(parserDerivedStatic, Derived);

#define BIND_TRAILING(name, resultType)                                       \
  static auto const name = cmArgumentParser<resultType>{}                     \
                             .Bind(0, &resultType::Pos0)                      \
                             .Bind(1, &resultType::Pos1)                      \
                             .BindTrailingArgs(&resultType::TrailingPos)      \
                             .Bind("OPTION_1"_s, &resultType::Option1)        \
                             .Bind("LIST_1"_s, &resultType::List1)

BIND_TRAILING(parserTrailingStatic, ResultTrailingPos);
BIND_TRAILING(parserTrailingDerivedStatic, DerivedTrailingPos);

bool testArgumentParserStatic()
{
  ASSERT_TRUE(parserStatic.HasKeyword("OPTION_1"_s));
  ASSERT_TRUE(!parserStatic.HasKeyword("NOT_AN_OPTION"_s));

  std::vector<std::string> unparsedArguments;
  Result const result = parserStatic.Parse(args, &unparsedArguments);
  if (!verifyResult(result, unparsedArguments)) {
    return false;
  }

  unparsedArguments.clear();
  ResultTrailingPos const result_trailing =
    parserTrailingStatic.Parse(args_trailingpos, &unparsedArguments);
  return verifyResult(result_trailing, unparsedArguments);
}

bool testArgumentParserDerivedStatic()
{
  ASSERT_TRUE(parserDerivedStatic.HasKeyword("OPTION_1"_s));
  ASSERT_TRUE(!parserDerivedStatic.HasKeyword("NOT_AN_OPTION"_s));

  std::vector<std::string> unparsedArguments;
  Derived const result = parserDerivedStatic.Parse(args, &unparsedArguments);
  if (!verifyResult(result, unparsedArguments)) {
    return false;
  }

  unparsedArguments.clear();
  ResultTrailingPos const result_trailing =
    parserTrailingDerivedStatic.Parse(args_trailingpos, &unparsedArguments);
  return verifyResult(result_trailing, unparsedArguments);
}

bool testArgumentParserStaticBool()
{
  std::vector<std::string> unparsedArguments;
  Result result;
  ASSERT_TRUE(parserStatic.Parse(result, args, &unparsedArguments) == false);
  return verifyResult(result, unparsedArguments);
}

bool testArgumentParserTypes()
{
  ArgumentParser::Maybe<std::string> maybeString;
  maybeString = std::string();
  maybeString = "";

  ArgumentParser::MaybeEmpty<std::vector<std::string>> maybeEmptyVecStr;
  maybeEmptyVecStr = std::vector<std::string>{};

  ArgumentParser::NonEmpty<std::string> nonEmptyString;
  nonEmptyString = std::string("x");
  nonEmptyString = "x";

  ArgumentParser::NonEmpty<std::vector<std::string>> nonEmptyVecStr;
  nonEmptyVecStr = std::vector<std::string>{ "" };
  return true;
}

}

int testArgumentParser(int /*unused*/, char* /*unused*/[])
{
  if (!testArgumentParserDynamic()) {
    std::cout << "While executing testArgumentParserDynamic().\n";
    return -1;
  }

  if (!testArgumentParserStatic()) {
    std::cout << "While executing testArgumentParserStatic().\n";
    return -1;
  }

  if (!testArgumentParserDerivedStatic()) {
    std::cout << "While executing testArgumentParserDerivedStatic().\n";
    return -1;
  }

  if (!testArgumentParserStaticBool()) {
    std::cout << "While executing testArgumentParserStaticBool().\n";
    return -1;
  }

  if (!testArgumentParserTypes()) {
    std::cout << "While executing testArgumentParserTypes().\n";
    return -1;
  }

  return 0;
}