Github actions

.github/workflows/meson-test.yml

@@ -0,0 +1,41 @@
+name: Meson Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    name: Meson tests (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install Meson and Ninja
+        run: |
+          python -m pip install --upgrade pip                              
+          pip install meson ninja                                          
+
+      - name: Setup build directory                                    
+        run: meson setup build                                             
+
+      - name: Build                                                        
+        run: meson compile -C build                                        
+
+      - name: Run tests                                                    
+        run: meson test -C build --print-errorlogs 
+
+      - name: Print test logs                                                    
+        run: cat build/meson-logs/testlog.txt || echo "No meson logs found"

include/Arg.hpp

@@ -1,55 +1,146 @@
 #pragma once
+
+#include "utils.hpp"
+
+#include <cerrno>
 #include <ostream>
 #include <iostream>
-#include <complex>
-#include <functional>
 #include <optional>
 #include <string>
 
-class ClapParser;
-
 class Arg {
   public:
-    explicit Arg(std::string name);
+    Arg(const std::string& name);
 
-    Arg& short_name(const std::string& s);
-    Arg& long_name(const std::string& l);
+    Arg& short_name(const std::string& short_name);
+    Arg& long_name(const std::string& long_name);
     Arg& help(const std::string& help);
     Arg& required(bool is_required);
-    Arg& takes_value(bool takes);
+    Arg& is_flag();
     Arg& default_value(const std::string& default_val);
     Arg& from_env(const char* env_var_name);
-    Arg& try_env();
-    void set_try_env_name(const std::string& s);
-
-    // Getters
-    [[nodiscard]] const std::string& short_name() const;
-    [[nodiscard]] const std::string& long_name() const;
-    [[nodiscard]] const std::string& help() const;
-    [[nodiscard]] const std::string& default_value() const;
-    [[nodiscard]] bool is_required() const;
-    [[nodiscard]] bool requires_value() const;
+    Arg& auto_env();
 
+    static void print_arg(std::ostream& os, const Arg& arg, int indent);
     friend std::ostream& operator<<(std::ostream& os, const Arg& arg);
 
   private:
     friend class ClapParser;
 
     std::string name_;
-    std::string short_;
-    std::string long_;
+    std::string short_name_;
+    std::string long_name_;
     std::string help_;
-    bool required_;
-    bool takes_value_;
-    bool has_env_;
+    bool is_required_;
+    bool is_flag_;
     std::string env_name_;
-    bool try_env_;
-    std::string try_env_name_;
-    std::string default_;
+    bool auto_env_;
+    // std::string auto_env_name_;
+    std::string default_value_;
     std::optional<std::string> value_;
 
-    [[nodiscard]] bool has_default() const;
-    [[nodiscard]] bool has_env() const;
-    [[nodiscard]] bool takes_value() const;
-    [[nodiscard]] const std::string& name() const;
+    // ----| Getters & Setters |----
+    // name_
+    [[nodiscard]] inline const std::string& get__name() const {
+      return this->name_;
+    }
+    inline void set__name(const std::string& name) {
+      this->name_ = name;
+    }
+
+    // short_
+    [[nodiscard]] inline const std::string& get__short_name() const {
+      return this->short_name_;
+    }
+    inline void set__short_name(const std::string& short_name) {
+      this->short_name_ = short_name;
+    }
+
+    // long_
+    [[nodiscard]] inline const std::string& get__long_name() const {
+      return this->long_name_;
+    }
+    inline void set__long_name(const std::string& long_name) {
+      this->long_name_ = long_name;
+    }
+
+    // help_
+    [[nodiscard]] inline const std::string& get__help() const {
+      return this->help_;
+    }
+    inline void set__help(const std::string& help) {
+      this->help_ = help;
+    }
+
+    // required_
+    [[nodiscard]] inline bool get__is_required() const {
+      return this->is_required_;
+    }
+    inline void set__is_required(const bool& is_required) {
+      this->is_required_ = is_required;
+    }
+
+    // takes_value_
+    [[nodiscard]] inline bool get__is_flag() const {
+      return this->is_flag_;
+    }
+    inline void set__is_flag(const bool& takes_value) {
+      this->is_flag_ = takes_value;
+    }
+
+    // env_name_
+    [[nodiscard]] inline const std::string& get__env_name() const {
+      return this->env_name_;
+    }
+    inline void set__env_name(const std::string& env_name) {
+      this->env_name_ = env_name;
+    }
+
+    // auto_env_
+    [[nodiscard]] inline bool get__auto_env() const {
+      return this->auto_env_;
+    }
+    inline void set__auto_env(const bool& auto_env) {
+      this->auto_env_ = auto_env;
+    }
+
+    // auto_env_name_
+    // [[nodiscard]] inline const std::string get__auto_env_name() const {
+    //   std::string env_name = PROGRAM_NAME() + '_' + this->get__name();
+    //   std::transform(env_name.begin(), env_name.end(), env_name.begin(), [](const unsigned char& c) { return std::toupper(c); });
+    //   return env_name;
+    // }
+
+    // default_
+    [[nodiscard]] inline const std::string& get__default_value() const {
+      return this->default_value_;
+    }
+    inline void set__default_value(const std::string& default_value) {
+      this->default_value_ = default_value;
+    }
+
+    // value_
+    [[nodiscard]] inline const std::optional<std::string> get__value() const {
+      return this->value_;
+    }
+    inline void set__value(const std::string& value) {
+      this->value_ = value;
+    }
+
+    // ----| Checkers |----
+    // has_env_
+    [[nodiscard]] inline bool has_env() const {
+      return !this->env_name_.empty();
+    }
+
+    // has_default_
+    [[nodiscard]] inline bool has_default() const {
+      return !this->default_value_.empty();
+    }
+
+    // has_value_
+    [[nodiscard]] inline bool has_value() const {
+      return this->value_.has_value();
+    }
+
 };

include/Parser.hpp

@@ -1,22 +1,32 @@
 #pragma once
+
 #include "Arg.hpp"
+#include "utils.hpp"
+
 #include <iostream>
 #include <optional>
-#include <sstream>
-#include <stdexcept>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
 class ClapParser {
   public:
     void add_arg(const Arg& arg);
-    void parse(int argc, char* argv[]);
+    void parse(const int& argc, char* argv[]);
     void print_help() const;
 
-    template <typename T> std::optional<T> get_one_as(const std::string& name) const;
-    bool has(const std::string& name) const;
+    template <typename T> inline std::optional<T> get_one_as(const std::string& name) {
+        Arg* arg = ok_or(ClapParser::find_arg(*this, "--" + name), []{ return std::nullopt; });
 
+        if (auto arg_value = arg->get__value(); arg_value) {
+            T value;
+            std::istringstream(*arg_value) >> value;
+            return value;
+        }
+        return std::nullopt;
+    }
+
+    static void print_parser(std::ostream& os, const ClapParser& parser, int indent);
     friend std::ostream& operator<<(std::ostream& os, const ClapParser& parser);
   private:
     std::vector<Arg> args_;
@@ -27,31 +37,12 @@ class ClapParser {
     inline bool is_option(const std::string& token) const ;
     inline bool is_long_option(const std::string& token) const ;
     inline bool is_short_option(const std::string& token) const ;
-    const Arg* find_option(const std::string& name) const;
+    static std::optional<Arg*> find_arg(ClapParser& parser, const std::string& name);
     std::vector<Arg> get_positional_args() const;
     void apply_defaults();
 
     void parse_options(const std::vector<std::string>& args);
-    void parse_positional_args(const std::vector<std::string>& args);
-    void check_required_args();
     void check_env();
+    void parse_positional_args(const std::vector<std::string>& args);
     void handle_missing_positional(const Arg& arg);
-
-    size_t handle_long_option(const std::string& token, const std::vector<std::string>& args, size_t i);
-    size_t handle_short_option(const std::string& token, const std::vector<std::string>& args, size_t i);
-    size_t handle_option_with_value(const Arg* arg, const std::vector<std::string>& args, size_t i,
-                                    const std::string& token);
-
 };
-
-template <typename T> std::optional<T> ClapParser::get_one_as(const std::string& name) const {
-    auto it = values_.find(name);
-    if (it == values_.end()) {
-        return std::nullopt;
-    }
-
-    T value;
-    std::istringstream(it->second) >> value;
-    return value;
-    // return std::any_cast<T>(it->second);
-}

src/utils.cpp → include/utils.hpp

@@ -1,35 +1,46 @@
+#pragma once
+
 #include <optional>
 #include <stdexcept>
 #include <string>
 #include <sstream>
 
 template <typename T, typename E>
-T ok_or(std::optional<T> opt, E&& err) {
+inline T ok_or(std::optional<T> opt, E&& err) {
     if (!opt) std::forward<E>(err)();
     return *opt;
 }
 
 template <typename T>
-T ok_or_throw_str(std::optional<T> opt, const std::string& err) {
+inline T ok_or_throw_str(std::optional<T> opt, const std::string& err) {
     if (!opt) throw std::runtime_error(err);
     return *opt;
 }
 
 template <typename T>
-T ptr_ok_or_throw_str(T pointer, const std::string& err) {
+inline T ptr_ok_or_throw_str(T pointer, const std::string& err) {
     if (!pointer) throw std::runtime_error(err);
     return pointer;
 }
 
 template <typename P, typename E>
-E ptr_unwrap_or(P pointer, const E other) { 
+inline E ptr_unwrap_or(P pointer, const E other) { 
     if (!pointer) return other;
 }
 
 // variadic template function to concatenate any number of arguments
-template <typename... Args> std::string concat(Args&&... args) {
+template <typename... Args> inline std::string concat(Args&&... args) {
     std::ostringstream oss;
     (void)std::initializer_list<int>{
         (oss << std::forward<Args>(args), 0)...}; // using initializer_list for fold-like behavior
     return oss.str();
 }
+
+inline const std::string quote(const std::string& name) {
+    return '\'' + name + '\'';
+}
+
+inline void print_indent(std::ostream& os, int indent_level) {
+    for (int i = 0; i < indent_level; ++i)
+        os << '\t';
+}