resolved comments

Author: SpectraL519

docs/dev_notes.md

@@ -19,15 +19,13 @@ This will build each test file as a separate executable in the `build/tests/` di
 
 ### Run the tests
 
-You can run tests from each test file manually with:
+You can run tests from each test file separately with:
 
 ```shell
 ./build/tests/<test-name>
 ```
 
-where `<test-name>` is the name of the test file without the extension.
-
-To run all tests at once run:
+To execute all tests at once run:
 
 ```shell
 ctest --test-dir build/tests/ # -V (to capture output from each test executable)

docs/tutorial.md

@@ -638,9 +638,11 @@ The `argument_parser` class also defines the `void parse_args(int argc, char* ar
 
 > [!WARNING]
 >
-> By default the `argument_parser` class treats all* command-line arguments beggining with a `--` or `-` prefix as optional argument flags and if the flag's value does not match any of the specified arguments, then such flag is considered *unknown* and an exception will be thrown.
+> By default the `argument_parser` class treats *all\** command-line arguments beggining with a `--` or `-` prefix as optional argument flags and if the flag's value does not match any of the specified arguments, then such flag is considered *unknown* and an exception will be thrown.
 >
-> This behaviour can be altered so that the unknown argument flags will be treated as values, not flags.
+> *\** If a command-line argument begins with a flag prefix, but contains whitespaces (e.g. `"--flag value"`), then it is treated as a value and not a flag.
+>
+> This behavior can be altered so that the unknown argument flags will be treated as values, not flags.
 >
 > Example:
 > ```cpp
@@ -796,7 +798,7 @@ int main(int argc, char* argv[]) {
 
 > [!IMPORTANT]
 >
-> The parser behaviour depends on the argument definitions. The argument parameters are described int the [Argument parameters](#argument-parameters) section.
+> The parser's behavior depends on the argument definitions - see [Argument Parameters](#argument-parameters) section.
 
 <br/>
 <br/>
@@ -808,14 +810,14 @@ You can retrieve the argument's value with:
 
 ```cpp
 (const) auto value = parser.value<value_type>("argument_name"); // (1)
-(const) auto value = parser.value_or<value_type>("argument_name", default_value); // (2)
+(const) auto value = parser.value_or<value_type>("argument_name", fallback_value); // (2)
 ```
 
 1. This will return the value parsed for the given argument.
 
     For optional arguments this will return the argument's predefined value if no value has been parsed. Additionaly, if more than one value has been parsed for an optional argument, this function will return the first parsed value.
 
-2. When a value has been parsed for the argument, the behaviour is the same as in case **(1)**. Otherwise, this will return `value_type{std::forward<U>(default_value)}` (where `U` is the deducted type of `default_value`), if:
+2. When a value has been parsed for the argument, the behavior is the same as in case **(1)**. Otherwise, this will return `value_type{std::forward<U>(fallback_value)}` (where `U` is the deducted type of `fallback_value`), if:
 
     - There is no value parsed for a positional argument
     - There is no parsed values and no predefined values for an optional arrument

include/ap/argument_parser.hpp

@@ -145,7 +145,7 @@ class argument_parser {
     argument::positional<T>& add_positional_argument(std::string_view primary_name) {
         this->_verify_arg_name_pattern(primary_name);
 
-        const detail::argument_name arg_name = {primary_name};
+        const detail::argument_name arg_name(primary_name);
         if (this->_is_arg_name_used(arg_name))
             throw invalid_configuration::argument_name_used(arg_name);
 
@@ -170,7 +170,7 @@ class argument_parser {
         this->_verify_arg_name_pattern(primary_name);
         this->_verify_arg_name_pattern(secondary_name);
 
-        const detail::argument_name arg_name = {primary_name, secondary_name};
+        const detail::argument_name arg_name(primary_name, secondary_name);
         if (this->_is_arg_name_used(arg_name))
             throw invalid_configuration::argument_name_used(arg_name);
 
@@ -373,12 +373,12 @@ class argument_parser {
      * @tparam T Type of the argument value.
      * @tparam U The default value type.
      * @param arg_name The name of the argument.
-     * @param default_value The default value.
+     * @param fallback_value The fallback value.
      * @return The value of the argument.
      * @throws ap::lookup_failure, ap::type_error
      */
     template <detail::c_argument_value_type T = std::string, std::convertible_to<T> U>
-    [[nodiscard]] T value_or(std::string_view arg_name, U&& default_value) const {
+    [[nodiscard]] T value_or(std::string_view arg_name, U&& fallback_value) const {
         const auto arg_opt = this->_get_argument(arg_name);
         if (not arg_opt)
             throw lookup_failure::argument_not_found(arg_name);
@@ -390,7 +390,7 @@ class argument_parser {
         catch (const std::logic_error&) {
             // positional: no value parsed
             // optional: no value parsed + no predefined value
-            return T{std::forward<U>(default_value)};
+            return T{std::forward<U>(fallback_value)};
         }
         catch (const std::bad_any_cast& err) {
             throw type_error::invalid_value_type(arg_opt->get().name(), typeid(T));
@@ -658,8 +658,11 @@ class argument_parser {
     [[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
+
+        if (tok.type == detail::argument_token::t_flag_secondary)
             return this->_is_arg_name_used({tok.value}, detail::argument_name::m_secondary);
+
+        return false;
     }
 
     /**

include/ap/detail/argument_token.hpp

@@ -38,8 +38,8 @@ struct argument_token {
         return this->type == t_flag_primary or this->type == t_flag_secondary;
     }
 
-    token_type type;
-    std::string value;
+    token_type type; ///< The token's type discrimiator value.
+    std::string value; ///< The actual token's value.
 };
 
 } // namespace ap::detail