Progress on tests and general code improvements

Author: toroidal-code

README.md

@@ -7,6 +7,8 @@
 
 A behavior-driven development testing library for C++ with an RSpec-inspired DSL.
 
+## Warning! This is pre-release software and may be incomplete, contain bugs, and/or introduce major breaking changes within a short period of time
+
 ## Installation ##
 
 C++Spec will be released as a single collated header-file that can be placed in any include path in your project. After that, all features are available via `#include "cppspec.hpp"`.

docs/syntax/describe.md

@@ -1,55 +1,63 @@
+Every test suite begins with either `describe` or `describe_a`.
 
-Every test suite begins with either `describe` or `describe_a`. 
-
-# describe #
+# describe
 
 Describes have the form of:
 
 ```c++
 describe example_spec("An example", $ { });
 ```
 
-Each `describe` is a global instance of the `Description` class, the name of the spec being
-the name of the global variable that the test is contained in.
+Each `describe` is a global instance of the `Description` class, the name of the spec being the name of the global variable that the test is contained in.
 
-__Important!__ Take note of the `$`. This is used whenever you write a `describe` or a `describe_a`.
+!!! important
 
-In conventional C++, the above snippet would be written as:
+```
+Take note of the `$`. This is used whenever you write a `describe` or a `describe_a`.
+```
+
+In conventional C++14, after macro-expansion the above snippet would be written as:
 
 ```c++
 Description example_spec("An example", [](&self auto) { });
 ```
 
-The `Description` constructor takes two arguments: a string, and a lambda. For simplicity's sake,
-any lambdas passed to any C++Spec functions are referred to as "blocks", as the capture-list 
-and arguments of the lambda are effectively never seen.
+The `Description` constructor takes two arguments: a string, and a lambda. For simplicity's sake, any lambdas passed to any C++Spec functions are referred to as "blocks", as the capture-list and arguments of the lambda are effectively never seen.
 
-# describe_a #
+# describe_a
 
-A `describe_a` is more complex than `describe`. 
+A `describe_a` is more complex than `describe`.
 
-Unlike `describe` which creates instances of `Description`, `describe_a` creates instances of 
-`ClassDescription`. `ClassDescription` is a template class, where the template's type variable 
-is used to specialize the description and create a subject available to all statements in the 
-description.
+Unlike `describe` which creates instances of `Description`, `describe_a` creates instances of `ClassDescription`. `ClassDescription` is a template class, where the template's type variable is used to specialize the description and create a subject available to all statements in the description. The subject is available via the `subject` keyword.
 
 ```c++
 template <typename T>
-class ClassDescription : public Description { };
+class ClassDescription : public Description { ... };
 ```
 
-Also unlike `describe`, there are two forms of `describe_a`: one where the subject is explicit,
-and another where it is implicit.
+Also unlike `describe`, there are two forms of `describe_a`: one where the subject is explicit, and another where it is implied.
+
+## Explicit subject describe_a
+
+An explicit describe_a has the subject passed into it as the first argument if there is no provided description, or after the description if there is one.
+
+For example:
+
+```c++
+describe_a <TestClass> tc_spec(TestClass(arg1, arg2), $ { ... });
+```
 
-The explicit form:
+and
 
 ```c++
-describe_a <TestClass> tc_spec(TestClass(arg1, arg2), $ { });
+describe_an <AnotherTestClass> atc_spec
+    ("The class AnotherTest class", AnotherTestClass(args...), $ { ... });
 ```
 
-The implicit form:
+## Implied subject describe_a
 
 ```c++
-describe_a <AnotherTestClass> atc_spec($ { });
+describe_a <YetAnotherTestClass> yatc_spec( $ { ... });
 ```
 
+With an implied subject, the default constructor of the templated class is called to create the subject.

gh-pages/index.md

@@ -3,14 +3,17 @@ layout: default
 profile: true
 ---
 
-C++Spec is a behavior-driven development library for C++ with an RSpec-inspired DSL. Designed with ease of use and rapid prototyping in mind, C++Spec offers an alternative to traditional testing libraries and frameworks. Some of the core concepts:
+C++Spec is a behavior-driven development library for C++ with an RSpec-inspired DSL. Designed with ease of use and rapid prototyping in mind, C++Spec offers an alternative to traditional testing libraries and frameworks. Some things that make C++Spec different than other testing libraries:
 
 - A clean, readable syntax
 - As few macros as possibles
 - Use as a library, not a framework
 - Easily extensible with custom matchers.
 - Support for the RSpec and Jasmine constructs you'd expect, such as describe, context, it, expect, and let.
 - Can automatically generate documentation strings based on your tests
+- Cross-platform with no need to change complex build settings.
+
+
 
 ## An example:
 
@@ -42,17 +45,17 @@ int_list_spec("A list of ints", {1,2,3}, $ {
 
 ## Usage:
 
-Download the [header file]() and put it in your project either alongside your tests or in a folder that is in your `INCLUDE` path. Then, simply `#include "cppspec.hpp"` and you're ready to go.
+Download the [header file]() and put it in your project either alongside your tests or in a folder that is in your `INCLUDE` path. Then, simply `#include "cppspec.hpp"` and you're ready to go. Both user and API documentation is available at the top of this page, and a tutorial will soon be available.
 
 ## How does it work?
 
 C++Spec utilizes templated classes and functions as well as C++14 features in order to automatically deduce the types of your objects and construct your tests.
 
 Lambdas are passed to functions (such as `context` and `it`) in order to build an execution tree at runtime. A formatter object visits each node when the tests are run and prints the status of the tests and any errors.
 
-## I'm getting really long errors. What's going on?
+## I'm getting really long compiler errors. What's going on?
 
-Due to how the library is constructed with both templates and auto-type lambdas, error messages from the compiler can be difficult to understand. Errors also tend to cascade and make the enclosing objects also fail, further obfuscating what's actually going wrong.
+Due to how the library is constructed with both templates and type-deduced (auto) lambdas, error messages from the compiler can be difficult to understand. Errors also tend to cascade and make the structures above the problem code also fail to compile, further obfuscating what's actually going wrong.
 
 Usually, the only information you want is the actual error, not all of the template substitution notes. You can reduce the template backtrace by using the flag `-ftemplate-backtrace-limit=1` when compiling with GCC and Clang.
 

include/class_description.hpp

@@ -56,8 +56,8 @@ class ClassDescription : public Description {
         type(" : " + Util::demangle(typeid(T).name())),
         subject(subject) {}
 
-  ClassDescription(std::string descr, T &subject, block_t body)
-      : Description(descr), body(body), subject(subject) {}
+//  ClassDescription(std::string descr, T &subject, block_t body)
+//      : Description(descr), body(body), subject(subject) {}
 
   template <typename U>
   ClassDescription(std::initializer_list<U> init_list, block_t body)
@@ -78,10 +78,28 @@ class ClassDescription : public Description {
 
   Result it(std::string descr, std::function<void(ItCd<T> &)> body);
   Result it(std::function<void(ItCd<T> &)> body);
-  Result context(T subject, block_t body);
-  Result context(T &subject, block_t body);
-  Result context(block_t body);
+  /** @brief an alias for it */
+  Result specify(std::string descr, std::function<void(ItCd<T> &)> body) {
+    return it(descr, body);
+  }
+  /** @brief an alias for it */
+  Result specify(std::function<void(ItCd<T> &)> body) { return it(body); }
+
+  template <class U>
+  Result context(std::string descr, U subject,
+                 std::function<void(ClassDescription<U> &)> body);
+  template <class U>
+  Result context(std::string descr, U &subject,
+                 std::function<void(ClassDescription<U> &)> body);
+  template <class U>
+  Result context(U subject, std::function<void(ClassDescription<U> &)> body);
+  template <class U>
+  Result context(U &subject, std::function<void(ClassDescription<U> &)> body);
+
+  Result context(std::string descr, std::function<void(ClassDescription<T> &)> body);
+
   Result run(Formatters::BaseFormatter &printer) override;
+
   std::string get_descr() override { return descr; }
   const std::string get_descr() const override { return descr; }
   std::string get_subject_type() override { return type; }
@@ -92,25 +110,47 @@ template <class T>
 using ClassContext = ClassDescription<T>;
 
 template <class T>
+template <class U>
 Result ClassDescription<T>::context(
-    T subject, std::function<void(ClassDescription &)> body) {
-  ClassContext<T> context(subject, body);
+    std::string descr, U subject,
+    std::function<void(ClassDescription<U> &)> body) {
+  ClassContext<U> context(descr, subject, body);
   context.set_parent(this);
-  context.before_eaches = this->before_eaches;
-  context.after_eaches = this->after_eaches;
+  context.ClassContext<U>::before_eaches = this->before_eaches;
+  context.ClassContext<U>::after_eaches = this->after_eaches;
   return context.run(this->get_formatter());
 }
 
 template <class T>
+template <class U>
+Result ClassDescription<T>::context(
+    U subject, std::function<void(ClassDescription<U> &)> body) {
+  return context("", std::forward<U>(subject), body);
+}
+
+template <class T>
+template <class U>
 Result ClassDescription<T>::context(
-    T &subject, std::function<void(ClassDescription &)> body) {
-  return context(subject, body);
+    std::string descr, U &subject,
+    std::function<void(ClassDescription<U> &)> body) {
+  ClassContext<U> context(descr, subject, body);
+  context.set_parent(this);
+  context.ClassContext<U>::before_eaches = this->before_eaches;
+  context.ClassContext<U>::after_eaches = this->after_eaches;
+  return context.run(this->get_formatter());
 }
 
 template <class T>
+template <class U>
 Result ClassDescription<T>::context(
-    std::function<void(ClassDescription &)> body) {
-  ClassContext<T> context(body);
+    U &subject, std::function<void(ClassDescription<U> &)> body) {
+  return context("", std::forward<U>(subject), body);
+}
+
+template <class T>
+Result ClassDescription<T>::context(std::string descr,
+    std::function<void(ClassDescription<T> &)> body) {
+  ClassContext<T> context(descr, this->subject, body);
   context.set_parent(this);
   context.before_eaches = this->before_eaches;
   context.after_eaches = this->after_eaches;
@@ -120,14 +160,20 @@ Result ClassDescription<T>::context(
 template <class T>
 Result Description::context(T subject,
                             std::function<void(ClassDescription<T> &)> body) {
-  ClassContext<T> context(body);
-  context.subject = subject;
+  return this->context("", subject, body);
+}
+
+template <class T>
+Result Description::context(std::string descr, T subject,
+                            std::function<void(ClassDescription<T> &)> body) {
+  ClassContext<T> context(descr, subject, body);
   context.set_parent(this);
   context.before_eaches = this->before_eaches;
   context.after_eaches = this->after_eaches;
   return context.run(this->get_formatter());
 }
 
+
 // template <class T>
 // ClassContext<T>& Description::context(
 //     T& subject, std::function<void(ClassDescription<T>&)> body) {

include/cppspec.hpp

@@ -20,6 +20,7 @@
 #define _ [=](auto &self) mutable -> void
 
 #define it self.it
+#define specify it
 #ifdef _MSC_VER  // Apparently MSVC++ doesn't conform to C++14 14.2/4. Annoying.
 #define context self.context
 #define expect self.expect

include/description.hpp

@@ -23,9 +23,6 @@ class Description : public Runnable {
 
  protected:
   std::string descr = "";
-  std::deque<rule_block_t> after_alls;
-  std::deque<rule_block_t> before_eaches;
-  std::deque<rule_block_t> after_eaches;
   std::unordered_set<LetBase *> lets;
 
   Description() {}
@@ -34,10 +31,14 @@ class Description : public Runnable {
       : Runnable(parent), body(body), descr(descr) {}
 
  public:
+
   // Constructor
   Description(std::string descr, block_t body) : body(body), descr(descr) {}
 
   const bool has_subject = false;
+  std::deque<rule_block_t> after_alls;
+  std::deque<rule_block_t> before_eaches;
+  std::deque<rule_block_t> after_eaches;
 
   // Spec functions
   Result it(std::string descr, std::function<void(ItD &)> body);
@@ -47,8 +48,8 @@ class Description : public Runnable {
   template <class T>
   Result context(T subject, std::function<void(ClassDescription<T> &)> body);
 
-  //  template <class T>
-  //  bool context(T &subject, std::function<void(ClassDescription<T> &)> body);
+  template <class T>
+  Result context(std::string descr, T subject, std::function<void(ClassDescription<T> &)> body);
 
   template <class T, typename U>
   Result context(std::initializer_list<U> init_list,

include/expectations/expectation.hpp

@@ -142,7 +142,6 @@ Expectation<A> &Expectation<A>::not_() {
  */
 template <typename A>
 Expectation<A> &Expectation<A>::ignore() {
-  // std::cout << "IGNORE: ";
   this->ignore_failure = true;
   return *this;
 }

include/matchers/equal.hpp

@@ -37,7 +37,7 @@ class Equal : public BaseMatcher<A, E> {
 template <typename A, typename E>
 std::string Equal<A, E>::description() {
   std::stringstream ss;
-  ss << "equal" << Pretty::to_sentance(this->expected);
+  ss << "equal" << Pretty::to_sentance<E>(this->expected);
   return ss.str();
 }
 
@@ -54,23 +54,20 @@ std::string Equal<A, E>::failure_message() {
 template <typename A, typename E>
 std::string Equal<A, E>::failure_message_when_negated() {
   std::stringstream ss;
-  ss << "\n"
-     << "expected not "
-     << Util::inspect_object(BaseMatcher<A, E>::get_expected()) << "\n"
+  ss << "expected not "
+     << Pretty::inspect_object(BaseMatcher<A, E>::get_expected()) << "\n"
      << "         got " << actual_inspected() << "\n"
-     << "\n"
-     << "Compared using `==`.\n\n";
+     << "Compared using `==`" << std::endl;
   return ss.str();
 }
 
 template <typename A, typename E>
 std::string Equal<A, E>::simple_failure_message() {
   std::stringstream ss;
-  ss << "\n"
-     << "expected " << Util::inspect_object(BaseMatcher<A, E>::get_expected())
+  ss << "expected " << Pretty::inspect_object(BaseMatcher<A, E>::get_expected())
      << "\n"
      << "     got " << actual_inspected() << "\n"
-     << "Compared using `==`.\n\n";
+     << "Compared using `==`" << std::endl;
   return ss.str();
 }
 
@@ -81,7 +78,6 @@ bool Equal<A, E>::diffable() {
 
 template <typename A, typename E>
 bool Equal<A, E>::match() {
-  // TODO: compare pointers too
   return this->get_expected() == this->get_actual();
 }
 
@@ -99,7 +95,7 @@ bool Equal<A, E>::expected_is_a_literal() {
 
 template <typename A, typename E>
 std::string Equal<A, E>::actual_inspected() {
-  return Util::inspect_object(BaseMatcher<A, E>::get_actual());
+  return Pretty::inspect_object(BaseMatcher<A, E>::get_actual());
 }
 
 // template <typename A, bool E>