Rewrote format.

- Using a vector of elements instead of passing through va_args.
- Add more localization strings.

Author: ZCG-coder

include/fn/basicArithm.hpp

@@ -164,7 +164,7 @@ namespace steppable::__internals::arithmetic
      * @param[in] steps The number of steps to perform the power operation.
      * @return The result of the power operation as a string.
      */
-    std::string power(std::string _number, const std::string& raiseTo, int steps = 2);
+    std::string power(const std::string& _number, const std::string& raiseTo, int steps = 2);
 
     /**
      * @brief Subtracts one string representation of a number from another string representation of a number.
@@ -187,7 +187,7 @@ namespace steppable::__internals::arithmetic
      *
      * @return The result of the root operation.
      */
-    std::string root(const std::string& _number, const std::string& base, size_t decimals = 8);
+    std::string root(const std::string& _number, const std::string& base, size_t decimals = 8, int steps = 0);
 
     /**
      * @brief Converts a root operation into a surd.
@@ -556,7 +556,7 @@ namespace steppable::__internals::arithmetic
             catch (std::exception& e)
             {
                 output::error("loop", "Exception occurred in predicate."s);
-                output::error("loop", "Exception message: %s"s, e.what());
+                output::error("loop", "Exception message: {0}"s, { e.what() });
             }
             current = add(current, "1", 0);
             result = compare(current, times, 0);

include/format.hpp

@@ -39,7 +39,6 @@
 
 #pragma once
 
-#include <cstdarg>
 #include <string>
 #include <vector>
 
@@ -49,72 +48,5 @@
  */
 namespace steppable::__internals::format
 {
-    // https://stackoverflow.com/a/49812356/14868780
-    /**
-     * @brief Formats a string using a variable number of arguments.
-     *
-     * This function takes a format string and a variable number of arguments,
-     * and returns a formatted string. It uses the same format specifiers as
-     * the standard library's `printf` function.
-     *
-     * @tparam CharT The character type of the string.
-     * @param[in] sFormat The format string.
-     * @param[in] ... The variable arguments.
-     * @return The formatted string.
-     */
-    template<typename CharT>
-    std::basic_string<CharT> vFormat(const std::basic_string<CharT> sFormat, ...)
-    {
-        const CharT* const zcFormat = sFormat.c_str();
-
-        // Initialize a variable argument array
-        va_list vaArgs; // NOLINT(cppcoreguidelines-init-variables)
-        va_start(vaArgs, sFormat);
-
-        // Reliably acquire the size from a copy of the variable argument array
-        // and a functionally reliable call to mock the formatting
-        va_list vaCopy; // NOLINT(cppcoreguidelines-init-variables)
-        va_copy(vaCopy, vaArgs);
-        const int iLen = std::vsnprintf(nullptr, 0, zcFormat, vaCopy);
-        va_end(vaCopy);
-
-        // Return a formatted string without risking memory mismanagement
-        // and without assuming any compiler or platform specific behavior
-        std::vector<CharT> formatted(iLen + 1);
-        (void)std::vsnprintf(formatted.data(), formatted.size(), zcFormat, vaArgs);
-        va_end(vaArgs);
-        return std::string(formatted.data(), formatted.size());
-    }
-
-    /**
-     * @brief Formats a string using a format specifier and variable arguments.
-     *
-     * This function takes a format specifier and variable arguments, similar to the printf function,
-     * and returns a formatted string. The format specifier is a string that may contain placeholders
-     * for the variable arguments. The function uses the vsnprintf function to perform the formatting.
-     *
-     * @tparam CharT The character type of the string.
-     * @param[in] sFormat The format specifier string.
-     * @param[in] ... The variable arguments.
-     * @return The formatted string.
-     */
-    template<typename CharT>
-    std::basic_string<CharT> vFormat(const CharT* sFormat, ...)
-    {
-        const CharT* const zcFormat = sFormat;
-
-        va_list vaArgs; // NOLINT(cppcoreguidelines-init-variables)
-        va_start(vaArgs, sFormat);
-
-        va_list vaCopy; // NOLINT(cppcoreguidelines-init-variables)
-        va_copy(vaCopy, vaArgs);
-        const int iLen = std::vsnprintf(nullptr, 0, zcFormat, vaCopy); // NOLINT(clang-diagnostic-format-nonliteral)
-        va_end(vaCopy);
-
-        std::vector<CharT> formatted(iLen + 1);
-        static_cast<void>(std::vsnprintf(
-            formatted.data(), formatted.size(), zcFormat, vaArgs)); // NOLINT(clang-diagnostic-format-nonliteral)
-        va_end(vaArgs);
-        return std::string(formatted.data(), formatted.size());
-    }
+    std::string format(const std::string& format, const std::vector<std::string>& args);
 } // namespace steppable::__internals::format

include/getString.hpp

@@ -35,5 +35,5 @@ namespace steppable::localization
      *
      * @return The string in its localized form.
      */
-    std::string getString(const std::string& origin, const std::string& key);
+    std::string $(const std::string& origin, const std::string& key);
 } // namespace steppable::localization

include/output.hpp

@@ -72,48 +72,22 @@ namespace steppable::output
      * It is intended to tell the user that something is going wrong and cannot be handled.
      *
      * @tparam T The character type of the message.
-     * @tparam Args The types of the additional arguments.
      * @param[in] name The name of the error.
      * @param[in] msg The error message.
      * @param[in] args Additional arguments for formatting the message.
      */
-    template<typename T, typename... Args>
-    void error(const std::string& name, std::basic_string<T> msg, Args... args)
+    template<typename T>
+    void error(const std::string& name, std::basic_string<T> msg, const std::vector<std::string>& args = {})
     {
-        auto formattedMsg = format::vFormat(std::string(msg), args...);
-        std::cerr << colors::red << formats::bold << LARGE_DOT << " Error: " << reset << colors::red;
+        auto formattedMsg = format::format(msg, args);
+        std::cerr << colors::red << formats::bold << LARGE_DOT << name << " - ERROR: " << reset << colors::red;
         std::cerr << formattedMsg << reset << '\n';
 
         // Write to the log file
         auto logger = logging::Logger(name, "steppable.log");
         logger.error(formattedMsg);
     }
 
-    /**
-     * @brief Prints an error message.
-     *
-     * This function prints an error message with the given name and message.
-     * Additional arguments can be provided to format the message using the
-     * `std::basic_string<T>` format syntax.
-     *
-     * The message is printed in red color, and is also written to the log file.
-     * It is intended to tell the user that something is going wrong and cannot be handled.
-     *
-     * @tparam CharT The character type of the message.
-     * @param[in] name The name of the error.
-     * @param[in] msg The error message.
-     */
-    template<typename CharT>
-    void error(const std::string& name, std::basic_string<CharT> msg)
-    {
-        std::cerr << colors::red << formats::bold << LARGE_DOT << " Error: " << reset << colors::red;
-        std::cerr << msg << reset << '\n';
-
-        // Write to the log file
-        auto logger = logging::Logger(name, "steppable.log");
-        logger.error(msg);
-    }
-
     /**
      * @brief Prints a warning message.
      *
@@ -125,15 +99,16 @@ namespace steppable::output
      * It is intended to tell the user that something is going wrong but can be handled.
      *
      * @tparam T The character type of the message.
-     * @tparam Args The types of the additional arguments.
      * @param[in] msg The error message.
      * @param[in] args Additional arguments for formatting the message.
      */
-    template<typename T, typename... Args>
-    [[maybe_unused]] void warning(T msg, Args... args)
+    template<typename T>
+    [[maybe_unused]] void warning(const std::basic_string<T>& name,
+                                  const std::basic_string<T>& msg,
+                                  const std::vector<std::string>& args = {})
     {
-        std::cout << colors::yellow << formats::bold << LARGE_DOT << " Warning: " << reset << colors::yellow;
-        std::cout << format::vFormat(msg, args...) << reset << '\n';
+        std::cout << colors::yellow << formats::bold << LARGE_DOT << name << " - WARNING: " << reset << colors::yellow;
+        std::cout << format::format(msg, args) << reset << '\n';
     }
 
     /**
@@ -147,14 +122,16 @@ namespace steppable::output
      * It is intended to tell the user that something is going right, or to provide some information.
      *
      * @tparam T The character type of the message.
-     * @tparam Args The types of the additional arguments.
      * @param[in] msg The info message.
      * @param[in] args Additional arguments for formatting the message.
      */
-    template<typename T, typename... Args>
-    void info(T msg, Args... args)
+    template<typename T>
+    void info(const std::basic_string<T>& name,
+              const std::basic_string<T>& msg,
+              const std::vector<std::string>& args = {})
     {
-        std::cout << colors::brightGreen << formats::bold << LARGE_DOT << " Info: " << reset << colors::brightGreen;
-        std::cout << format::vFormat(msg, args...) << reset << '\n';
+        std::cout << colors::brightGreen << formats::bold << LARGE_DOT << name << " INFO: " << reset
+                  << colors::brightGreen;
+        std::cout << format::format(msg, args) << reset << '\n';
     }
 } // namespace steppable::output

include/testing.hpp

@@ -73,14 +73,14 @@ using namespace std::literals;
 
 /// @brief This macro ends the main function and prints the number of errors encountered.
 // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define TEST_END()                                                                          \
-    if (errors)                                                                             \
-        error("TEST_END", "Not all tests passed. There are %i errors."s, errors);           \
-    else                                                                                    \
-        info("All tests passed.");                                                          \
-    std::cout << colors::brightBlue << std::setw(80) << std::setfill('=') << reset << '\n'; \
-    if (errors)                                                                             \
-        return 1;                                                                           \
+#define TEST_END()                                                                                      \
+    if (errors)                                                                                         \
+        error("TEST_END"s, "Not all tests passed. There are {0} errors."s, { std::to_string(errors) }); \
+    else                                                                                                \
+        info("TEST_END"s, "All tests passed."s);                                                        \
+    std::cout << colors::brightBlue << std::setw(80) << std::setfill('=') << reset << '\n';             \
+    if (errors)                                                                                         \
+        return 1;                                                                                       \
     }
 
 /**

include/util.hpp

@@ -87,7 +87,6 @@ namespace steppable::__internals::utils
     #include <io.h>
 #endif
 
-    void initLocale();
 #ifdef WINDOWS
     #include <fcntl.h>
     #include <windows.h>
@@ -182,7 +181,7 @@ namespace steppable::__internals::utils
     class Utf8CodePage
     {
     public:
-        Utf8CodePage() { initLocale(); }
+        Utf8CodePage() { ; }
     };
 #endif
 } // namespace steppable::__internals::utils

lib/paths.py

@@ -25,6 +25,7 @@
 """
 
 from pathlib import Path
+from lib.constants import WINDOWS
 
 # section Project paths
 PROJECT = "Steppable"
@@ -39,3 +40,13 @@
 BIN_DIR = BUILD_DIR / "bin"
 LIB_DIR = BUILD_DIR / "lib"
 # endsection
+
+# section Configuration paths
+if not WINDOWS:
+    CONFIG_DIR = Path().home() / ".config" / "steppable"
+else:
+    CONFIG_DIR = Path().home() / "AppData" / "Roaming" / "steppable"
+
+DEFAULT_CONFIG_DIR = PROJECT_PATH / "res"
+
+# endsection

pyproject.toml

@@ -16,7 +16,8 @@ dependencies = [
     "black >= 24.4.2",
     "isort >= 5.13.2",
     "setuptools >= 61.0",
-    "nanobind >= 1.9.2"
+    "nanobind >= 1.9.2",
+    "pyyaml >= 6.0.1",
 ]
 
 [build-system]