env.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <concepts>
#include <cstdlib>
#include <wordexp.h>
#include <ranges>
 
#include "../std/expected.hpp"
#include "../std/string.hpp"
#include "../common.hpp"
#include "../macro.hpp"

namespace ns_env
{
 
namespace
{
namespace fs = std::filesystem;
}
 
enum class Replace
{
  Y,
  N,
};

template<ns_concept::StringRepresentable T, ns_concept::StringRepresentable U>
void set(T&& name, U&& value, Replace replace)
{
  setenv(ns_string::to_string(name).c_str(), ns_string::to_string(value).c_str(), (replace == Replace::Y));
}

template<ns_string::static_string S = "E">
inline Value<std::string> get_expected(std::string_view name)
{
  static constexpr ns_string::static_string suffix("::Could not read variable '{}'");
  static constexpr ns_string::static_string fmt = S.template join<suffix>();
  const char * var = std::getenv(name.data());
  return (var != nullptr)?
      Value<std::string>(std::string{var})
    : Error(fmt.data, name);
}

inline bool exists(std::string_view name, std::string_view value)
{
  const char* value_real = getenv(name.data());
  return_if(not value_real, false);
  return std::string_view{value_real} == value;
}

inline Value<std::string> expand(ns_concept::StringRepresentable auto&& var)
{
  std::string expanded = ns_string::to_string(var);
 
  // Perform word expansion
  wordexp_t data;
  if (int ret = wordexp(expanded.c_str(), &data, 0); ret == 0)
  {
    if (data.we_wordc > 0)
    {
      expanded = data.we_wordv[0];
    } // if
    wordfree(&data);
  } // if
  else
  {
    std::string error;
    switch(ret)
    {
      case WRDE_BADCHAR: error = "WRDE_BADCHAR"; break;
      case WRDE_BADVAL: error = "WRDE_BADVAL"; break;
      case WRDE_CMDSUB: error = "WRDE_CMDSUB"; break;
      case WRDE_NOSPACE: error = "WRDE_NOSPACE"; break;
      case WRDE_SYNTAX: error = "WRDE_SYNTAX"; break;
      default: error = "unknown";
    } // switch
    return Error("E::{}", error);
  } // else
 
  return expanded;
}

template<typename T = std::string>
inline Value<T> xdg_data_home() noexcept
{
  const char* var = std::getenv("XDG_DATA_HOME");
  return_if(var, var);
  const char* home = std::getenv("HOME");
  return_if(not home, Error("E::HOME is undefined"));
  return std::string{home} + "/.local/share";
}

[[nodiscard]] inline Value<fs::path> search_path(std::string const& query)
{
  std::string env_path = Pop(ns_env::get_expected("PATH"));
  // Query should be a file name
  if ( fs::path{query}.is_absolute() )
  {
    return Error("E::Query should be a file name, not an absolute path");
  }
  // Search directories in PATH
  for(fs::path directory : env_path
    | std::views::split(':')
    | std::ranges::to<std::vector<std::string>>())
  {
    fs::path path_full = directory / query;
    return_if(fs::exists(path_full), path_full);
  }
  return Error("E::File not found in PATH");
}
 
} // namespace ns_env
 
/* vim: set expandtab fdm=marker ts=2 sw=2 tw=100 et :*/