Refactor around verb

Author: toroidal-code

include/expectations/expectation.hpp

@@ -100,7 +100,7 @@ class Expectation : public Child {
   Result to_be_less_than(E rhs, std::string msg = "");
 
   template <typename E>
-  Matchers::BeWithin<A, E> to_be_within(E expected, std::string msg = "");
+  Matchers::BeWithinHelper<A, E> to_be_within(E expected, std::string msg = "");
 
   /*-------- to... ----------*/
 
@@ -302,8 +302,8 @@ Result Expectation<A>::to_equal(E expected, std::string msg) {
  */
 template <typename A>
 template <typename E>
-Matchers::BeWithin<A, E> Expectation<A>::to_be_within(E expected, std::string msg) {
-  Matchers::BeWithin<A, E> matcher(*this, expected);
+Matchers::BeWithinHelper<A, E> Expectation<A>::to_be_within(E expected, std::string msg) {
+  Matchers::BeWithinHelper<A, E> matcher(*this, expected);
   matcher.set_message(msg);
   return matcher;
 }

include/matchers/be_nullptr.hpp

@@ -12,6 +12,7 @@ class BeNullptr : MatcherBase<A, std::nullptr_t> {
  public:
   explicit BeNullptr(Expectation<A> &expectation) : MatcherBase<A, std::nullptr_t>(expectation) {}
 
+  std::string verb() override { return "be"; }
   std::string description() override { return "be nullptr"; }
   bool match() override { return this->actual() == nullptr; }
 };

include/matchers/contain.hpp

@@ -13,6 +13,7 @@ class ContainBase : public MatcherBase<A, E> {
   A actual_;
 
  public:
+  std::string verb() override { return "contain"; }
   std::string description() override;
   std::string failure_message() override;
   std::string failure_message_when_negated() override;
@@ -30,7 +31,7 @@ class ContainBase : public MatcherBase<A, E> {
 template <typename A, typename E, typename U>
 std::string ContainBase<A, E, U>::description() {
   // std::vector<E> described_items;
-  return Pretty::improve_hash_formatting("contain" + Pretty::to_sentence(this->expected()));
+  return Pretty::improve_hash_formatting(verb() + Pretty::to_sentence(this->expected()));
 }
 
 template <typename A, typename E, typename U>
@@ -49,7 +50,7 @@ bool ContainBase<A, E, U>::actual_collection_includes(U expected_item) {
   auto last = *(actual.begin());
   static_assert(Util::verbose_assert<std::is_same_v<decltype(last), U>>::value,
                 "Expected item is not the same type as what is inside container.");
-  return std::find(actual.begin(), actual.end(), expected_item) != actual.end();
+  return std::ranges::find(actual, expected_item) != actual.end();
 }
 
 /**

include/matchers/equal.hpp

@@ -18,7 +18,7 @@ class Equal : public MatcherBase<A, E> {
  public:
   Equal(Expectation<A> &expectation, E expected) : MatcherBase<A, E>(expectation, expected) {}
 
-  std::string description() override;
+  std::string verb() override { return "equal"; }
   std::string failure_message() override;
   std::string failure_message_when_negated() override;
   bool diffable();
@@ -31,13 +31,6 @@ class Equal : public MatcherBase<A, E> {
   // std::string detailed_failure_message();
 };
 
-template <typename A, typename E>
-std::string Equal<A, E>::description() {
-  std::stringstream ss;
-  ss << "equal" << Pretty::to_sentence<E>(this->expected());
-  return ss.str();
-}
-
 template <typename A, typename E>
 std::string Equal<A, E>::failure_message() {
   // if (expected_is_a_literal()) {

include/matchers/errors/fail.hpp

@@ -1,8 +1,5 @@
-/** @file */
 #pragma once
 
-#include <string>
-
 #include "matchers/matcher_base.hpp"
 
 namespace CppSpec::Matchers {

include/matchers/errors/have_error.hpp

@@ -3,20 +3,20 @@
 
 #include "matchers/matcher_base.hpp"
 
-
 namespace CppSpec::Matchers {
 
 template <typename T>
 concept expected = requires(T t) {
-  { t.error() } -> std::same_as<typename T::error_type&>;
+  { t.error() } -> std::same_as<typename T::error_type &>;
 };
 
 template <expected T>
 class HaveError : public MatcherBase<T, void *> {
  public:
   HaveError(Expectation<T> &expectation) : MatcherBase<T, void *>(expectation) {}
 
-  std::string description() override {return "have an error"; }
+  std::string verb() override { return "have an error"; }
+  std::string description() override { return verb(); }
 
   bool match() override { return (!this->actual().has_value()); }
 };

include/matchers/errors/have_value.hpp

@@ -1,6 +1,6 @@
 #pragma once
-#include <optional>
 
+#include "matchers/equal.hpp"
 #include "matchers/matcher_base.hpp"
 
 namespace CppSpec::Matchers {
@@ -15,16 +15,16 @@ class HaveValue : public MatcherBase<T, void *> {
  public:
   HaveValue(Expectation<T> &expectation) : MatcherBase<T, void *>(expectation) {}
 
-  std::string description() override {return "have a value"; }
+  std::string verb() override { return "have"; }
+  std::string description() override { return "have a value"; }
 
   bool match() override { return (this->actual().has_value()); }
 };
 
 template <optional T, typename E>
 class HaveValueEqualTo : public Equal<T, E> {
  public:
-  static_assert(std::is_same_v<typename T::value_type, E>,
-                "the contained value_type must match the expected type");
+  static_assert(std::is_same_v<typename T::value_type, E>, "the contained value_type must match the expected type");
   HaveValueEqualTo(Expectation<T> &expectation, E expected) : Equal<T, E>(expectation, expected) {}
 
   bool match() { return (this->actual().value() == this->expected()); }

include/matchers/errors/throw.hpp

@@ -1,9 +1,5 @@
-/** @file */
 #pragma once
 
-#include <functional>
-#include <type_traits>
-
 #include "matchers/matcher_base.hpp"
 #include "util.hpp"
 
@@ -14,6 +10,7 @@ class Throw : public MatcherBase<A, void *> {
  public:
   explicit Throw(Expectation<A> &expectation) : MatcherBase<A, void *>(expectation, nullptr) {}
   bool match() override;
+  std::string verb() override { return "throw"; }
   std::string description() override;
   std::string failure_message() override;
   std::string failure_message_when_negated() override;
@@ -32,26 +29,18 @@ bool Throw<A, Ex>::match() {
 
 template <typename A, typename Ex>
 std::string Throw<A, Ex>::description() {
-  std::stringstream ss;
-  ss << "throw " << Util::demangle(typeid(Ex).name());
-  return ss.str();
+  return std::format("throw {}", Util::demangle(typeid(Ex).name()));
 }
 
 template <typename A, typename Ex>
 std::string Throw<A, Ex>::failure_message() {
-  std::stringstream ss;
-  ss << "expected the given function ([] -> " << Util::demangle(typeid(A).name()) << " {...}) to "
-     << this->description();
-  return ss.str();
+  return std::format("expected the given function ([] -> {} {{...}}) to {}", Util::demangle(typeid(A).name()),
+                     description());
 }
 
 template <typename A, typename Ex>
 std::string Throw<A, Ex>::failure_message_when_negated() {
-  std::stringstream ss;
-  ss << "expected the given function ([] -> " << Util::demangle(typeid(A).name()) << " {...}) not to "
-     << this->description();
-  return ss.str();
+  return std::format("expected the given function ([] -> {} {{...}}) not to {}", Util::demangle(typeid(A).name()),
+                     description());
 }
-
 }  // namespace CppSpec::Matchers
-

include/matchers/matcher_base.hpp

@@ -65,6 +65,7 @@ class MatcherBase : public Runnable, public Pretty {
   virtual std::string failure_message();
   virtual std::string failure_message_when_negated();
   virtual std::string description();
+  virtual std::string verb() { return "match"; }
 
   // Get the 'actual' object from the Expectation
   constexpr Actual &actual() { return expectation_.get_target(); }
@@ -113,9 +114,7 @@ std::string MatcherBase<A, E>::failure_message() {
   if (not custom_failure_message.empty()) {
     return this->custom_failure_message;
   }
-  std::stringstream ss;
-  ss << "expected " << Pretty::to_word(actual()) << " to " << description();
-  return ss.str();
+  return std::format("expected {} to {}", Pretty::to_word(actual()), description());
 }
 
 /**
@@ -128,9 +127,7 @@ std::string MatcherBase<A, E>::failure_message_when_negated() {
   if (not custom_failure_message.empty()) {
     return this->custom_failure_message;
   }
-  std::stringstream ss;
-  ss << "expected " << Pretty::to_word(actual()) << " to not " << description();
-  return ss.str();
+  return std::format("expected {} to not {}", Pretty::to_word(actual()), description());
 }
 
 /**
@@ -140,13 +137,11 @@ std::string MatcherBase<A, E>::failure_message_when_negated() {
  */
 template <typename A, typename E>
 std::string MatcherBase<A, E>::description() {
-  std::stringstream ss;
-  //std::string pretty_expected = this->to_sentence(expected_);
-  //  ss << "match " <<
-  //  this->name_to_sentence(Util::demangle(typeid(*this).name()))
-  //     << "(" << pretty_expected.substr(1, pretty_expected.length()) << ")";
-  ss << "match" << Pretty::to_sentence(expected_);
-  return ss.str();
+  // std::string pretty_expected = this->to_sentence(expected_);
+  //   ss << "match " <<
+  //   this->name_to_sentence(Util::demangle(typeid(*this).name()))
+  //      << "(" << pretty_expected.substr(1, pretty_expected.length()) << ")";
+  return std::format("{} {}", verb(), Pretty::to_sentence(expected_));
 }
 
 /**
@@ -158,15 +153,14 @@ std::string MatcherBase<A, E>::description() {
  */
 template <typename A, typename E>
 Result MatcherBase<A, E>::run(Formatters::BaseFormatter &printer) {
-  auto *par = static_cast<ItBase *>(this->get_parent());
+  auto *parent = static_cast<ItBase *>(this->get_parent());
   // If we need a description for our test, generate it
   // unless we're ignoring the output.
-  if (par->needs_description() && !expectation_.ignore_failure()) {
+  if (parent->needs_description() && !expectation_.ignore_failure()) {
     std::stringstream ss;
     ss << (expectation_.sign() ? PositiveExpectationHandler::verb() : NegativeExpectationHandler::verb()) << " "
        << this->description();
-    std::string ss_str = ss.str();
-    par->set_description(ss_str);
+    parent->set_description(ss.str());
   }
 
   Result matched = expectation_.sign() ? PositiveExpectationHandler::handle_matcher(*this)

include/matchers/numeric/be_between.hpp

@@ -34,6 +34,7 @@ class BeBetween : public MatcherBase<A, E> {
   }
 
   bool match() override;
+  std::string verb() override { return "be between"; }
   std::string description() override;
 };
 
@@ -63,11 +64,7 @@ bool BeBetween<A, E>::match() {
 
 template <typename A, typename E>
 std::string BeBetween<A, E>::description() {
-  std::stringstream ss;
-  ss << "be between " << min << " and " << max << " (" << (mode == RangeMode::exclusive ? "exclusive" : "inclusive")
-     << ")";
-  return ss.str();
+  return std::format("be between {} and {} ({})", min, max, (mode == RangeMode::exclusive ? "exclusive" : "inclusive"));
 }
 
 }  // namespace CppSpec::Matchers
-