Remove unnecessary includes, begin writing specs

Author: toroidal-code

.travis.yml

@@ -2,14 +2,36 @@ language: cpp
 
 compiler:
   - clang
+  - gcc
+
+before_install:
+  - git submodule update --init --recursive
+
+install:
+  - if [ "$CC" = "gcc" ]; then export CXX="g++-5" CC="gcc-5"; fi
+  - if [ "$CC" = "clang" ]; then export CXX="clang++-3.7" CC="clang-3.7"; fi
 
 before_script:
   - mkdir build
   - cd build
-  - cmake ..
+  - cmake .. -DBUILD_TESTS=YES
 
-script: make
+script:
+  - make
+  - make spec
 
 os:
   - linux
-  - osx
+
+addons:
+  apt:
+    sources:
+      - george-edison55-precise-backports
+      - ubuntu-toolchain-r-test
+      - llvm-toolchain-precise-3.7
+    packages:
+      - cmake-data
+      - cmake
+      - gcc-5
+      - g++-5
+      - clang-3.7

CMakeLists.txt

@@ -1,6 +1,11 @@
 project( c++spec )
 
-cmake_minimum_required( VERSION 3.0 )
+if ( IWYU )
+  cmake_minimum_required( VERSION 3.3 FATAL_ERROR )
+  find_program(iwyu_path NAMES include-what-you-use iwyu)
+else ()
+  cmake_minimum_required( VERSION 3.0 )
+endif ( IWYU )
 
 set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Werror" )
 set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++1y -Wall -Werror")
@@ -11,12 +16,18 @@ target_include_directories( c++spec INTERFACE
   $<INSTALL_INTERFACE:include/>  # <prefix>/include/
 )
 
-option ( BUILD_TESTING "Build tests." OFF )
-if ( BUILD_TESTING )
+option ( BUILD_TESTS "Build tests." OFF )
+if ( BUILD_TESTS )
+  enable_testing()
+
+  # Tests
   add_subdirectory( spec )
-endif ( BUILD_TESTING )
+endif ( BUILD_TESTS )
 
 option( BUILD_EXAMPLES "Build examples." OFF )
 if ( BUILD_EXAMPLES )
   add_subdirectory( examples )
+  if(iwyu_path)
+    set_property(TARGET cppspec_sample PROPERTY CXX_INCLUDE_WHAT_YOU_USE ${iwyu_path})
+  endif()
 endif ( BUILD_EXAMPLES )

Doxyfile

@@ -1924,7 +1924,7 @@ SEARCH_INCLUDES        = YES
 # preprocessor.
 # This tag requires that the tag SEARCH_INCLUDES is set to YES.
 
-INCLUDE_PATH           =
+INCLUDE_PATH           = ./include/
 
 # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
 # patterns (like *.h and *.hpp) to filter out the header-files in the
@@ -2056,7 +2056,7 @@ HIDE_UNDOC_RELATIONS   = YES
 # set to NO
 # The default value is: NO.
 
-HAVE_DOT               = NO
+HAVE_DOT               = YES
 
 # The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
 # to run in parallel. When set to 0 doxygen will base this on the number of
@@ -2098,7 +2098,7 @@ DOT_FONTPATH           =
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
-CLASS_GRAPH            = YES
+CLASS_GRAPH            = NO
 
 # If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
 # graph for each documented class showing the direct and indirect implementation
@@ -2172,7 +2172,7 @@ INCLUDED_BY_GRAPH      = YES
 # The default value is: NO.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
-CALL_GRAPH             = NO
+CALL_GRAPH             = YES
 
 # If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
 # dependency graph for every global function or class method.
@@ -2183,7 +2183,7 @@ CALL_GRAPH             = NO
 # The default value is: NO.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
-CALLER_GRAPH           = NO
+CALLER_GRAPH           = YES
 
 # If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
 # hierarchy of all classes instead of a textual one.

include/class_description.hpp

@@ -1,18 +1,9 @@
 #ifndef CLASS_DESCRIPTION_H
 #define CLASS_DESCRIPTION_H
-
-#include <string>
-#include <vector>
-#include <map>
-#include <functional>
-#include <iostream>
-#include "util.hpp"
 #include "description.hpp"
-#include "it.hpp"
-#include "expectations/expectation.hpp"
 
 /**
- * @brief A Description with an implicit subject
+ * @brief A Description with a defined subject
  *
  * A ClassDescription is a subclass of Description that
  * allows for templating and specification of the subject
@@ -26,56 +17,58 @@ template <class T>
 class ClassDescription : public Description {
   typedef std::function<void(ClassDescription<T>&)> block_t;
   block_t body;
-  T example;
   bool first;
 
  public:
+  T subject;  // subject field exposed for usage in `expect([self.]subject)`
+
   // Constructor
-  // if there's no explicit subject given, then default using
-  // the default constructor of the given type as the subject.
-  ClassDescription<T>(block_t body)
-      : Description(Pretty::to_word(T()) + " : " +
-                    Util::demangle(typeid(T).name())),
-        body(body),
-        example(T()){};
+  // if there's no explicit subject given, then use
+  // the default constructor of the given type as the implicit subject.
+  ClassDescription<T>(block_t body) : Description(), body(body), subject(T()) {
+    this->descr = Pretty::to_word_type(subject);
+  };
+
+  ClassDescription<T>(std::string descr, block_t body)
+      : Description(descr), body(body), subject(T()){};
 
   ClassDescription(T subject, block_t body)
-      : Description(Pretty::to_word(subject) + " : " +
-                    Util::demangle(typeid(T).name())),
+      : Description(Pretty::to_word_type(subject)),
         body(body),
-        example(subject){};
+        subject(subject){};
+
+  ClassDescription(std::string descr, T subject, block_t body)
+      : Description(descr), body(body), subject(subject){};
 
   ClassDescription(T& subject, block_t body)
-      : Description(Pretty::to_word(subject) + " : " +
-                    Util::demangle(typeid(T).name())),
+      : Description(Pretty::to_word_type(subject)),
         body(body),
-        example(subject){};
+        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)
-      : Description(Pretty::to_word(init_list) + " : " +
-                    Util::demangle(typeid(T).name())),
-        body(body),
-        example(T(init_list)){};
+      : Description(), body(body), subject(T(init_list)) {
+    this->descr = Pretty::to_word_type(subject);
+  };
+
+  template <typename U>
+  ClassDescription(std::string descr, std::initializer_list<U> init_list,
+                   block_t body)
+      : Description(descr), body(body), subject(T(init_list)){};
 
   ClassDescription<T>(Description& d) : Description(d){};
 
   const bool has_subject = true;
-  void set_subject(T& subject) { example = subject; }
-  T& get_subject() { return example; }
 
   bool it(std::string descr, std::function<void(ItCd<T>&)> body);
   bool it(std::function<void(ItCd<T>&)> body);
   bool context(T subject, block_t body);
   bool context(T& subject, block_t body);
   bool context(block_t body);
   bool run();
-
-  template <class U>
-  ClassDescription<U> subject(U subject);
-
-  template <class U>
-  ClassDescription<U> subject(U& subject);
 };
 
 template <class T>
@@ -110,7 +103,7 @@ template <class T>
 bool Description::context(T subject,
                           std::function<void(ClassDescription<T>&)> body) {
   ClassContext<T> context(body);
-  context.set_subject(subject);
+  context.subject = subject;
   context.set_parent(this);
   context.before_eaches = this->before_eaches;
   context.after_eaches = this->after_eaches;
@@ -157,7 +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(name, body);
+  ItCd<T> it(this->subject, name, body);
   it.set_parent(this);
   bool result = it.run();
   exec_after_eaches();
@@ -188,30 +181,14 @@ bool ClassDescription<T>::it(std::string name,
  */
 template <class T>
 bool ClassDescription<T>::it(std::function<void(ItCd<T>&)> body) {
-  ItCd<T> it(body);
+  ItCd<T> it(this->subject, body);
   it.set_parent(this);
   bool result = it.run();
   exec_after_eaches();
   exec_before_eaches();
   return result;
 }
 
-template <class T>
-template <class U>
-ClassDescription<U> ClassDescription<T>::subject(U subject) {
-  ClassDescription<U> cd(static_cast<Description>(this));
-  cd->example = subject;
-  return cd;
-}
-
-template <class T>
-template <class U>
-ClassDescription<U> ClassDescription<T>::subject(U& subject) {
-  ClassDescription<U> cd(static_cast<Description>(this));
-  cd->example = subject;
-  return cd;
-}
-
 template <class T>
 bool ClassDescription<T>::run() {
   std::cout << padding() << descr << std::endl;
@@ -223,7 +200,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->get_subject());
+  Expectations::Expectation<T> expectation(cd->subject);
   expectation.set_parent(this);
   return expectation;
 }

include/cppspec.hpp

@@ -1,15 +1,18 @@
-#include "description.hpp"
+/**
+ * @file
+ * @brief The core header file for Cppspec
+ */
 #include "class_description.hpp"
-#include "it.hpp"
-#include "expectations/expectation.hpp"
 
 #define _ [=](auto &self)
 #define $ [](auto &self)
 #define it self.it
 #define context self.template context
-#define explain context
+#define explain context  // piggybacks off of the `context` macro
 #define expect self.template expect
 #define is_expected self.is_expected
+#define subject self.subject
+
 #define before_all self.before_all
 #define before_each self.before_each
 #define after_all self.after_all

include/description.hpp

@@ -1,16 +1,12 @@
+/**
+ * @file
+ * @brief Defines the Description class and associated functions
+ */
 #ifndef DESCRIPTION_H
 #define DESCRIPTION_H
-
-#include <string>
 #include <queue>
 #include <unordered_map>
-#include <functional>
-#include <iostream>
-#include <memory>
-#include "util.hpp"
-#include "runnable.hpp"
 #include "it.hpp"
-#include "let.hpp"
 
 template <class T>
 class ClassDescription;
@@ -27,6 +23,7 @@ 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){};
 
  public:

include/expectations/expectation.hpp

@@ -1,10 +1,10 @@
+/**
+ * @file
+ * @brief Defines the Expectations::Expectation class and associated functions
+ */
 #ifndef EXPECTATION_H
 #define EXPECTATION_H
-#include <functional>
-#include <vector>
-#include "runnable.hpp"
 #include "let.hpp"
-#include "matchers/basematcher.hpp"
 #include "matchers/be.hpp"
 #include "matchers/be_between.hpp"
 #include "matchers/be_within.hpp"

include/expectations/fail_with.hpp

@@ -1,6 +1,5 @@
 #ifndef FAIL_WITH_H
 #define FAIL_WITH_H
-#include <string>
 #include <stdexcept>
 #include <iostream>
 // the following are UBUNTU/LINUX ONLY terminal color codes.

include/expectations/handler.hpp

@@ -1,7 +1,5 @@
 #ifndef HANDLER_H
 #define HANDLER_H
-#include <string>
-#include "matchers/basematcher.hpp"
 #include "fail_with.hpp"
 //#include "matchers/negativebasematcher.hpp"
 

include/it.hpp

@@ -1,9 +1,5 @@
 #ifndef IT_H
 #define IT_H
-#include <string>
-#include <functional>
-#include <unordered_map>
-#include "it_base.hpp"
 #include "expectations/expectation.hpp"
 
 class ItExpBase : public ItBase {
@@ -42,11 +38,14 @@ class ItCd : public ItExpBase {
   std::function<void(ItCd<T> &)> body;
 
  public:
+  T &subject;
+
   // This is only ever instantiated by ClassDescription<T>
-  ItCd(std::string descr, std::function<void(ItCd<T> &)> body)
-      : ItExpBase(descr), body(body) {}
+  ItCd(T &subject, std::string descr, std::function<void(ItCd<T> &)> body)
+      : ItExpBase(descr), body(body), subject(subject) {}
 
-  ItCd(std::function<void(ItCd<T> &)> body) : body(body) {}
+  ItCd(T &subject, std::function<void(ItCd<T> &)> body)
+      : body(body), subject(subject) {}
 
   Expectations::Expectation<T> is_expected();
   bool run();