cufetchpm: actually build projects and add to state.toml + (almost)final version of the manifest

Toni500github · Toni500github · commit 946a1908f97e · 2025-07-24T00:11:43.000+02:00
diff --git a/cufetchpm/Makefile b/cufetchpm/Makefile
@@ -28,7 +28,7 @@ SRC 	   	 = $(wildcard src/*.cpp src/manager/*.cpp  ../src/util.cpp)
 OBJ 	   	 = $(SRC:.cpp=.o)
 LDLIBS   	+= $(BUILDDIR)/libfmt.a $(BUILDDIR)/libtiny-process-library.a
 CXXFLAGS  	?= -mtune=generic -march=native
-CXXFLAGS        += -fvisibility=hidden -I../include -I../src/libs/ -Iinclude -std=c++20 $(VARS) -DVERSION=\"$(VERSION)\"
+CXXFLAGS        += -fvisibility=hidden -I../include -I../include/libs/ -Iinclude -std=c++20 $(VARS) -DVERSION=\"$(VERSION)\"
 
 all: fmt toml tpl $(TARGET)
 
diff --git a/cufetchpm/compile_flags.txt b/cufetchpm/compile_flags.txt
@@ -1,4 +1,5 @@
 -I../include
+-I../include/libs
 -I../src/libs/
 -Iinclude
 -Wall
diff --git a/cufetchpm/include/manifest.hpp b/cufetchpm/include/manifest.hpp
@@ -6,36 +6,57 @@
 #include <string_view>
 #include <utility>
 #include <vector>
+
 #include "libcufetch/common.hh"
 #include "toml++/toml.hpp"
 
-struct manifest_t
+struct plugin_t
 {
+    // The plugin name.
     std::string name;
-    std::string license;
+
+    // The plugin description.
     std::string description;
+
+    // The plugin build directory,
+    // where we'll retrive the built plugin
     std::string output_dir;
+
+    // The plugin multiple SPDX License Identifier (MIT, GPL-2.0, ...)
+    // NOTE: it doesn't actually check if they are correct or not.
+    std::vector<std::string> licenses;
+
+    // Which plugins can be conflicting by name / modules.
+    // TODO: choose if check either name or git url.
+    std::vector<std::string> conflicts;
+
+    // The plugin authors.
     std::vector<std::string> authors;
+
+    // A list of commands to be executed for building the plugin.
+    // Kinda like a Makefile target instructions.
+    // Each command will be executed from a different shell session.
     std::vector<std::string> build_steps;
+
+    // A list of root modules that the plugin will be used for querying its modules
+    std::vector<std::string> prefixes;
 };
 
 const char* const MANIFEST_NAME = "cufetchpm.toml";
 
-class CManifest {
+class CManifest
+{
 public:
     CManifest(const std::string_view path);
-    CManifest(toml::table&& tbl) : m_tbl(tbl){}
-    CManifest(const toml::table& tbl) : m_tbl(std::move(tbl)){}
-    CManifest &operator=(CManifest &&) = default;
-    CManifest &operator=(const CManifest &) = default;
-    ~CManifest() = default;
+    CManifest(toml::table&& tbl) : m_tbl(std::move(tbl)) {}
+    CManifest(const toml::table& tbl) : m_tbl(tbl) {}
 
-    manifest_t get_plugin(const std::string_view name);
-    std::vector<manifest_t> get_all_plugins();
+    plugin_t              get_plugin(const std::string_view name);
+    std::vector<plugin_t> get_all_plugins();
 
 private:
     toml::table m_tbl;
-    bool m_is_state = true;
+    bool        m_is_state = true;
 
     template <typename T>
     T getValue(const std::string_view name, const std::string_view value) const
@@ -62,4 +83,4 @@ class CManifest {
     }
 };
 
-#endif // !_MANIFEST_HPP_;
+#endif  // !_MANIFEST_HPP_;
diff --git a/cufetchpm/include/pluginManager.hpp b/cufetchpm/include/pluginManager.hpp
@@ -11,41 +11,40 @@
 #include "toml++/toml.hpp"
 #include "util.hpp"
 
-constexpr std::array<std::string_view, 1> dependencies = {"git"}; // expand in the future, maybe
+constexpr std::array<std::string_view, 1> dependencies = { "git" };  // expand in the future, maybe
 
 #define BOLD_COLOR(x) (fmt::emphasis::bold | fmt::fg(fmt::rgb(x)))
 
 template <typename... Args>
 void success(const std::string_view fmt, Args&&... args) noexcept
 {
     fmt::print(BOLD_COLOR((fmt::color::green)), "SUCCESS:\033[0m {}\n",
-        fmt::format(fmt::runtime(fmt), std::forward<Args>(args)...));
+               fmt::format(fmt::runtime(fmt), std::forward<Args>(args)...));
 }
 
 template <typename... Args>
 void status(const std::string_view fmt, Args&&... args) noexcept
 {
     fmt::print(BOLD_COLOR((fmt::color::cadet_blue)), "status:\033[0m {} ...\n",
-        fmt::format(fmt::runtime(fmt), std::forward<Args>(args)...));
+               fmt::format(fmt::runtime(fmt), std::forward<Args>(args)...));
 }
 
 #undef BOLD_COLOR
 
 class PluginManager
 {
 public:
-    PluginManager(const StateManager& state) : m_state(state){}
-    PluginManager(StateManager&& state)      : m_state(std::move(state)){}
+    PluginManager(const StateManager& state) : m_state(state) {}
+    PluginManager(StateManager&& state) : m_state(std::move(state)) {}
 
     void add_repo_plugins(const std::string& repo);
     bool add_plugin(const std::string&);
     bool has_deps();
 
 private:
-    const StateManager& m_state;
-    const std::filesystem::path m_cache_path{getHomeCacheDir()/"cufetchpm"/"plugins"};
-    toml::table m_manifest;
+    StateManager                m_state;
+    const std::filesystem::path m_cache_path{ getHomeCacheDir() / "cufetchpm" / "plugins" };
+    toml::table                 m_manifest;
 };
 
-
 #endif
diff --git a/cufetchpm/include/stateManager.hpp b/cufetchpm/include/stateManager.hpp
@@ -3,6 +3,7 @@
 
 #include <filesystem>
 
+#include "manifest.hpp"
 #include "toml++/toml.hpp"
 #include "util.hpp"
 
@@ -14,10 +15,11 @@ class StateManager
     StateManager(const StateManager&) = default;
     ~StateManager()                   = default;
 
+    void        add_new_plugin(const plugin_t& manifest);
     toml::table get_state() { return m_state; }
 
 private:
-    const std::filesystem::path m_path{getHomeCacheDir()/"cufetchpm"/"state.toml"};
+    const std::filesystem::path m_path{ getHomeCacheDir() / "cufetchpm" / "state.toml" };
     toml::table                 m_state;
 };
 
diff --git a/cufetchpm/src/main.cpp b/cufetchpm/src/main.cpp
@@ -1,11 +1,11 @@
-#include "stateManager.hpp"
 #include "pluginManager.hpp"
+#include "stateManager.hpp"
 
-int main (int argc, char *argv[])
+int main(int argc, char* argv[])
 {
-    std::filesystem::create_directories({getHomeCacheDir()/"cufetchpm"/"plugins"});
-    StateManager state;
-    PluginManager man(state);
+    std::filesystem::create_directories({ getHomeCacheDir() / "cufetchpm" / "plugins" });
+    StateManager  state;
+    PluginManager man(std::move(state));
     man.add_repo_plugins(argv[2]);
     return 0;
 }
diff --git a/cufetchpm/src/manifest.cpp b/cufetchpm/src/manifest.cpp
@@ -1,13 +1,16 @@
 #include "manifest.hpp"
+
 #include <algorithm>
 #include <cctype>
 #include <vector>
 
 #include "libcufetch/common.hh"
 #include "util.hpp"
 
-static bool validManifestName(const std::string_view n) {
-    return std::ranges::all_of(n, [](const unsigned char c) { return (isalnum(c) || c == '-' || c == '_' || c == '='); });
+static bool validManifestName(const std::string_view n)
+{
+    return std::ranges::all_of(n,
+                               [](const unsigned char c) { return (isalnum(c) || c == '-' || c == '_' || c == '='); });
 }
 
 CManifest::CManifest(const std::string_view path) : m_is_state(false)
@@ -21,48 +24,48 @@ CManifest::CManifest(const std::string_view path) : m_is_state(false)
         die(_("Failed to parse state file at '{}':\n"
               "{}\n"
               "\t(error occurred at line {} column {})"),
-            path, err.description(),
-            err.source().begin.line, err.source().begin.column);
+            path, err.description(), err.source().begin.line, err.source().begin.column);
     }
 }
 
-std::vector<manifest_t> CManifest::get_all_plugins()
+std::vector<plugin_t> CManifest::get_all_plugins()
 {
-    std::vector<manifest_t> plugins;
+    std::vector<plugin_t> plugins;
     for (auto const& [name, _] : m_tbl)
     {
         if (name.str() == "repository")
             continue;
 
         if (!validManifestName(name.str()))
         {
-            warn("Plugin '{}' has an invalid name. Only alphanumeric and '-', '_', '=' are allowed in the name", name.str());
+            warn("Plugin '{}' has an invalid name. Only alphanumeric and '-', '_', '=' are allowed in the name",
+                 name.str());
             continue;
         }
 
-        plugins.push_back({
-            name.data(),
-            getValue<std::string>(name, "license"),
-            getValue<std::string>(name, "description"),
-            getValue<std::string>(name, "output-dir"),
-            getValueArrayStr(name, "authors"),
-            getValueArrayStr(name, "build-steps"),
-        });
+        plugins.push_back({ .name        = name.data(),
+                            .description = getValue<std::string>(name, "description"),
+                            .output_dir  = getValue<std::string>(name, "license"),
+                            .licenses    = getValueArrayStr(name, "licenses"),
+                            .conflicts   = getValueArrayStr(name, "conflicts"),
+                            .authors     = getValueArrayStr(name, "authors"),
+                            .build_steps = getValueArrayStr(name, "build-steps"),
+                            .prefixes    = getValueArrayStr(name, "prefixes") });
     }
     return plugins;
 }
 
-manifest_t CManifest::get_plugin(const std::string_view name)
+plugin_t CManifest::get_plugin(const std::string_view name)
 {
     if (!m_tbl[name].is_table())
         die("Couldn't find such plugin '{}' in manifest", name);
 
-    return {
-        name.data(),
-        getValue<std::string>(name, "license"),
-        getValue<std::string>(name, "description"),
-        getValue<std::string>(name, "output-dir"),
-        getValueArrayStr(name, "authors"),
-        getValueArrayStr(name, "build-steps"),
-    };
+    return { .name        = name.data(),
+             .description = getValue<std::string>(name, "description"),
+             .output_dir  = getValue<std::string>(name, "license"),
+             .licenses    = getValueArrayStr(name, "licenses"),
+             .conflicts   = getValueArrayStr(name, "conflicts"),
+             .authors     = getValueArrayStr(name, "authors"),
+             .build_steps = getValueArrayStr(name, "build-steps"),
+             .prefixes    = getValueArrayStr(name, "prefixes") };
 }
diff --git a/cufetchpm/src/pluginManager.cpp b/cufetchpm/src/pluginManager.cpp
@@ -1,4 +1,5 @@
 #include "pluginManager.hpp"
+
 #include <cstdio>
 #include <cstdlib>
 #include <filesystem>
@@ -7,25 +8,21 @@
 #include <string_view>
 #include <vector>
 
-#include "tiny-process-library/process.hpp"
 #include "fmt/format.h"
-#include "manifest.hpp"
 #include "libcufetch/common.hh"
-//#include "fmt/ranges.h"
+#include "manifest.hpp"
+#include "tiny-process-library/process.hpp"
+// #include "fmt/ranges.h"
 
 using namespace TinyProcessLib;
 
-std::random_device rd;
-std::mt19937 gen(rd());
-std::uniform_int_distribution<> dist(0, 999999);
-
 bool PluginManager::has_deps()
 {
     for (const std::string_view bin : dependencies)
     {
         Process proc(fmt::format("command -v {}", bin),
                      "",
-                    [](const char*, size_t) {}, // discard stdout
+                    [](const char*, size_t) {},   // discard stdout
                     [](const char*, size_t) {});  // discard stderr
         if (proc.get_exit_status() != 0)
             return false;
@@ -37,7 +34,7 @@ bool PluginManager::has_deps()
 void PluginManager::add_repo_plugins(const std::string& repo)
 {
     if (!has_deps())
-        die("Not all dependencies have been installed. You'll need to install git"); // fmt::join(dependencies, ", "));
+        die("Not all dependencies have been installed. You'll need to install git");  // fmt::join(dependencies, ", "));
 
     std::string repo_name;
     {
@@ -55,11 +52,15 @@ void PluginManager::add_repo_plugins(const std::string& repo)
         return;
     }
 
+    static std::random_device              rd;
+    static std::mt19937                    gen(rd());
+    static std::uniform_int_distribution<> dist(100000, 999999);
+
     const std::filesystem::path& working_dir = m_cache_path / ("plugin_" + std::to_string(dist(gen)));
     std::filesystem::create_directories(working_dir);
 
     status("Cloning repository '{}' at '{}'", repo, working_dir.string());
-    if (Process({"git", "clone", "--recursive", repo, working_dir.string()}).get_exit_status() != 0)
+    if (Process({ "git", "clone", "--recursive", repo, working_dir.string() }).get_exit_status() != 0)
     {
         std::filesystem::remove_all(working_dir);
         die("Failed to clone at directory '{}'", working_dir.string());
@@ -70,26 +71,31 @@ void PluginManager::add_repo_plugins(const std::string& repo)
     CManifest manifest(MANIFEST_NAME);
 
     status("Querying all plugins declared from the manifest");
-    const std::vector<manifest_t>& plugins = manifest.get_all_plugins();
+    const std::vector<plugin_t>& plugins = manifest.get_all_plugins();
     if (plugins.empty())
     {
         std::filesystem::remove_all(working_dir);
         die("Looks like there are no plugins to build with '{}'", repo_name);
     }
     success("Queried the plugins");
 
-    for (const manifest_t& plugin : plugins)
+    for (const plugin_t& plugin : plugins)
     {
         status("Trying to build plugin '{}'", plugin.name);
         for (const std::string& bs : plugin.build_steps)
         {
-            Process process(bs, "", nullptr);
-            if (process.get_exit_status() != 0)
-            {   
+            if (Process(bs, "").get_exit_status() != 0)
+            {
                 std::filesystem::remove_all(working_dir);
                 die("Failed to build plugin '{}' from '{}'", plugin.name, repo);
             }
         }
-        success("Successfully built '{}'", plugin.name);
+        success("Successfully built '{}' into '{}'", plugin.name, plugin.output_dir);
+        m_state.add_new_plugin(plugin);
     }
+
+    const std::filesystem::path& new_plugin_path = (m_cache_path / repo_name);
+    success("Plugins Successfully built! Moving it to '{}'...", new_plugin_path.string());
+    std::filesystem::create_directories(new_plugin_path);
+    std::filesystem::rename(working_dir, new_plugin_path);
 }
diff --git a/cufetchpm/src/stateManager.cpp b/cufetchpm/src/stateManager.cpp

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`-I../include`
	`2`	`+-I../include/libs`
`2`	`3`	`-I../src/libs/`
`3`	`4`	`-Iinclude`
`4`	`5`	`-Wall`