flag detection improved

Author: SpectraL519

include/ap/argument_parser.hpp

@@ -497,6 +497,12 @@ class argument_parser {
                 arg_name, "An argument name cannot be empty."
             );
 
+        // TODO: add tests
+        if (detail::contains_whitespaces(arg_name))
+            throw invalid_configuration::invalid_argument_name(
+                arg_name, "An argument name cannot contain whitespaces."
+            );
+
         if (arg_name.front() == this->_flag_prefix_char)
             throw invalid_configuration::invalid_argument_name(
                 arg_name,
@@ -570,7 +576,7 @@ class argument_parser {
      * 1. No required positional argument can be added after a non-required positional argument.
      */
     void _validate_argument_configuration() const {
-        // Step: 1
+        // step 1
         const_arg_opt_t non_required_arg = std::nullopt;
         for (const auto& arg : this->_positional_args) {
             if (not arg->is_required()) {
@@ -591,47 +597,74 @@ class argument_parser {
      * @param arg_range The command-line argument value range.
      * @return A list of preprocessed command-line argument tokens.
      */
-    template <detail::c_sized_range_of<std::string, detail::type_validator::convertible> AR>
+    template <detail::c_sized_range_of<std::string_view, detail::type_validator::convertible> AR>
     [[nodiscard]] arg_token_list_t _tokenize(const AR& arg_range) const noexcept {
         const auto n_args = std::ranges::size(arg_range);
         if (n_args == 0ull)
             return arg_token_list_t{};
 
         arg_token_list_t toks;
         toks.reserve(n_args);
+        std::ranges::for_each(
+            arg_range, std::bind_front(&argument_parser::_tokenize_arg, this, std::ref(toks))
+        );
+        return toks;
+    }
 
-        for (const auto& arg : arg_range) {
-            std::string value = static_cast<std::string>(arg);
-            if (this->_is_flag(value)) {
-                const auto flag_tok = this->_strip_flag_prefix(value);
-                toks.emplace_back(flag_tok, std::move(value));
-            }
-            else {
-                toks.emplace_back(detail::argument_token::t_value, std::move(value));
-            }
+    /**
+     * @brief Appends an argument token created from `arg_value` to the `toks` vector.
+     * @param toks The argument token list to which the processed token(s) will be appended.
+     * @param arg_value The command-line argument's value to be processed.
+     */
+    void _tokenize_arg(arg_token_list_t& toks, const std::string_view arg_value) const {
+        auto tok = this->_build_token(arg_value);
+        if (tok.is_flag_token() and not this->_is_valid_flag(tok)) {
+#ifdef AP_UNKNOWN_FLAGS_AS_VALUES
+            toks.emplace_back(detail::argument_token::t_value, std::string(arg_value));
+            return;
+#else
+            throw parsing_failure::unknown_argument(arg_value);
+#endif
         }
 
-        return toks;
+        toks.emplace_back(std::move(tok));
     }
 
     /**
-     * @brief Check if an argument is a flag based on its value.
-     * @param arg The cmd argument's value.
-     * @return True if the argument is a flag, false otherwise.
+     * @brief Builds an argument token from the given value.
+     * @param arg_value The command-line argument's value to be processed.
+     * @return An argument token with removed flag prefix (if present) and an adequate token type.
      */
-    [[nodiscard]] bool _is_flag(const std::string& arg) const noexcept {
-        if (arg.starts_with(this->_flag_prefix))
-            return this->_is_arg_name_used(
-                {arg.substr(this->_primary_flag_prefix_length)}, detail::argument_name::m_primary
-            );
+    [[nodiscard]] detail::argument_token _build_token(const std::string_view arg_value
+    ) const noexcept {
+        if (detail::contains_whitespaces(arg_value))
+            return {.type = detail::argument_token::t_value, .value = std::string(arg_value)};
 
-        if (arg.starts_with(this->_flag_prefix_char))
-            return this->_is_arg_name_used(
-                {arg.substr(this->_secondary_flag_prefix_length)},
-                detail::argument_name::m_secondary
-            );
+        if (arg_value.starts_with(this->_flag_prefix))
+            return {
+                .type = detail::argument_token::t_flag_primary,
+                .value = std::string(arg_value.substr(this->_primary_flag_prefix_length))
+            };
 
-        return false;
+        if (arg_value.starts_with(this->_flag_prefix_char))
+            return {
+                .type = detail::argument_token::t_flag_secondary,
+                .value = std::string(arg_value.substr(this->_secondary_flag_prefix_length))
+            };
+
+        return {.type = detail::argument_token::t_value, .value = std::string(arg_value)};
+    }
+
+    /**
+     * @brief Check if a flag token is valid based on its value.
+     * @param tok The processed argument token.
+     * @return true if the token's value matches an argument name specified within the parser, false otherwise.
+     */
+    [[nodiscard]] bool _is_valid_flag(const detail::argument_token& tok) const noexcept {
+        if (tok.type == detail::argument_token::t_flag_primary)
+            return this->_is_arg_name_used({tok.value}, detail::argument_name::m_primary);
+        else
+            return this->_is_arg_name_used({tok.value}, detail::argument_name::m_secondary);
     }
 
     /**
@@ -658,22 +691,6 @@ class argument_parser {
         }
     }
 
-    /**
-     * @brief Remove the flag prefix from the argument.
-     * @param arg_flag The argument flag to strip the prefix from.
-     * @return A flag argument token representing whether the prefix indicated a primary or a secondary flag.
-     */
-    detail::argument_token::token_type _strip_flag_prefix(std::string& arg_flag) const noexcept {
-        if (arg_flag.starts_with(this->_flag_prefix)) {
-            arg_flag.erase(0, this->_primary_flag_prefix_length);
-            return detail::argument_token::t_flag_primary;
-        }
-        else {
-            arg_flag.erase(0, this->_secondary_flag_prefix_length);
-            return detail::argument_token::t_flag_secondary;
-        }
-    }
-
     /**
      * @brief Implementation of parsing command-line arguments.
      * @param arg_tokens The list of command-line argument tokens.

include/ap/detail/argument_token.hpp

@@ -21,23 +21,6 @@ struct argument_token {
     };
     using enum token_type;
 
-    argument_token() = delete;
-
-    argument_token(const argument_token&) = default;
-    argument_token(argument_token&&) = default;
-
-    argument_token& operator=(const argument_token&) = default;
-    argument_token& operator=(argument_token&&) = default;
-
-    /**
-     * @brief Constructor of a command-line argument.
-     * @param type Type type of the token (flag or value).
-     * @param value The value of the argument.
-     */
-    argument_token(const token_type type, const std::string& value) : type(type), value(value) {}
-
-    ~argument_token() = default;
-
     /**
      * @brief Equality operator for comparing argument_token instances.
      * @param other An argument_token instance to compare with.
@@ -47,6 +30,14 @@ struct argument_token {
         return this->type == other.type and this->value == other.value;
     }
 
+    /**
+     * @brief Checks whether the `type` member is a flag token type.
+     * @return true if `type` is either `t_flag_primary` or `t_flag_secondary`, false otherwise.
+     */
+    [[nodiscard]] bool is_flag_token() const noexcept {
+        return this->type == t_flag_primary or this->type == t_flag_secondary;
+    }
+
     token_type type;
     std::string value;
 };

include/ap/detail/str_utility.hpp

@@ -11,6 +11,7 @@
 
 #include "concepts.hpp"
 
+#include <algorithm>
 #include <sstream>
 #include <string_view>
 
@@ -28,6 +29,12 @@ template <c_writable T>
     return oss.str();
 }
 
+// TODO: add tests
+/// @brief Checks whether a string contains any whitespace characters.
+[[nodiscard]] inline bool contains_whitespaces(std::string_view str) noexcept {
+    return std::ranges::any_of(str, [](unsigned char c) { return std::isspace(c); });
+}
+
 /**
  * @brief Joins elements of a range into a single string with a delimiter.
  * @tparam R The type of the value range. The value type of R must satisfy the @ref c_writable concept.