七月的技术分享

////////
#ifndef EXPAND_ENV_HPP
#define EXPAND_ENV_HPP
#include <string>
#include <string_view>
#include <absl/strings/str_format.h>
#include <absl/container/flat_hash_map.h>

namespace env {

class Derivative {
public:
  Derivative() = default;
  Derivative(const Derivative &) = delete;
  Derivative &operator=(const Derivative &) = delete;
  bool AddBashCompatible(int argc, char *const *argv);
  bool EraseEnv(std::string_view key);
  bool SetEnv(std::string_view key, std::string_view value, bool force = false);
  bool PutEnv(std::string_view nv, bool force = false);
  [[nodiscard]] std::string_view GetEnv(std::string_view key) const;
  bool ExpandEnv(std::string_view raw, std::string &w,
                 bool disableos = false) const;

private:
  bool AppendEnv(std::string_view key, std::string &w) const;
  absl::flat_hash_map<std::string, std::string> envblock;
};

namespace env_internal {
inline bool is_shell_specia_var(char ch) {
  return (ch == '*' || ch == '#' || ch == '$' || ch == '@' || ch == '!' ||
          ch == '?' || ch == '-' || (ch >= '0' && ch <= '9'));
}

inline bool is_alphanum(char ch) {
  return (ch == '_' || (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'z') ||
          (ch >= 'A' && ch <= 'Z'));
}

inline std::string_view resovle_shell_name(std::string_view s, size_t &off) {
  off = 0;
  if (s.front() == '{') {
    if (s.size() > 2 && is_shell_specia_var(s[1]) && s[2] == '}') {
      off = 3;
      return s.substr(1, 2);
    }
    for (size_t i = 1; i < s.size(); i++) {
      if (s[i] == '}') {
        if (i == 1) {
          off = 2;
          return "";
        }
        off = i + 1;
        return s.substr(1, i - 1);
      }
    }
    off = 1;
    return "";
  }
  if (is_shell_specia_var(s[0])) {
    off = 1;
    return s.substr(0, 1);
  }
  size_t i = 0;
  for (; i < s.size() && is_alphanum(s[i]); i++) {
    ;
  }
  off = i;
  return s.substr(0, i);
}

inline bool os_expand_env(const std::string &key, std::string &value) {
  auto v = ::getenv(key.data());
  if (v == nullptr) {
    return false;
  }
  value.append(v);
  return true;
}
} // namespace env_internal

inline bool Derivative::AddBashCompatible(int argc, char *const *argv) {
  // $0~$N
  for (int i = 0; i < argc; i++) {
    envblock.emplace(absl::AlphaNum(i).Piece(), argv[i]);
  }
  envblock.emplace("$",
                   absl::AlphaNum(::getpid()).Piece()); // current process PID
  return true;
}

inline bool Derivative::EraseEnv(std::string_view key) {
  return envblock.erase(key) != 0;
}

inline bool Derivative::SetEnv(std::string_view key, std::string_view value,
                               bool force) {
  if (force) {
    // envblock[key] = value;
    envblock.insert_or_assign(key, value);
    return true;
  }
  return envblock.emplace(key, value).second;
}

inline bool Derivative::PutEnv(std::string_view nv, bool force) {
  auto pos = nv.find('=');
  if (pos == std::wstring_view::npos) {
    return SetEnv(nv, "", force);
  }
  return SetEnv(nv.substr(0, pos), nv.substr(pos + 1), force);
}

[[nodiscard]] inline std::string_view
Derivative::GetEnv(std::string_view key) const {
  auto it = envblock.find(key);
  if (it == envblock.end()) {
    return "";
  }
  return it->second;
}

inline bool Derivative::AppendEnv(std::string_view key, std::string &w) const {
  auto it = envblock.find(key);
  if (it == envblock.end()) {
    return false;
  }
  w.append(it->second);
  return true;
}

// Expand Env string to normal string only support  Unix style'${KEY}'
inline bool Derivative::ExpandEnv(std::string_view raw, std::string &w,
                                  bool disableos) const {
  w.reserve(raw.size() * 2);
  size_t i = 0;
  for (size_t j = 0; j < raw.size(); j++) {
    if (raw[j] == '$' && j + 1 < raw.size()) {
      w.append(raw.substr(i, j - i));
      size_t off = 0;
      auto name = env_internal::resovle_shell_name(raw.substr(j + 1), off);
      if (name.empty()) {
        if (off == 0) {
          w.push_back(raw[j]);
        }
      } else {
        if (!AppendEnv(name, w)) {
          if (!disableos) {
            env_internal::os_expand_env(std::string(name), w);
          }
        }
      }
      j += off;
      i = j + 1;
    }
  }
  w.append(raw.substr(i));
  return true;
}

} // namespace env

#endif