env.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <ranges>
#include <filesystem>
#include <format>
 
#include "../std/expected.hpp"
#include "../lib/env.hpp"
#include "../reserved/env.hpp"
#include "db.hpp"

namespace ns_db::ns_env
{
 
namespace
{
 
namespace fs = std::filesystem;

[[nodiscard]] inline std::unordered_map<std::string,std::string> map(std::vector<std::string> const& entries)
{
  return entries
    | std::views::filter([](auto&& e){ return e.find('=') != std::string::npos; })
    | std::views::transform([](auto&& e)
      {
        auto it = e.find('=');
        return std::make_pair(e.substr(0, it), e.substr(it+1, std::string::npos));
      })
    | std::ranges::to<std::unordered_map<std::string,std::string>>();
}

[[nodiscard]] inline Value<void> validate(std::vector<std::string> const& entries)
{
  for (auto&& entry : entries)
  {
    if (std::ranges::count_if(entry, [](char c){ return c == '='; }) == 0)
    {
      return Error("C::Variable assignment '{}' is invalid", entry);
    }
  }
  return {};
}
 
} // namespace

[[nodiscard]] inline Value<void> del(fs::path const& path_file_binary, std::vector<std::string> const& entries)
{
  ns_db::Db db = ns_db::from_string(Pop(ns_reserved::ns_env::read(path_file_binary))).value_or(ns_db::Db());
  std::ranges::for_each(entries, [&](auto const& entry)
  {
    if( db.erase(entry) )
    {
      logger("I::Erase key '{}'", entry);
    }
    else
    {
      logger("I::Key '{}' not found for deletion", entry);
    }
  });
  Pop(ns_reserved::ns_env::write(path_file_binary, Pop(db.dump())));
  return {};
}

[[nodiscard]] inline Value<void> add(fs::path const& path_file_binary, std::vector<std::string> const& entries)
{
  // Validate entries
  Pop(validate(entries));
  // Insert environment variables in the database
  ns_db::Db db = ns_db::from_string(Pop(ns_reserved::ns_env::read(path_file_binary))).value_or(ns_db::Db());
  for (auto&& [key,value] : map(entries))
  {
    db(key) = value;
    logger("I::Included variable '{}' with value '{}'", key, value);
  }
  // Write to the database
  Pop(ns_reserved::ns_env::write(path_file_binary, Pop(db.dump())));
  return {};
}

[[nodiscard]] inline Value<void> set(fs::path const& path_file_binary, std::vector<std::string> const& entries)
{
  Pop(ns_reserved::ns_env::write(path_file_binary, Pop(ns_db::Db().dump())));
  Pop(add(path_file_binary, entries));
  return {};
}

[[nodiscard]] inline Value<std::vector<std::string>> get(fs::path const& path_file_binary)
{
  // Get environment
  ns_db::Db db = ns_db::from_string(Pop(ns_reserved::ns_env::read(path_file_binary))).value_or(ns_db::Db());
  // Merge variables with values
  std::vector<std::string> environment;
  for (auto&& [key,value] : db.items())
  {
    environment.push_back(std::format("{}={}", key, Pop(value.template value<std::string>())));
  }
  // Expand variables
  for(auto& variable : environment)
  {
    variable = ::ns_env::expand(variable).value_or(variable);
  }
  return environment;
}
 
} // namespace ns_db::ns_env
 
 
/* vim: set expandtab fdm=marker ts=2 sw=2 tw=100 et :*/