cufetchpm: some WIP

Author: Toni500github

cufetchpm/Makefile

@@ -24,11 +24,11 @@ NAME		 = cufetchpm
 TARGET		?= $(NAME)
 OLDVERSION	 = 0.0.0
 VERSION    	 = 0.0.1
-SRC 	   	 = $(wildcard src/*.cpp ../src/util.cpp)
+SRC 	   	 = $(wildcard src/*.cpp src/manager/*.cpp  ../src/util.cpp)
 OBJ 	   	 = $(SRC:.cpp=.o)
 LDFLAGS   	+= -L./$(BUILDDIR)/fmt -lfmt
 CXXFLAGS  	?= -mtune=generic -march=native
-CXXFLAGS        += -fvisibility=hidden -I../include -std=c++20 $(VARS) -DVERSION=\"$(VERSION)\"
+CXXFLAGS        += -fvisibility=hidden -I../include -Iinclude -std=c++20 $(VARS) -DVERSION=\"$(VERSION)\"
 
 all: fmt toml $(TARGET)
 

cufetchpm/compile_flags.txt

@@ -1,4 +1,5 @@
 -I../include
+-Iinclude
 -Wall
 -Wextra
 -Wpedantic

cufetchpm/include/manifest.hpp

@@ -0,0 +1,58 @@
+#include <optional>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+#include "libcufetch/common.hh"
+#include "toml++/toml.hpp"
+
+struct manifest_t
+{
+    std::string name;
+    std::string license;
+    std::string description;
+    std::string output_dir;
+    std::vector<std::string> authors;
+    std::vector<std::string> build;
+};
+
+const char* const MANIFEST_NAME = "cufetchpm.toml";
+
+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;
+
+    manifest_t get_plugin(const std::string_view name);
+private:
+    toml::table m_tbl;
+    bool m_is_state = true;
+
+    template <typename T>
+    T getValue(const std::string_view name, const std::string_view value) const
+    {
+        const std::optional<T>& ret = m_tbl[name][value].value<T>();
+        return ret.value_or(UNKNOWN);
+    }
+
+    std::vector<std::string> getValueArrayStr(const std::string_view name, const std::string_view value) const
+    {
+        std::vector<std::string> ret;
+
+        // https://stackoverflow.com/a/78266628
+        if (const toml::array* array_it = m_tbl[name][value].as_array())
+        {
+            array_it->for_each([&ret](auto&& el) {
+                if (const toml::value<std::string>* str_elem = el.as_string())
+                    ret.push_back((*str_elem)->data());
+            });
+
+            return ret;
+        }
+        return {};
+    }
+};

cufetchpm/include/pluginManager.hpp

@@ -0,0 +1,28 @@
+#include <array>
+#include <filesystem>
+#include <string>
+#include <string_view>
+#include <utility>
+
+#include "stateManager.hpp"
+#include "toml++/toml.hpp"
+#include "util.hpp"
+
+constexpr std::array<std::string_view, 1> dependencies = {"git"};
+
+class PluginManager
+{
+public:
+    PluginManager(const StateManager& state) : m_state(state){}
+    PluginManager(StateManager&& state)      : m_state(std::move(state)){}
+
+    void create_cache_dir();
+    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;
+};

cufetchpm/include/stateManager.hpp

@@ -0,0 +1,19 @@
+#include <filesystem>
+
+#include "toml++/toml.hpp"
+#include "util.hpp"
+
+class StateManager
+{
+public:
+    StateManager();
+    StateManager(StateManager&&)      = default;
+    StateManager(const StateManager&) = default;
+    ~StateManager()                   = default;
+
+    toml::table get_state() { return m_state; }
+
+private:
+    const std::filesystem::path m_path{getConfigDir()/"plugins"/"state.toml"};
+    toml::table                 m_state;
+};

cufetchpm/src/add.cpp

@@ -1,24 +1,7 @@
 #include <cstring>
 #include <string_view>
 
-#include "libcufetch/common.hpp"
 #include "fmt/base.h"
+#include "libcufetch/common.hh"
 
 bool download_git(const std::string_view url);
-
-int main (int argc, char *argv[])
-{
-    if (argc > 1 && strcmp(argv[1], "add") == 0)
-    {
-        if (argc == 2)
-            die("please insert a git url to clone");
-
-        if (download_git(argv[2]))
-            info("plugin downloaded successfully");
-    }
-    else
-    {
-        fmt::println("usage: cufetchpm add <url>");
-    }
-    return 0;
-}

cufetchpm/src/main.cpp

@@ -0,0 +1,35 @@
+#include "manifest.hpp"
+
+#include "libcufetch/common.hh"
+#include "util.hpp"
+
+CManifest::CManifest(const std::string_view path) : m_is_state(false)
+{
+    try
+    {
+        this->m_tbl = toml::parse_file(path);
+    }
+    catch (const toml::parse_error& err)
+    {
+        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);
+    }
+}
+
+manifest_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"),
+    };
+}

cufetchpm/src/manifest.cpp

@@ -0,0 +1,38 @@
+#include "pluginManager.hpp"
+#include <cstdio>
+#include <filesystem>
+#include <string>
+#include <string_view>
+#include <vector>
+#include "libcufetch/common.hh"
+#include "libcufetch/fmt/ranges.h"
+#include "util.hpp"
+
+bool PluginManager::has_deps()
+{
+    for (const std::string_view bin : dependencies) // expand in the future
+    {
+        if (which(bin) == UNKNOWN)
+            return false;
+    }
+
+    return true;
+}
+
+void PluginManager::create_cache_dir()
+{
+    if (!std::filesystem::exists(m_cache_path))
+        std::filesystem::create_directories(m_cache_path);
+}
+
+void PluginManager::add_repo_plugins(const std::string& repo)
+{
+    if (!has_deps())
+        die("Not all dependencies have been installed. You'll need to install {}", fmt::join(dependencies, ", "));
+
+    const std::filesystem::path& working_dir = (m_cache_path/std::tmpnam(nullptr));
+    std::filesystem::create_directories(working_dir);
+
+    if (!taur_exec({"git", "clone", "--recursive", repo, working_dir.string()}, false))
+        die("Failed to clone at directory '{}'", working_dir.string());
+}

cufetchpm/src/pluginManager.cpp

@@ -0,0 +1,32 @@
+#include <filesystem>
+
+#include "fmt/os.h"
+#include "libcufetch/common.hh"
+#include "stateManager.hpp"
+
+StateManager::StateManager()
+{
+    if (!std::filesystem::exists(m_path))
+    {
+        auto f = fmt::output_file(m_path.string(), fmt::file::WRONLY | fmt::file::TRUNC | fmt::file::CREATE);
+        f.print(R"(
+# AUTOGENERATED FILE. DO NOT EDIT THIS FILE.
+# YOU GONNA MESS SHIT UP. unless you know what you doing ofc
+                )");
+        f.close();
+    }
+
+    try
+    {
+        if (m_state.empty())
+            m_state = toml::parse_file(m_path.string());
+    }
+    catch (const toml::parse_error& err)
+    {
+        die(_("Failed to parse state file at '{}':\n"
+              "{}\n"
+              "\t(error occurred at line {} column {})"),
+            m_path.string(), err.description(),
+            err.source().begin.line, err.source().begin.column);
+    }
+}