pretty_matchers.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <optional>
#include <regex>
#include <string>
#include <utility>
#include <vector>
 
#include "prettyprint.hpp"
#include "util.hpp"
 
// C++26 (P3168) gives std::optional begin()/end(), so cxx-prettyprint's
// has_begin_end/has_const_iterator detection now classifies optional<T> as a
// container and tries to element-print its value_type — which hard-errors for
// element types lacking operator<< (and is wrong regardless: an optional is not
// a container). Exclude it from prettyprint's container detection so optionals
// fall back to the generic (non-streamable) to_word path.
namespace pretty_print {
template <typename T>
struct is_container<std::optional<T>> : std::false_type {};
} // namespace pretty_print
 
namespace CppSpec {
 
namespace Matchers {
template <typename A, typename E>
class MatcherBase;
}

struct Pretty {
  std::string _name;
  [[nodiscard]] std::string name(const std::string& name) const;
  [[nodiscard]] std::string name_to_sentence(const std::string& name) const;
  static std::string split_words(const std::string& sym);
  static std::string underscore(const std::string& camel_cased_word);
  static std::string last(const std::string& s, char delim);
  static std::string improve_hash_formatting(const std::string& inspect_string);
 
  template <Util::is_streamable T>
  static std::string to_word(const T& item);
 
  template <typename T>
  static std::string to_word(const T& item);
 
  template <typename T>
  static std::string to_word_type(const T& item);
 
  template <typename A, typename E>
  static std::string to_word(const Matchers::MatcherBase<A, E>& matcher);
 
  template <class T>
  static std::string to_sentence(const T& item);
 
  template <class T>
  static std::string to_sentence(const std::vector<T>& words);
 
  template <typename T>
  static std::string inspect_object(const T& object);
};

template <typename T>
inline std::string Pretty::to_sentence(const std::vector<T>& objects) {
  std::vector<std::string> words;
  for (const auto& object : objects) {
    words.push_back(to_word(object));
  }
 
  std::stringstream ss;
  switch (words.size()) {
    case 0:
      return "";
    case 1:
      ss << " " << words[0];
      break;
    case 2:
      ss << " " << words[0] << " and " << words[1];
      break;
    default:
      ss << " ";
      for (size_t i = 0; i < words.size() - 1; ++i) {
        if (i != 0) {
          ss << ", ";
        }
        ss << words[i];
      }
      ss << ", and " << words.back();
      break;
  }
 
  return ss.str();
}

template <typename T>
inline std::string Pretty::to_sentence(const T& item) {
  return to_sentence(std::vector{item});
}

template <Util::is_streamable T>
inline std::string Pretty::to_word(const T& item) {
  std::ostringstream oss;
  oss << item;  // use operator<< to convert and append
  return oss.str();
}
 
template <>
inline std::string Pretty::to_word<bool>(const bool& item) {
  return item ? "true" : "false";
}
 
template <>
inline std::string Pretty::to_word<std::true_type>(const std::true_type& /* item */) {
  return "true";
}
 
template <>
inline std::string Pretty::to_word<std::false_type>(const std::false_type& /* item */) {
  return "false";
}

template <typename T>
inline std::string Pretty::to_word(const T& item) {
  std::stringstream ss;
  // Ruby-style inspect for objects without an overloaded operator<<
  ss << "#<" << Util::demangle(typeid(item).name()) << ":" << &item << ">";
  return ss.str();
}

template <typename A, typename E>
inline std::string Pretty::to_word(const Matchers::MatcherBase<A, E>& matcher) {
  std::string description = matcher.description();
  if (description.empty()) {
    return "[No description]";
  }
  return description;
}
 
template <typename T>
inline std::string Pretty::to_word_type(const T& item) {
  std::string word = to_word(item);
  if constexpr (Util::is_streamable<T>) {
    word += " : " + Util::demangle(typeid(T).name());
  }
  return word;
}
 
inline std::string Pretty::name_to_sentence(const std::string& n) const {
  return split_words(name(n));
}
 
inline std::string Pretty::name(const std::string& name) const {
  if (_name.empty()) {
    return last(name, ':');
  }
  return _name;
}
 
inline std::string Pretty::split_words(const std::string& sym) {
  return std::regex_replace(sym, std::regex("_"), " ");
}
 
inline std::string Pretty::underscore(const std::string& word) {
  std::string str = std::regex_replace(word, std::regex("([A-Z]+)([A-Z][a-z])"), "$1_$2");
  str = std::regex_replace(str, std::regex("([a-z\\d])([A-Z])"), "$1_$2");
  str = std::regex_replace(str, std::regex("-"), "_");
  std::ranges::transform(str, str.begin(), ::tolower);
  return str;
}
 
inline std::string Pretty::last(const std::string& s, const char delim) {
  std::vector<std::string> elems;
  std::stringstream ss(s);
  std::string item;
  while (getline(ss, item, delim)) {
    if (!item.empty()) {
      elems.push_back(item);
    }
  }
  return elems.back();
}
 
inline std::string Pretty::improve_hash_formatting(const std::string& inspect_string) {
  return std::regex_replace(inspect_string, std::regex("(\\S)=>(\\S)"), "$1 => $2");
}

template <typename O>
inline std::string Pretty::inspect_object(const O& o) {
  return std::format("({}) => {}", Util::demangle(typeid(o).name()), to_word(o));
}

template <>
inline std::string Pretty::inspect_object<const char*>(const char* const& o) {
  return std::format("(const char *) => \"{}\"", o);
}

template <>
inline std::string Pretty::inspect_object<std::string>(const std::string& o) {
  return std::format("(std::string) => \"{}\"", o);
}
 
template <>
inline std::string Pretty::inspect_object<std::string_view>(const std::string_view& o) {
  return std::format("(std::string_view) => \"{}\"", o);
}
 
}  // namespace CppSpec