Major refactor and cleanup of API

Author: toroidal-code

README.md

@@ -4,24 +4,46 @@
 [![Github Releases](https://img.shields.io/github/downloads/toroidal-code/cppspec/latest/total.svg)]()  
 [![Documentation Status](https://readthedocs.org/projects/cppspec/badge/?version=latest)](http://cppspec.readthedocs.org/en/latest/?badge=latest)
 
-C++Spec is a behavior-driven development library for C++ with an RSpec-inspired DSL.
+A behavior-driven development testing library for C++ with an RSpec-inspired DSL.
 
 ## Installation ##
 
-C++Spec is available 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"`.
+C++Spec is available 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"`.
 
 ## Documentation ##
 
-See [http://cppspec.readthedocs.org/]() for all documentation.
-
-## Testing ##
+See [http://cppspec.readthedocs.org/](http://cppspec.readthedocs.org/) for full documentation and a tutorial.
 
 ## Requirements ##
 
 C++Spec requires a compiler with support for C++11 and polymorphic lambda expressions from C++14. This includes GCC >= 4.9, MSVCC >= 14.0, or clang >= 3.4. For other compilers check [this chart](http://en.cppreference.com/w/cpp/compiler_support).
 
 __Note:__ Only the tests require being compiled with C++14 support (`-std=c++14`). No other part of an existing project's build must be modified.
 
+## Introduction ##
+
+If you've ever used RSpec or Jasmine, chances are you'll be familiar with C++Spec's syntax. For example, this is a C++Spec version of the first snippet on RSpec's [README](https://github.com/rspec/rspec-core/blob/master/README.md#basic-structure).
+
+```c++
+describe order_spec("Order", $ {
+  it("sums the prices of its line items", _ {
+    Order order();
+		
+	order.add_entry(LineItem().set_item(Item()
+	  .set_price(Money(1.11, Money::USD))
+	));
+	
+	order.add_entry(LineItem().set_item(Item()
+	  .set_price(Money(1.11, Money::USD))
+	  .set_quantity(2)
+	));
+
+	expect(order.total()).to_equal(Money(5.55, Money::USD));
+  });
+});
+
+```
+
 ## FAQ ##
 
 ## Attribution ##

examples/sample/example_spec.cpp

@@ -32,19 +32,19 @@ describe bool_spec("Some Tests", $ {
 
     explain("0 is", _ {
         it("between -1 and 1 (exclusive)", _ {
-            expect(0).to_be_between(-1, 1, Matchers::RangeMode::exclusive);
+            expect(0).to_be_between(-1, 1).exclusive();
           });
         it("between -0 and 0 (inclusive)", _ {
-            expect(0).to_be_between(-0,0, Matchers::RangeMode::inclusive);
+            expect(0).to_be_between(-0,0).inclusive();
           });
         it("not between -0 and 0 (exclusive)", _ {
-            expect(0).not_().to_be_between(-0,0, Matchers::RangeMode::exclusive);
+            expect(0).not_().to_be_between(-0,0).exclusive();
           });
-        it("not between 1 and -1", _ {
-            expect(0).not_().to_be_between(1,-1);
+        it("not between 1 and -1 (inclusive)", _ {
+            expect(0).not_().to_be_between(1,-1).inclusive();
           });
         it("between -1.0 and 1.0 (exclusive)", _ {
-            expect(0).to_be_between(-1.0, 1.0, Matchers::RangeMode::exclusive);
+            expect(0).to_be_between(-1.0, 1.0).exclusive();
           });
       });
 
@@ -162,7 +162,7 @@ describe_a <std::vector<int>> vector_spec({1,2,3,4}, $ {
 int _count = 0;
 describe let_spec("let", $ {
   let(count, [&]{ return ++_count ;});
-    
+
   it("memoizes the value", _ {
     expect(count).to_equal(1);
     expect(count).to_equal(1);

include/class_description.hpp

@@ -20,7 +20,7 @@ class ClassDescription : public Description {
   bool first;
 
  public:
-  T subject;  // subject field exposed for usage in `expect([self.]subject)`
+  T subject;  // subject field public for usage in `expect([self.]subject)`
 
   // Constructor
   // if there's no explicit subject given, then use
@@ -50,7 +50,7 @@ class ClassDescription : public Description {
 
   template <typename U>
   ClassDescription(std::initializer_list<U> init_list, block_t body)
-      : Description(), body(body), subject(T(init_list)) {
+      : body(body), subject(T(init_list)) {
     this->descr = Pretty::to_word_type(subject);
   };
 
@@ -150,8 +150,7 @@ bool Description::context(std::initializer_list<U> init_list,
 template <class T>
 bool ClassDescription<T>::it(std::string name,
                              std::function<void(ItCd<T>&)> body) {
-  ItCd<T> it(this->subject, name, body);
-  it.set_parent(this);
+  ItCd<T> it(*this, this->subject, name, body);
   bool result = it.run();
   exec_after_eaches();
   exec_before_eaches();
@@ -181,8 +180,7 @@ bool ClassDescription<T>::it(std::string name,
  */
 template <class T>
 bool ClassDescription<T>::it(std::function<void(ItCd<T>&)> body) {
-  ItCd<T> it(this->subject, body);
-  it.set_parent(this);
+  ItCd<T> it(*this, this->subject, body);
   bool result = it.run();
   exec_after_eaches();
   exec_before_eaches();
@@ -200,8 +198,7 @@ bool ClassDescription<T>::run() {
 template <class T>
 Expectations::Expectation<T> ItCd<T>::is_expected() {
   auto cd = static_cast<ClassDescription<T>*>(this->get_parent());
-  Expectations::Expectation<T> expectation(cd->subject);
-  expectation.set_parent(this);
+  Expectations::Expectation<T> expectation(*this, cd->subject);
   return expectation;
 }
 

include/cppspec.hpp

@@ -23,8 +23,10 @@ class Description : public Runnable {
   std::deque<rule_block_t> after_eaches;
   std::unordered_map<std::string, Runnable *> lets;
 
-  explicit Description(){};
-  explicit Description(std::string descr) : descr(descr){};
+  Description(){};
+  Description(std::string descr) : descr(descr){};
+  Description(Child &parent, std::string descr, block_t body)
+      : Runnable(parent), body(body), descr(descr){};
 
  public:
   // Constructor
@@ -40,21 +42,22 @@ class Description : public Runnable {
   template <class T>
   bool 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>
+  //  bool context(T &subject, std::function<void(ClassDescription<T> &)> body);
 
   template <class T, typename U>
   bool context(std::initializer_list<U> init_list,
                std::function<void(ClassDescription<T> &)> body);
 
-  template <class T>
-  ClassDescription<T> subject(T subject);
-
-  template <class T>
-  ClassDescription<T> subject(T &subject);
-
-  template <class T>
-  ClassDescription<std::vector<T>> subject(std::initializer_list<T> init_list);
+  //  template <class T>
+  //  ClassDescription<T> subject(T subject);
+  //
+  //  template <class T>
+  //  ClassDescription<T> subject(T &subject);
+  //
+  //  template <class T>
+  //  ClassDescription<std::vector<T>> subject(std::initializer_list<T>
+  //  init_list);
 
   void before_each(rule_block_t block);
   void before_all(rule_block_t block);
@@ -73,52 +76,43 @@ typedef Description Context;
 
 bool Description::context(std::string name,
                           std::function<void(Description &)> body) {
-  Context context(name, body);
-  context.set_parent(this);
+  Context context(*this, name, body);
   context.before_eaches = this->before_eaches;
   context.after_eaches = this->after_eaches;
   return context.run();
 }
 
 bool Description::it(std::string name, std::function<void(ItD &)> body) {
-  ItD it(name, body);
-  it.set_parent(this);
+  ItD it(*this, name, body);
   bool result = it.run();
   exec_after_eaches();
   exec_before_eaches();
   return result;
 }
 
 bool Description::it(std::function<void(ItD &)> body) {
-  ItD it(body);
-  it.set_parent(this);
+  ItD it(*this, body);
   bool result = it.run();
   exec_after_eaches();
   exec_before_eaches();
   return result;
 }
 
-template <class U>
-ClassDescription<U> Description::subject(U subject) {
-  ClassDescription<U> cd(this);
-  cd->example = subject;
-  return cd;
-}
-
-template <class U>
-ClassDescription<U> Description::subject(U &subject) {
-  ClassDescription<U> cd(this);
-  cd->example = subject;
-  return cd;
-}
-
-template <class U>
-ClassDescription<std::vector<U>> Description::subject(
-    std::initializer_list<U> init_list) {
-  ClassDescription<U> cd(this);
-  cd->example = std::vector<U>(init_list);
-  return cd;
-}
+// template <class U>
+// ClassDescription<U> Description::subject(U subject) {
+//  return ClassDescription<U>(*this, subject);
+//}
+//
+// template <class U>
+// ClassDescription<U> Description::subject(U &subject) {
+//  return ClassDescription<U>(*this, subject);
+//}
+//
+// template <class U>
+// ClassDescription<std::vector<U>> Description::subject(
+//    std::initializer_list<U> init_list) {
+//  return ClassDescription<std::vector<U>>(*this, std::vector<U>(init_list));
+//}
 
 void Description::before_each(rule_block_t b) {
   before_eaches.push_back(b);
@@ -127,9 +121,8 @@ void Description::before_each(rule_block_t b) {
   // the environment by executing the before_each, so that when an 'it'
   // declaration's lambda captures that env, it has the correct values for the
   // variables. Truthfully, 'before_each' is a misnomer, as they are not
-  // getting
-  // executed directly before the lambda's execution as one might expect, but
-  // instead before the *next* lambda is declared.
+  // getting executed directly before the lambda's execution as one might
+  // expect, but instead before the *next* lambda is declared.
   b();
 }
 
@@ -191,8 +184,7 @@ Expectations::Expectation<T> ItExpBase::expect(Let<T> let) {
   auto parent = static_cast<Description *>(this->get_parent());
   Let<T> *actual_let = static_cast<Let<T> *>(parent->find_let(let.get_name()));
   T res = actual_let->get_result();
-  Expectations::Expectation<T> expectation(res);
-  expectation.set_parent(this);
+  Expectations::Expectation<T> expectation(*this, res);
   return expectation;
 }