got rid of outdated tests

* replaced `tl::expected` with `Err` where ever possible
* removed `.gitattributes`

Author: evanwporter

.gitattributes

@@ -8,7 +8,6 @@ git = 'https://github.com/fmtlib/fmt.git'
 muuk_path = 'deps/fmt/muuk.toml'
 revision = '577fd3be883accf8629423ed77fcca8a24bccee2'
 version = '577fd3be883accf8629423ed77fcca8a24bccee2'
-features = ['use_std2_fmt']
 
 [library]
 cflags = ["-DSPDLOG_COMPILED_LIB", "-DSPDLOG_FMT_EXTERNAL"]

deps/spdlog/3335c380a08c5e0f5117a66622df6afdb3d74959/muuk.toml

@@ -217,7 +217,9 @@ struct BaseFields {
             }
 
             std::filesystem::path full_path = std::filesystem::path(base_path) / file_path;
-            temp_sources.emplace_back(util::file_system::to_linux_path(full_path.lexically_normal().string()), extracted_cflags);
+            temp_sources.emplace_back(
+                util::file_system::to_linux_path(full_path.lexically_normal().string()),
+                extracted_cflags);
         }
 
         return temp_sources;

include/base_config.hpp

@@ -5,8 +5,6 @@
 #include <string>
 #include <vector>
 
-#include <tl/expected.hpp>
-
 #include "compiler.hpp"
 #include "rustify.hpp"
 

include/muuk.hpp

@@ -24,21 +24,21 @@ inline constexpr auto Err(const std::string& msg) {
 }
 
 inline constexpr auto Err(std::string_view msg) {
-    return tl::unexpected(std::string(msg));
+    return Err(std::string(msg));
 }
 
 inline constexpr auto Err(const char* msg) {
-    return tl::unexpected(std::string(msg));
+    return Err(std::string(msg));
 }
 
 template <typename T>
 inline constexpr auto Err(Result<T> result) {
-    return tl::unexpected(result.error());
+    return Err(result.error());
 }
 
 template <typename... Args>
 inline constexpr auto Err(fmt::format_string<Args...> fmt_str, Args&&... args) {
-    return tl::unexpected(fmt::format(fmt_str, std::forward<Args>(args)...));
+    return Err(fmt::format(fmt_str, std::forward<Args>(args)...));
 }
 
 struct PanicException : public std::exception {
@@ -55,15 +55,15 @@ struct PanicException : public std::exception {
 template <typename T>
 inline auto Try(Result<T>&& exp) -> Result<T> {
     if (!exp)
-        return tl::unexpected(exp.error());
+        return Err(exp.error());
     return std::move(*exp);
 }
 
 // Specialization for void type
 template <>
 inline auto Try<void>(Result<void>&& exp) -> Result<void> {
     if (!exp)
-        return tl::unexpected(exp.error());
+        return Err(exp.error());
     return {}; // Return an empty Result<void> (equivalent to Ok())
 }
 

include/rustify.hpp

@@ -12,62 +12,12 @@
 
 #pragma once
 
-// Detect whether we are compiling with GCC/Clang for statement expressions
-#if defined(__GNUC__) || defined(__clang__)
-#define TRY_HAS_STATEMENT_EXPR 1
-#else
-#define TRY_HAS_STATEMENT_EXPR 0
-#endif
-
 #include <tl/expected.hpp>
 
-#if TRY_HAS_STATEMENT_EXPR
-#else
-#include <type_traits>
-#include <utility>
-#endif
-
-// Basic TRY macro using statement expressions (non-portable)
-#if TRY_HAS_STATEMENT_EXPR
-#define TRY(expr)                                       \
-    ({                                                  \
-        auto _try_result = (expr);                      \
-        if (!_try_result)                               \
-            return tl::unexpected(_try_result.error()); \
-        std::move(*_try_result);                        \
-    })
-#else
-// Portable version using lambda
-#define TRY(expr)                                       \
-    ([&]() -> decltype(auto) {                          \
-        auto _try_result = (expr);                      \
-        if (!_try_result)                               \
-            return tl::unexpected(_try_result.error()); \
-        return std::move(*_try_result);                 \
-    }())
-#endif
-
 // TRYV: use when expr returns std::expected<void, E>
 #define TRYV(expr)                                      \
     do {                                                \
         auto _try_result = (expr);                      \
         if (!_try_result)                               \
             return tl::unexpected(_try_result.error()); \
     } while (0)
-
-// TRY_OR: custom error handling function/lambda
-#define TRY_OR(expr, handler)                      \
-    ([&]() -> decltype(auto) {                     \
-        auto _try_result = (expr);                 \
-        if (!_try_result)                          \
-            return (handler)(_try_result.error()); \
-        return std::move(*_try_result);            \
-    }())
-
-// TRYV_OR: custom error handler for void-returning std::expected
-#define TRYV_OR(expr, handler)                     \
-    do {                                           \
-        auto _try_result = (expr);                 \
-        if (!_try_result)                          \
-            return (handler)(_try_result.error()); \
-    } while (0)

include/try_expected.hpp

@@ -59,13 +59,6 @@ sources = ['test/internal/muuk_test.cpp']
 [build.test.dependencies]
 googletest = { git = 'https://github.com/google/googletest.git', version = '3fbe4db9a39291ae8d7a9c5f1d75896bb4c5a18f' }
 
-[build.test_util]
-profile = ['debug']
-sources = ['test/internal/test_util.cpp']
-
-[build.test_util.dependencies]
-googletest = { git = 'https://github.com/google/googletest.git', version = '3fbe4db9a39291ae8d7a9c5f1d75896bb4c5a18f' }
-
 [platform.windows]
 cflags = []
 

muuk.toml

@@ -5,8 +5,6 @@
 
 #include <fmt/core.h>
 #include <fmt/ranges.h>
-#include <glob/glob.hpp>
-#include <tl/expected.hpp>
 #include <toml.hpp>
 
 #include "buildconfig.h"
@@ -273,11 +271,9 @@ Result<void> MuukLockGenerator::load() {
     base_package_dep.version = base_package_version;
 
     // Resolve dependencies for the base package
-    auto result_base_pkg = resolve_dependencies(
+    TRYV(resolve_dependencies(
         base_package_name,
-        base_package_version);
-    if (!result_base_pkg)
-        return Err(result_base_pkg);
+        base_package_version));
 
     muuk::logger::info("Resolving dependencies for build packages...");
     for (const auto& [build_name, build] : builds_) {

src/lockgen/muuklockgen.cpp

@@ -6,7 +6,6 @@
 #include <argparse/argparse.hpp>
 #include <fmt/ostream.h>
 #include <nlohmann/json.hpp>
-#include <tl/expected.hpp>
 
 #include "buildconfig.h"
 #include "commands/add.hpp"

src/main.cpp

@@ -9,10 +9,12 @@
 #include "buildparser.hpp"
 #include "commands/build.hpp"
 #include "compiler.hpp"
+#include "error_codes.hpp"
 #include "logger.hpp"
 #include "muuk_parser.hpp"
 #include "muuklockgen.hpp"
 #include "rustify.hpp"
+#include "try_expected.hpp"
 #include "util.hpp"
 
 namespace fs = std::filesystem;
@@ -89,29 +91,34 @@ namespace muuk {
     Result<void> add_script(const std::string& profile, const std::string& build_name) {
         (void)build_name;
 
-        auto result = muuk::parse_muuk_file("muuk.toml", false);
+        auto result = muuk::parse_muuk_file(
+            "muuk.toml",
+            false,
+            false);
         if (!result)
-            return tl::unexpected("Failed to parse muuk.toml: " + result.error());
+            return Err(result.error());
 
         toml::value config = result.value();
 
-        std::string executable_name = "muuk";
 #ifdef _WIN32
-        std::string executable_path = "build/" + profile + "/" + executable_name + ".exe";
+        std::string executable_path = "build/"
+            + profile + "/" + build_name
+            + "/" + build_name + ".exe";
 #else
-        std::string executable_path = "./build/" + profile + "/" + executable_name;
+        std::string executable_path = "./build/"
+            + profile + "/" + build_name
+            + "/" + build_name + ".exe";
 #endif
 
         if (!config.contains("scripts") || !config["scripts"].is_table()) {
             config["scripts"] = toml::table {};
         }
 
-        config["scripts"].as_table()["run"] = toml::value(executable_path);
+        config["scripts"].as_table()[build_name] = toml::value(executable_path);
 
         std::ofstream out("muuk.toml");
-        if (!out) {
-            return tl::unexpected("Failed to open muuk.toml for writing.");
-        }
+        if (!out)
+            return make_error<EC::FileNotFound>("muuk.toml");
         out << toml::format(config);
 
         muuk::logger::info("Successfully added run script to 'muuk.toml': {}", executable_path);
@@ -128,15 +135,21 @@ namespace muuk {
 
     Result<void> build(std::string& target_build, const std::string& compiler, const std::string& profile, const toml::value& config) {
 
+        auto muuk_result = parse_muuk_file(
+            "muuk.toml",
+            false,
+            true);
+        if (!muuk_result)
+            return Err(muuk_result);
+
+        auto muuk_file = muuk_result.value();
+
+        // TODO: Pass the config to the lock generator
         auto lock_generator_ = MuukLockGenerator::create("./");
         if (!lock_generator_)
             return Err(lock_generator_.error());
 
-        auto lock_file_result = lock_generator_->generate_cache(MUUK_CACHE_FILE);
-        if (!lock_file_result)
-            return Err(lock_file_result.error());
-
-        spdlog::default_logger()->flush();
+        TRYV(lock_generator_->generate_cache(MUUK_CACHE_FILE));
 
         auto compiler_result = compiler.empty()
             ? detect_default_compiler()
@@ -151,24 +164,28 @@ namespace muuk {
 
         auto profile_result = select_profile(profile, config);
         if (!profile_result)
-            return tl::unexpected(profile_result.error());
-
-        std::string selected_profile = profile_result.value();
+            return Err(profile_result);
+        auto selected_profile = profile_result.value();
 
         auto build_manager = std::make_unique<BuildManager>();
 
-        auto parse_result = parse(
+        // TODO: IMPLEMENT
+        // if (muuk_file.contains("build")) {
+        //     const auto& builds = muuk_file["build"].as_table();
+        //     for (const auto& [build_name, _] : builds) {
+        //         muuk::logger::info("Adding script for build target '{}'", build_name);
+        //         TRYV(add_script(selected_profile, build_name));
+        //     }
+        // }
+
+        TRYV(parse(
             *build_manager,
             selected_compiler,
             fs::path("build") / selected_profile,
-            selected_profile);
-
-        if (!parse_result) {
-            return Err(parse_result.error());
-        }
+            selected_profile));
 
         NinjaBackend build_backend(
-            *build_manager, // ← Reuse external BuildManager
+            *build_manager,
             selected_compiler,
             selected_archiver,
             selected_linker);
@@ -179,7 +196,12 @@ namespace muuk {
         build_backend.generate_build_file(target_build, selected_profile);
 
         execute_build(selected_profile);
-        generate_compile_commands(*build_manager, selected_profile, selected_compiler, selected_archiver, selected_linker);
+        generate_compile_commands(
+            *build_manager,
+            selected_profile,
+            selected_compiler,
+            selected_archiver,
+            selected_linker);
 
         return {};
     }