xspec 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a5dba5d7629f6d87591f9abe883290f50372dc64
-  data.tar.gz: ead15780cdec15272984c1580051e7d7f2eadded
+  metadata.gz: b3831933eef297e842aeb3d87c7fd269f15e1377
+  data.tar.gz: 72891d3ec2b7a439cbedc809c98393591e673d46
 SHA512:
-  metadata.gz: b37433a77450176d0cf1ebeae40d5ad24ef28ce8095887126edfd5dfd0040fdcfbf418a1726862a60eb7f275f347d19a371720331b5376145e256bff08374ef5
-  data.tar.gz: 963b1b472454aeaeb03aa956a1e38ff3a9b1a9bb4bf78fcd8c9eb06aae26a31d4591ed8e7b9a4fa1c11f43a7413a2d37112d2bd140c182145fcadc8745922b91
+  metadata.gz: 3825fe02479cf05849b66351a846adb91d0af0f895b1b5a1e12e555626fca1724066d759466f8b41e7149691b5e290288098e50dff3877beb1f220549d55f9cc
+  data.tar.gz: e4e573a3aca9af04bfa5f9b4db9af146c29f56d1112c3ed410b78e5d5ab785db6c53abc59a74be333dc1fc92d29b1c2bfc20d147882ec194dfb9746fc6650b50

data/README.md

@@ -21,7 +21,7 @@ extend XSpec.dsl # Use defaults
 describe 'my application' do
   it 'does math' do
     double = instance_double('Calculator')
-    expect(double).add(1, 1) { 2 }
+    stub(double).add(1, 1) { 2 }
 
     assert_equal 2, double.add(1, 1)
   end
@@ -43,9 +43,9 @@ see the colors in this README, but trust me they are quite lovely.
 > xspec example.rb
 
 my application
-  0.000s does math
-  0.011s is slow sometimes
-  0.000s fails - FAILED
+  0.000s 3l1 does math
+  0.011s f0j is slow sometimes
+  0.000s juj fails - FAILED
 
            Timings:
      0.001 #################### 2
@@ -54,11 +54,25 @@ my application
        0.1 ##########           1
 
 
-my application fails:
+juj - my application fails
   "fruit" not present in: "punch"
 
-  example.rb:18:in `block (2 levels) in <top (required)>'
-  bin/xspec:19:in `<main>'
+  test.rb:17:in `block (2 levels) in <top (required)>'
+  bin/xspec:44:in `<main>'
+```
+
+The three-character tag next to each test is its short id. You can use it to
+run a single test:
+
+```
+> xspec -f 3l1
+
+my application
+  0.000s 3l1 does math
+
+           Timings:
+     0.001 #################### 1
+
 ```
 
 ### Customization
@@ -73,11 +87,11 @@ expectations. You could do that:
 require 'xspec'
 
 extend XSpec.dsl(
-  assertion_context: XSpec::AssertionContext.stack {
-    include XSpec::AssertionContext::RSpecExpectations
+  evaluator_context: XSpec::Evaluator.stack {
+    include XSpec::Evaluator::RSpecExpectations
   },
-  notifier: XSpec::Notifiers::Character.new +
-            XSpec::Notifiers::FailuresAtEnd.new
+  notifier: XSpec::Notifier::Character.new +
+            XSpec::Notifier::FailuresAtEnd.new
 )
 
 describe '...' do
@@ -86,15 +100,15 @@ end
 ```
 
 Of course, you can make your own extension classes as well. For details, see
-the "Configuration" section of the documentation.
+the API documentation.
 
 Documentation
 -------------
 
 There are two major sources of documentation:
 
-* [Main API documentation.](https://xaviershay.github.io/xspec/api.html)
-* [Literate source code.](https://xaviershay.github.io/xspec/)
+* [Main API documentation.](https://xaviershay.github.io/xspec/docs/api.html)
+* [Literate source code.](https://xaviershay.github.io/xspec/docs/xspec.html)
 
 It is expected that regular users of XSpec will read both at least once. There
 isn't much to them, and they will give you a useful mental model of how XSpec

data/bin/xspec

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
 
+require 'optparse'
+
 $LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
 
 require 'xspec'
@@ -7,6 +9,27 @@ require 'xspec'
 $LOAD_PATH.unshift "spec"
 $LOAD_PATH.unshift "lib"
 
+filter    = nil
+short_ids = []
+
+parser = OptionParser.new
+parser.banner = "Usage: xspec [options] [files]"
+parser.separator ""
+parser.on('-e FILTER', "Run specs with full name including FILTER.") do |f|
+  filter = Regexp.new(f)
+end
+parser.on('-f ID', "Run spec with short id ID. Use multiple times to specify more than one id.") do |f|
+  short_ids << f
+end
+parser.on("-h", "--help", "Show this message.") do
+  $stderr.puts parser
+  exit
+end
+parser.separator ""
+
+parser.parse!
+
+
 files = if ARGV.any? {|x| x.length > 0 }
   ARGV
 else
@@ -18,7 +41,25 @@ files.each do |f|
 end
 
 if respond_to?(:run!)
-  exit 1 unless run!
+  result = run! {|config|
+    config.update(scheduler: XSpec::Scheduler::Filter.new(
+      scheduler: config.fetch(:scheduler),
+      filter:    -> uow {
+        inc = true
+
+        if short_ids.any?
+          inc &&= short_ids.include?(config.fetch(:short_id).(uow))
+        end
+
+        if filter
+          inc &&= uow.full_name =~ filter
+        end
+
+        inc
+      }
+    ))
+  }
+  exit 1 unless result
 else
   $stderr.puts "This script can only be used when XSpec.dsl is mixed in to " +
                "global scope."

data/lib/xspec.rb

@@ -12,8 +12,8 @@ module XSpec
   # This enables different options to be specified per DSL, which is at the
   # heart of XSpec's modularity. It is easy to change every component to your
   # liking.
-  def dsl(options = {})
-    options = XSpec.add_defaults(options)
+  def dsl(config = {})
+    config = XSpec.add_defaults(config)
 
     Module.new do
       # Each DSL provides a standard set of methods provided by the [DSL
@@ -24,22 +24,26 @@ module XSpec
       # described in detail in the
       # [`data_structures.rb`](data_structures.html).
       def __xspec_context
-        evaluator = __xspec_opts.fetch(:evaluator)
+        evaluator = __xspec_config.fetch(:evaluator)
         @__xspec_context ||= XSpec::Context.root(evaluator)
       end
 
-      # Some meta-magic is needed to enable the options from local scope above
+      # Some meta-magic is needed to enable the config from local scope above
       # to be available inside the module.
-      define_method(:__xspec_opts) { options }
+      define_method(:__xspec_config) { config }
 
       # `run!` is where the magic happens. Typically called at the end of a
       # file (or by `autorun!`), this method takes all the data that was
       # accumulated by the DSL methods above and runs it through the scheduler.
-      def run!
-        notifier  = __xspec_opts.fetch(:notifier)
-        scheduler = __xspec_opts.fetch(:scheduler)
+      #
+      # It takes an optional block that can be used to override any options
+      # set in the initial `XSpec.dsl` call.
+      def run!(&overrides)
+        overrides ||= -> x { x }
+        config = overrides.(__xspec_config)
+        scheduler = config.fetch(:scheduler)
 
-        scheduler.run(__xspec_context, notifier)
+        scheduler.run(__xspec_context, config)
       end
 
       # It is often convenient to trigger a run after all files have been

data/lib/xspec/data_structures.rb

@@ -2,7 +2,7 @@
 
 # XSpec data structures are very dumb. They:
 #
-# * Only contain iteration and creation logic.
+# * Only contain iteration, property, and creation logic.
 # * Do not store recursive references ("everything flows downhill").
 module XSpec
   # A unit of work, usually created by the `it` DSL method, is a labeled,
@@ -85,7 +85,7 @@ module XSpec
       # A shared context is a floating context that isn't part of any context
       # heirachy, so its units of work will not be visible to the root node. It
       # can be brought into any point in the heirachy using `copy_into_tree`
-      # (aliased as `it_behaves_like_a` in the DSL), and this can be done
+      # (aliased as `include_context` in the DSL), and this can be done
       # multiple times, which allows definitions to be reused.
       #
       # This is leaky abstraction, since only units of work are copied from
@@ -156,6 +156,10 @@ module XSpec
     def block; unit_of_work.block; end
     def name;  unit_of_work.name; end
 
+    def full_name
+      (parents + [self]).map(&:name).compact.join(' ')
+    end
+
     def immediate_parent
       parents.last
     end
@@ -170,6 +174,7 @@ module XSpec
   ExecutedUnitOfWork = Struct.new(:nested_unit_of_work, :errors, :duration) do
     def name; nested_unit_of_work.name end
     def parents; nested_unit_of_work.parents end
+    def full_name; nested_unit_of_work.full_name end
   end
 
   # A test failure will be reported as a `Failure`, which includes contextual

data/lib/xspec/defaults.rb

@@ -7,7 +7,21 @@ require 'xspec/schedulers'
 require 'xspec/evaluators'
 require 'xspec/notifiers'
 
+require 'digest/sha1'
+
 module XSpec
+  def default_short_id(uow)
+    length  = 3
+    base    = 32
+    digest  = Digest::SHA1.hexdigest(uow.full_name).hex
+    bottom  = base ** (length-1)
+    top     = base ** length
+    shifted = digest % (top - bottom) + bottom
+
+    shifted.to_s(base)
+  end
+  module_function :default_short_id
+
   def add_defaults(options = {})
     # A notifier makes it possible to observe the state of the system, be that
     # progress or details of failing tests.
@@ -20,6 +34,9 @@ module XSpec
     # used.
     options[:evaluator] ||= Evaluator::DEFAULT
 
+    options[:short_id] ||= XSpec.method(:default_short_id)
+
+
     # An scheduler is responsible for scheduling units of work and handing them
     # off to the assertion context. Any logic regarding threads, remote
     # execution or the like belongs in a scheduler.

data/lib/xspec/dsl.rb

@@ -24,7 +24,7 @@ module XSpec
       __xspec_context.create_shared_context(*args, &block)
     end
 
-    def it_behaves_like_a(context)
+    def include_context(context)
       __xspec_context.copy_into_tree(context)
     end
   end

data/lib/xspec/evaluators.rb

@@ -33,28 +33,24 @@ module XSpec
     module Top
       def call(unit_of_work)
         super
+      rescue EvaluateFailed => e
+        [Failure.new(unit_of_work, e.message, e.backtrace)]
       rescue => e
         [CodeException.new(unit_of_work, e.message, e.backtrace)]
       end
     end
 
+    # As long as the `Top` evaluator is used, evaluators can raise
+    # `EvaluateFailed` to indicate a failure separate from a normal code
+    # exception.
+    EvaluateFailed = Class.new(RuntimeError)
+
     # ### Simple Assertions
     #
     # This simple evaluator provides very straight-forward assertion methods.
     module Simple
-      class AssertionFailed < RuntimeError
-        attr_reader :message, :backtrace
-
-        def initialize(message, backtrace)
-          @message   = message
-          @backtrace = backtrace
-        end
-      end
-
       def call(unit_of_work)
         super
-      rescue AssertionFailed => e
-        [Failure.new(unit_of_work, e.message, e.backtrace)]
       end
 
       def assert(proposition, message=nil)
@@ -90,7 +86,7 @@ EOS
       private
 
       def _raise(message)
-        raise AssertionFailed.new(message, caller)
+        raise EvaluateFailed, message
       end
     end
 
@@ -99,12 +95,8 @@ EOS
     # The doubles module provides test doubles that can be used in-place of
     # real objects.
     module Doubles
-      DoubleFailure = Class.new(RuntimeError)
-
       def call(unit_of_work)
         super
-      rescue DoubleFailure => e
-        [Failure.new(unit_of_work, e.message, e.backtrace)]
       end
 
       # It can be configured with the following options:
@@ -227,7 +219,7 @@ EOS
             @received.delete_at(i)
           else
             name, rest = *args
-            ::Kernel.raise DoubleFailure,
+            ::Kernel.raise EvaluateFailed,
               "Did not receive: %s(%s)\nDid receive:%s\n" % [
                 name,
                 [*rest].map(&:inspect).join(", "),
@@ -269,7 +261,7 @@ EOS
           name, rest = *args
 
           unless @klass.respond_to?(name)
-            raise DoubleFailure,
+            raise EvaluateFailed,
               "#{@klass}.#{name} is unimplemented or not public"
           end
         end
@@ -280,7 +272,7 @@ EOS
           name, rest = *args
 
           unless @klass.public_instance_methods.include?(name)
-            raise DoubleFailure,
+            raise EvaluateFailed,
               "#{@klass}##{name} is unimplemented or not public"
           end
         end
@@ -293,7 +285,7 @@ EOS
           ref = if self.class.const_defined?(klass)
             type.new(self.class.const_get(klass))
           else
-            raise DoubleFailure, "#{klass} is not a valid class name"
+            raise EvaluateFailed, "#{klass} is not a valid class name"
           end
 
           super

data/lib/xspec/notifiers.rb

@@ -5,6 +5,17 @@
 # summarizing the run when it finished.
 module XSpec
   module Notifier
+    # A formatter must implement at least four methods. `run_start` and
+    # `run_finish` are called at the beginning and end of the full spec run
+    # respectively, while `evaluate_start` and `evaluate_finish` are called for
+    # each test. See [API docs](api.html#notifiers) for more information.
+    module EmptyFormatter
+      def run_start(*_); end
+      def evaluate_start(*_); end
+      def evaluate_finish(*_); end
+      def run_finish(*_); true; end
+    end
+
     # Many notifiers play nice with others, and can be composed together in a
     # way that each notifier will have its callback run in turn.
     module Composable
@@ -20,8 +31,8 @@ module XSpec
         @notifiers = notifiers
       end
 
-      def run_start
-        notifiers.each(&:run_start)
+      def run_start(*args)
+        notifiers.each {|x| x.run_start(*args) }
       end
 
       def evaluate_start(*args)
@@ -44,16 +55,13 @@ module XSpec
     # Outputs a single character for each executed unit of work representing
     # the result.
     class Character
+      include EmptyFormatter
       include Composable
 
       def initialize(out = $stdout)
         @out = out
       end
 
-      def run_start; end
-
-      def evaluate_start(*_); end
-
       def evaluate_finish(result)
         @out.print label_for_failure(result.errors[0])
         @failed ||= result.errors.any?
@@ -73,11 +81,11 @@ module XSpec
           else '.'
         end
       end
-
     end
 
     # Renders a histogram of test durations after the entire run is complete.
     class TimingsAtEnd
+      include EmptyFormatter
       include Composable
 
       DEFAULT_SPLITS = [0.001, 0.005, 0.01, 0.1, 1.0, Float::INFINITY]
@@ -92,11 +100,6 @@ module XSpec
         @out     = out
       end
 
-      def run_start(*_); end
-
-      def evaluate_start(_)
-      end
-
       def evaluate_finish(result)
         timings[result] = result.duration
       end
@@ -148,19 +151,29 @@ module XSpec
       end
     end
 
+    # Provides convenience methods for working with short ids.
+    module ShortIdSupport
+      def run_start(config)
+        super
+        @short_id = config.fetch(:short_id)
+      end
+
+      def short_id_for(x)
+        @short_id.(x)
+      end
+    end
+
     # Outputs error messages and backtraces after the entire run is complete.
     class FailuresAtEnd
+      include EmptyFormatter
       include Composable
+      include ShortIdSupport
 
       def initialize(out = $stdout)
         @errors = []
         @out    = out
       end
 
-      def run_start; end
-
-      def evaluate_start(*_); end
-
       def evaluate_finish(result)
         self.errors += result.errors
       end
@@ -170,7 +183,11 @@ module XSpec
 
         out.puts
         errors.each do |error|
-          out.puts "%s:\n%s\n\n" % [full_name(error.unit_of_work), error.message.lines.map {|x| "  #{x}"}.join("")]
+          out.puts "%s - %s\n%s\n\n" % [
+            short_id_for(error.unit_of_work),
+            error.unit_of_work.full_name,
+            error.message.lines.map {|x| "  #{x}"}.join("")
+          ]
           clean_backtrace(error.caller).each do |line|
             out.puts "  %s" % line
           end
@@ -182,10 +199,6 @@ module XSpec
 
       private
 
-      def full_name(unit_of_work)
-        (unit_of_work.parents + [unit_of_work]).map(&:name).compact.join(' ')
-      end
-
       # A standard backtrace contains many entries for XSpec itself which are
       # not useful for debugging your tests, so they are stripped out.
       def clean_backtrace(backtrace)
@@ -204,9 +217,9 @@ module XSpec
     # Includes nicely formatted names and durations of each test in the output,
     # with color.
     class ColoredDocumentation
-      require 'set'
-
+      include EmptyFormatter
       include Composable
+      include ShortIdSupport
 
       VT100_COLORS = {
         :black   => 30,
@@ -219,24 +232,6 @@ module XSpec
         :white   => 37
       }
 
-      def color_code_for(color)
-        VT100_COLORS.fetch(color)
-      end
-
-      def colorize(text, color)
-        "\e[#{color_code_for(color)}m#{text}\e[0m"
-      end
-
-      def decorate(result)
-        name = result.name
-        out = if result.errors.any?
-          colorize(append_failed(name), :red)
-        else
-          colorize(name , :green)
-        end
-        "%.3fs " % result.duration + out
-      end
-
       def initialize(out = $stdout)
         self.indent          = 2
         self.last_seen_names = []
@@ -244,10 +239,6 @@ module XSpec
         self.out             = out
       end
 
-      def run_start; end
-
-      def evaluate_start(*_); end
-
       def evaluate_finish(result)
         output_context_header! result.parents.map(&:name).compact
 
@@ -267,6 +258,28 @@ module XSpec
 
       attr_accessor :last_seen_names, :indent, :failed, :out
 
+      def color_code_for(color)
+        VT100_COLORS.fetch(color)
+      end
+
+      def colorize(text, color)
+        "\e[#{color_code_for(color)}m#{text}\e[0m"
+      end
+
+      def decorate(result)
+        name = result.name
+        out = if result.errors.any?
+          colorize(append_failed(name), :red)
+        else
+          colorize(name , :green)
+        end
+        "%.3fs %s %s" % [
+          result.duration,
+          short_id_for(result),
+          out,
+        ]
+      end
+
       def output_context_header!(parent_names)
         if parent_names != last_seen_names
           tail = parent_names - last_seen_names
@@ -299,11 +312,7 @@ module XSpec
     # Useful as a parent class for other notifiers or for testing.
     class Null
       include Composable
-
-      def run_start; end
-      def evaluate_start(*_); end
-      def evaluate_finish(*_); end
-      def run_finish; true; end
+      include EmptyFormatter
     end
 
     DEFAULT =

data/lib/xspec/schedulers.rb

@@ -12,8 +12,9 @@ module XSpec
         @clock = opts.fetch(:clock, ->{ Time.now.to_f })
       end
 
-      def run(context, notifier)
-        notifier.run_start
+      def run(context, config)
+        notifier = config.fetch(:notifier)
+        notifier.run_start(config)
 
         context.nested_units_of_work.each do |x|
           notifier.evaluate_start(x)
@@ -34,6 +35,25 @@ module XSpec
       attr_reader :clock
     end
 
+    class Filter
+      def initialize(scheduler:, filter:)
+        @scheduler = scheduler
+        @filter    = filter
+      end
+
+      def run(context, config)
+        scheduler.run(FilteredContext.new(context, filter), config)
+      end
+
+      FilteredContext = Struct.new(:context, :filter) do
+        def nested_units_of_work
+          context.nested_units_of_work.select(&filter)
+        end
+      end
+
+      attr_reader :scheduler, :filter
+    end
+
     DEFAULT = Serial.new
   end
 end

data/spec/spec_helper.rb

@@ -12,7 +12,7 @@ extend XSpec.dsl(
 def assert_errors_from_run(context, expected_error_messages)
   context.run!
 
-  notifier = context.__xspec_opts.fetch(:notifier)
+  notifier = context.__xspec_config.fetch(:notifier)
   assert_equal expected_error_messages, notifier.errors.flatten.map(&:message)
 end
 

data/spec/unit/assertion_spec.rb

@@ -14,7 +14,7 @@ describe 'simple assertion context' do
       begin
         subject.assert(false)
         fail "Assertion did not fail"
-      rescue XSpec::Evaluator::Simple::AssertionFailed => e
+      rescue XSpec::Evaluator::EvaluateFailed => e
         assert_equal "assertion failed", e.message
       end
     end
@@ -23,7 +23,7 @@ describe 'simple assertion context' do
       begin
         subject.assert(false, "nope")
         fail "Assertion did not fail"
-      rescue XSpec::Evaluator::Simple::AssertionFailed => e
+      rescue XSpec::Evaluator::EvaluateFailed => e
         assert_equal "nope", e.message
       end
     end
@@ -38,7 +38,7 @@ describe 'simple assertion context' do
       begin
         subject.assert_equal("a", "b")
         fail "Assertion did not fail"
-      rescue XSpec::Evaluator::Simple::AssertionFailed => e
+      rescue XSpec::Evaluator::EvaluateFailed => e
         assert_include 'want: "a"', e.message
         assert_include 'got: "b"', e.message
       end
@@ -50,7 +50,7 @@ describe 'simple assertion context' do
       begin
         subject.fail
         assert false, "fail did not fail"
-      rescue XSpec::Evaluator::Simple::AssertionFailed => e
+      rescue XSpec::Evaluator::EvaluateFailed => e
         assert_equal "failed", e.message
       end
     end
@@ -59,7 +59,7 @@ describe 'simple assertion context' do
       begin
         subject.fail ":("
         assert false, "fail did not fail"
-      rescue XSpec::Evaluator::Simple::AssertionFailed => e
+      rescue XSpec::Evaluator::EvaluateFailed => e
         assert_equal ":(", e.message
       end
     end

data/spec/unit/data_structures_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe 'short ids' do
+  def short_id_for(name)
+    XSpec.default_short_id \
+      XSpec::NestedUnitOfWork.new([], XSpec::UnitOfWork.new(name))
+  end
+
+  it 'is the same for same names' do
+    assert_equal short_id_for("abc"), short_id_for("abc")
+  end
+
+  it 'is always the same length' do
+    100.times do
+      name = rand.to_s
+      assert 3 == short_id_for(name).length, "#{name} had bad short id"
+    end
+  end
+end

data/spec/unit/doubles_spec.rb

@@ -12,7 +12,7 @@ describe 'doubles assertion context' do
 
   it 'converts double exceptions to failures' do
     result = subject.call(XSpec::UnitOfWork.new(nil, ->{
-      raise XSpec::Evaluator::Doubles::DoubleFailure, "nope"
+      raise XSpec::Evaluator::EvaluateFailed, "nope"
     }))
     assert_equal "nope", result[0].message
   end
@@ -81,7 +81,7 @@ describe 'doubles assertion context' do
           verify(double).foo("b")
         }
         fail "no error raised"
-      rescue XSpec::Evaluator::Doubles::DoubleFailure => e
+      rescue XSpec::Evaluator::EvaluateFailed => e
         assert_include "Did not receive", e.message
         assert_include 'foo("b")', e.message
       end
@@ -96,7 +96,7 @@ describe 'doubles assertion context' do
           verify(double).foo("c")
         }
         fail "no error raised"
-      rescue XSpec::Evaluator::Doubles::DoubleFailure => e
+      rescue XSpec::Evaluator::EvaluateFailed => e
         assert_include "Did not receive", e.message
         assert_include 'foo("b")', e.message
         assert_include "Did receive", e.message
@@ -122,7 +122,7 @@ describe 'doubles assertion context' do
             stub(double).bogus_method { 123 }
           }
           fail "no error raised"
-        rescue XSpec::Evaluator::Doubles::DoubleFailure => e
+        rescue XSpec::Evaluator::EvaluateFailed => e
           assert_include "LoadedClass#bogus_method", e.message
         end
       end
@@ -134,7 +134,7 @@ describe 'doubles assertion context' do
             verify(double).bogus_method { 123 }
           }
           fail "no error raised"
-        rescue XSpec::Evaluator::Doubles::DoubleFailure => e
+        rescue XSpec::Evaluator::EvaluateFailed => e
           assert_include "LoadedClass#bogus_method", e.message
         end
       end
@@ -157,7 +157,7 @@ describe 'doubles assertion context' do
             stub(double).bogus_method { 123 }
           }
           fail "no error raised"
-        rescue XSpec::Evaluator::Doubles::DoubleFailure => e
+        rescue XSpec::Evaluator::EvaluateFailed => e
           assert_include "LoadedClass.bogus_method", e.message
         end
       end
@@ -169,7 +169,7 @@ describe 'doubles assertion context' do
             verify(double).bogus_method
           }
           fail "no error raised"
-        rescue XSpec::Evaluator::Doubles::DoubleFailure => e
+        rescue XSpec::Evaluator::EvaluateFailed => e
           assert_include "LoadedClass.bogus_method", e.message
         end
       end
@@ -190,7 +190,7 @@ describe 'strict doubles assertion context' do
     begin
       subject.instance_double("Bogus")
       fail "no error raised"
-    rescue XSpec::Evaluator::Doubles::DoubleFailure => e
+    rescue XSpec::Evaluator::EvaluateFailed => e
       assert_include "Bogus", e.message
     end
   end

data/spec/unit/notifiers_spec.rb

@@ -10,6 +10,7 @@ end
 describe 'failures at end notifier' do
   let(:out)      { StringIO.new }
   let(:notifier) { XSpec::Notifier::FailuresAtEnd.new(out) }
+  let(:config)   {{ short_id: -> _ { "XXX" }}}
 
   it 'returns true when no errors are observed' do
     assert notifier.run_finish
@@ -21,10 +22,11 @@ describe 'failures at end notifier' do
       "failed",
       []
     )
+    notifier.run_start(config)
     notifier.evaluate_finish(make_executed_test errors: [failure])
 
     assert !notifier.run_finish
-    assert_include "a b c:\n  failed", out.string
+    assert_include "a b c\n  failed", out.string
   end
 
   it 'cleans lib entries out of backtrace' do
@@ -33,13 +35,14 @@ describe 'failures at end notifier' do
       "failed",
       [File.expand_path('../../../lib', __FILE__) + '/bogus.rb']
     )
+    notifier.run_start(config)
     notifier.evaluate_finish(make_executed_test errors: [failure])
 
     assert !notifier.run_finish
     assert !out.string.include?('bogus.rb')
   end
 
-  it_behaves_like_a ComposableNotifier
+  include_context ComposableNotifier
 end
 
 describe 'character notifier' do
@@ -68,25 +71,27 @@ describe 'character notifier' do
     assert out.string == "E\n"
   end
 
-  it_behaves_like_a ComposableNotifier
+  include_context ComposableNotifier
 end
 
 describe 'documentation notifier' do
   let(:notifier) { XSpec::Notifier::Documentation.new(out) }
   let(:out)      { StringIO.new }
+  let(:config)   {{ short_id: -> uow { 'XXX' }}}
 
   def evaluate_finish(args)
+    notifier.run_start(config)
     notifier.evaluate_finish(make_executed_test args)
     out.string
   end
 
   it 'outputs each context with a header and individual tests' do
-    assert_equal "\na\n  0.001s b\n",
+    assert_equal "\na\n  0.001s XXX b\n",
       evaluate_finish(parents: ['a'], name: 'b')
   end
 
   it 'adds an indent for each nested context' do
-    assert_equal "\na\n  b\n    0.001s c\n",
+    assert_equal "\na\n  b\n    0.001s XXX c\n",
       evaluate_finish(parents: ['a', 'b'], name: 'c')
   end
 
@@ -94,11 +99,11 @@ describe 'documentation notifier' do
     evaluate_finish(parents: ['a', 'b'], name: 'c')
     evaluate_finish(parents: ['a', 'd'], name: 'e')
 
-    assert_equal "\na\n  b\n    0.001s c\n\n  d\n    0.001s e\n", out.string
+    assert_equal "\na\n  b\n    0.001s XXX c\n\n  d\n    0.001s XXX e\n", out.string
   end
 
   it 'ignores contexts with no name' do
-    assert_equal "\na\n  0.001s b\n",
+    assert_equal "\na\n  0.001s XXX b\n",
       evaluate_finish(parents: [nil, 'a', nil], name: 'b')
   end
 
@@ -116,32 +121,35 @@ describe 'documentation notifier' do
     assert_include "FAILED", evaluate_finish(errors: [make_error])
   end
 
-  it_behaves_like_a ComposableNotifier
+  include_context ComposableNotifier
 end
 
 describe 'colored documentation notifier' do
   let(:notifier) { XSpec::Notifier::ColoredDocumentation.new(out) }
   let(:out)      { StringIO.new }
+  let(:config)   {{ short_id: -> uow { 'XXX' }}}
 
   it 'colors successful tests green' do
+    notifier.run_start(config)
     notifier.evaluate_finish(make_executed_test errors: [])
 
     assert_include "\e[32m\e[0m\n", out.string
   end
 
   it 'colors failed and errored tests red' do
+    notifier.run_start(config)
     notifier.evaluate_finish(make_executed_test errors: [make_failure])
 
     assert_include "\e[31mFAILED\e[0m", out.string
   end
 
-  it_behaves_like_a ComposableNotifier
+  include_context ComposableNotifier
 end
 
 describe 'composable notifier' do
   let(:notifier) { XSpec::Notifier::Composite.new }
 
-  it_behaves_like_a ComposableNotifier
+  include_context ComposableNotifier
 end
 
 describe 'null notifier' do
@@ -151,17 +159,18 @@ describe 'null notifier' do
     assert notifier.run_finish
   end
 
-  it_behaves_like_a ComposableNotifier
+  include_context ComposableNotifier
 end
 
 describe 'timings at end' do
-  let(:notifier) { XSpec::Notifier::TimingsAtEnd.new }
+  let(:out)      { StringIO.new }
+  let(:notifier) { XSpec::Notifier::TimingsAtEnd.new(out: out) }
 
   it 'always returns true' do
     assert notifier.run_finish
   end
 
-  it_behaves_like_a ComposableNotifier
+  include_context ComposableNotifier
 end
 
 def make_nested_test(parent_names = [], work_name = nil)

data/xspec.gemspec

@@ -22,6 +22,6 @@ Gem::Specification.new do |gem|
   gem.bindir        = "bin"
   gem.executables  << "xspec"
   gem.license       = "Apache 2.0"
-  gem.version       = "0.1.0"
+  gem.version       = "0.2.0"
   gem.has_rdoc      = false
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xspec
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Xavier Shay
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-29 00:00:00.000000000 Z
+date: 2014-08-10 00:00:00.000000000 Z
 dependencies: []
 description: yeah
 email:
@@ -32,6 +32,7 @@ files:
 - spec/integration/rspec_expectations_spec.rb
 - spec/spec_helper.rb
 - spec/unit/assertion_spec.rb
+- spec/unit/data_structures_spec.rb
 - spec/unit/doubles_spec.rb
 - spec/unit/let_spec.rb
 - spec/unit/notifiers_spec.rb
@@ -66,6 +67,7 @@ test_files:
 - spec/integration/rspec_expectations_spec.rb
 - spec/spec_helper.rb
 - spec/unit/assertion_spec.rb
+- spec/unit/data_structures_spec.rb
 - spec/unit/doubles_spec.rb
 - spec/unit/let_spec.rb
 - spec/unit/notifiers_spec.rb