mspec 1.1.1 → 1.2.0

data/Rakefile

@@ -9,7 +9,7 @@ task :default => :spec
 
 spec = Gem::Specification.new do |s|
   s.name                      = %q{mspec}
-  s.version                   = "1.1.1"
+  s.version                   = "1.2.0"
 
   s.specification_version     = 2 if s.respond_to? :specification_version=
 

data/lib/mspec/runner/actions/tag.rb

@@ -29,15 +29,35 @@ class TagAction < ActionFilter
     @tag = tag
     @comment = comment
     @report = []
+    @exception = false
   end
 
+  # Returns true if there are no _tag_ or _description_ filters. This
+  # means that a TagAction matches any example by default. Otherwise,
+  # returns true if either the _tag_ or the _description_ filter
+  # matches +string+.
   def ===(string)
     return true unless @sfilter or @tfilter
     @sfilter === string or @tfilter === string
   end
 
+  # Callback for the MSpec :before event. Resets the +#exception?+
+  # flag to false.
+  def before(state)
+    @exception = false
+  end
+
+  # Callback for the MSpec :exception event. Sets the +#exception?+
+  # flag.
+  def exception(exception)
+    @exception = exception
+  end
+
+  # Callback for the MSpec :after event. Performs the tag action
+  # depending on the type of action and the outcome of evaluating
+  # the example. See +TagAction+ for a description of the actions.
   def after(state)
-    if self === state.description and outcome? state
+    if self === state.description and outcome?
       tag = SpecTag.new
       tag.tag = @tag
       tag.comment = @comment
@@ -54,10 +74,19 @@ class TagAction < ActionFilter
     end
   end
 
-  def outcome?(state)
+  # Returns true if the result of evaluating the example matches
+  # the _outcome_ registered for this tag action. See +TagAction+
+  # for a description of the _outcome_ types.
+  def outcome?
     @outcome == :all or
-        (@outcome == :pass and not state.exception?) or
-        (@outcome == :fail and state.exception?)
+        (@outcome == :pass and not exception?) or
+        (@outcome == :fail and exception?)
+  end
+
+  # Returns true if an exception was raised while evaluating the
+  # current example.
+  def exception?
+    !!@exception
   end
 
   def report
@@ -65,6 +94,8 @@ class TagAction < ActionFilter
   end
   private :report
 
+  # Callback for the MSpec :finish event. Prints the actions
+  # performed while evaluating the examples.
   def finish
     case @action
     when :add
@@ -86,12 +117,15 @@ class TagAction < ActionFilter
 
   def register
     super
-    MSpec.register :after, self
-    MSpec.register :finish, self
+    MSpec.register :exception, self
+    MSpec.register :after,     self
+    MSpec.register :finish,    self
   end
 
   def unregister
     super
-    MSpec.unregister :after, self
+    MSpec.unregister :exception, self
+    MSpec.unregister :after,     self
+    MSpec.unregister :finish,    self
   end
 end

data/lib/mspec/runner/actions/tally.rb

@@ -48,14 +48,16 @@ class TallyAction
   end
 
   def register
-    MSpec.register :load, self
-    MSpec.register :after, self
+    MSpec.register :load,        self
+    MSpec.register :exception,   self
+    MSpec.register :after,       self
     MSpec.register :expectation, self
   end
 
   def unregister
-    MSpec.unregister :load, self
-    MSpec.unregister :after, self
+    MSpec.unregister :load,        self
+    MSpec.unregister :exception,   self
+    MSpec.unregister :after,       self
     MSpec.unregister :expectation, self
   end
 
@@ -63,15 +65,22 @@ class TallyAction
     @counter.files!
   end
 
+  # Callback for the MSpec :expectation event. Increments the
+  # tally of expectations (e.g. #should, #should_receive, etc.).
   def expectation(state)
     @counter.expectations!
   end
 
+  # Callback for the MSpec :exception event. Increments the
+  # tally of errors and failures.
+  def exception(exception)
+    exception.failure? ? @counter.failures! : @counter.errors!
+  end
+
+  # Callback for the MSpec :after event. Increments the tally
+  # of examples.
   def after(state)
     @counter.examples!
-    state.exceptions.each do |msg, exc|
-      state.failure?(exc) ? @counter.failures! : @counter.errors!
-    end
   end
 
   def format

data/lib/mspec/runner/{state.rb → context.rb}

@@ -1,6 +1,18 @@
 require 'mspec/runner/mspec'
-
-class RunState
+require 'mspec/runner/example'
+
+# Holds the state of the +describe+ block that is being
+# evaluated. Every example (i.e. +it+ block) is evaluated
+# in a context, which may include state set up in <tt>before
+# :each</tt> or <tt>before :all</tt> blocks.
+#
+#--
+# A note on naming: this is named _ContextState_ rather
+# than _DescribeState_ because +describe+ is the keyword
+# in the DSL for refering to the context in which an example
+# is evaluated, just as +it+ refers to the example itself.
+#++
+class ContextState
   def initialize
     @start = []
     @before = []
@@ -32,7 +44,7 @@ class RunState
   end
 
   def it(desc, &block)
-    state = SpecState.new @describe, desc
+    state = ExampleState.new @describe, desc
     @spec << [desc, block, state] unless state.filtered?
   end
 
@@ -42,8 +54,8 @@ class RunState
   end
 
   def protect(what, blocks, check=true)
-    return if check and MSpec.pretend_mode?
-    Array(blocks).each { |block| MSpec.protect what, &block }
+    return false if check and MSpec.pretend_mode?
+    Array(blocks).all? { |block| MSpec.protect what, &block }
   end
 
   def process
@@ -56,10 +68,11 @@ class RunState
     @spec.each do |desc, spec, state|
       @state = state
       MSpec.actions :before, state
-      protect "before :each", @before
-      protect nil, spec
-      protect "after :each", @after
-      protect "Mock.verify_count", lambda { Mock.verify_count }
+      if protect("before :each", @before)
+        protect nil, spec
+        protect "after :each", @after
+        protect "Mock.verify_count", lambda { Mock.verify_count }
+      end
       protect "Mock.cleanup", lambda { Mock.cleanup }
       MSpec.actions :after, state
       @state = nil
@@ -69,48 +82,3 @@ class RunState
   end
 end
 
-class SpecState
-  def initialize(describe, it)
-    @describe = describe
-    @it = it
-    @unfiltered = nil
-  end
-
-  def describe
-    @describe
-  end
-
-  def it
-    @it
-  end
-
-  def description
-    @description ||= "#{@describe} #{@it}"
-  end
-
-  def exceptions
-    @exceptions ||= []
-  end
-
-  def exception?
-    not exceptions.empty?
-  end
-
-  def unfiltered?
-    unless @unfiltered
-      incl = MSpec.retrieve(:include) || []
-      excl = MSpec.retrieve(:exclude) || []
-      @unfiltered   = incl.empty? || incl.any? { |f| f === description }
-      @unfiltered &&= excl.empty? || !excl.any? { |f| f === description }
-    end
-    @unfiltered
-  end
-
-  def filtered?
-    not unfiltered?
-  end
-
-  def failure?(exception)
-    exception.is_a?(ExpectationNotMetError)
-  end
-end

data/lib/mspec/runner/example.rb

@@ -0,0 +1,37 @@
+require 'mspec/runner/mspec'
+
+# Holds some of the state of the example (i.e. +it+ block) that is
+# being evaluated. See also +ContextState+.
+class ExampleState
+  def initialize(describe, it)
+    @describe = describe
+    @it = it
+    @unfiltered = nil
+  end
+
+  def describe
+    @describe
+  end
+
+  def it
+    @it
+  end
+
+  def description
+    @description ||= "#{@describe} #{@it}"
+  end
+
+  def unfiltered?
+    unless @unfiltered
+      incl = MSpec.retrieve(:include) || []
+      excl = MSpec.retrieve(:exclude) || []
+      @unfiltered   = incl.empty? || incl.any? { |f| f === description }
+      @unfiltered &&= excl.empty? || !excl.any? { |f| f === description }
+    end
+    @unfiltered
+  end
+
+  def filtered?
+    not unfiltered?
+  end
+end

data/lib/mspec/runner/exception.rb

@@ -0,0 +1,39 @@
+class ExceptionState
+  attr_reader :description, :describe, :it, :exception
+
+  def initialize(state, location, exception)
+    @exception = exception
+
+    @description = location ? "An exception occurred during: #{location}" : ""
+    if state
+      @description << "\n" unless @description.empty?
+      @description << state.description
+      @describe = state.describe
+      @it = state.it
+    else
+      @describe = @it = ""
+    end
+  end
+
+  def failure?
+    @exception.is_a? ExpectationNotMetError
+  end
+
+  def message
+    if @exception.message.empty?
+      "<No message>"
+    elsif @exception.class == ExpectationNotMetError
+      @exception.message
+    else
+      "#{@exception.class}: #{@exception.message}"
+    end
+  end
+
+  def backtrace
+    begin
+      return @exception.awesome_backtrace.show
+    rescue Exception
+      return @exception.backtrace && @exception.backtrace.join("\n")
+    end
+  end
+end

data/lib/mspec/runner/formatters/dotted.rb

@@ -3,10 +3,12 @@ require 'mspec/runner/actions/timer'
 require 'mspec/runner/actions/tally'
 
 class DottedFormatter
-  attr_reader :timer, :tally
+  attr_reader :exceptions, :timer, :tally
 
   def initialize(out=nil)
-    @states = []
+    @exception = @failure = false
+    @exceptions = []
+    @count = 0
     if out.nil?
       @out = $stdout
     else
@@ -14,68 +16,82 @@ class DottedFormatter
     end
   end
 
+  # Creates the +TimerAction+ and +TallyAction+ instances and
+  # registers them. Registers +self+ for the +:exception+,
+  # +:before+, +:after+, and +:finish+ actions.
   def register
-    @timer = TimerAction.new
-    @timer.register
-    @tally = TallyAction.new
-    @tally.register
+    (@timer = TimerAction.new).register
+    (@tally = TallyAction.new).register
     @counter = @tally.counter
 
-    MSpec.register :after, self
-    MSpec.register :finish, self
+    MSpec.register :exception, self
+    MSpec.register :before,    self
+    MSpec.register :after,     self
+    MSpec.register :finish,    self
   end
 
+  # Returns true if any exception is raised while running
+  # an example. This flag is reset before each example
+  # is evaluated.
+  def exception?
+    @exception
+  end
+
+  # Returns true if all exceptions during the evaluation
+  # of an example are failures rather than errors. See
+  # <tt>ExceptionState#failure</tt>. This flag is reset
+  # before each example is evaluated.
+  def failure?
+    @failure
+  end
+
+  # Callback for the MSpec :before event. Resets the
+  # +#exception?+ and +#failure+ flags.
+  def before(state)
+    @failure = @exception = false
+  end
+
+  # Callback for the MSpec :exception event. Stores the
+  # +ExceptionState+ object to generate the list of backtraces
+  # after all the specs are run. Also updates the internal
+  # +#exception?+ and +#failure?+ flags.
+  def exception(exception)
+    @count += 1
+    @failure = @exception ? @failure && exception.failure? : exception.failure?
+    @exception = true
+    @exceptions << exception
+  end
+
+  # Callback for the MSpec :after event. Prints an indicator
+  # for the result of evaluating this example as follows:
+  #   . = No failure or error
+  #   F = An ExpectationNotMetError was raised
+  #   E = Any exception other than ExpectationNotMetError
   def after(state)
-    unless state.exception?
+    unless exception?
       print "."
     else
-      @states << state
-      print failure?(state) ? "F" : "E"
+      print failure? ? "F" : "E"
     end
   end
 
+  # Callback for the MSpec :finish event. Prints a description
+  # and backtrace for every exception that occurred while
+  # evaluating the examples.
   def finish
     print "\n"
     count = 0
-    @states.each do |state|
-      state.exceptions.each do |msg, exc|
-        outcome = failure?(state) ? "FAILED" : "ERROR"
-        print "\n#{count += 1})\n#{state.description} #{outcome}\n"
-        print "#{exc.class.name} occurred during: #{msg}\n" if msg
-        print message(exc)
-        print "\n"
-        print backtrace(exc)
-        print "\n"
-      end
+    @exceptions.each do |exc|
+      outcome = exc.failure? ? "FAILED" : "ERROR"
+      print "\n#{count += 1})\n#{exc.description} #{outcome}\n"
+      print exc.message, "\n"
+      print exc.backtrace, "\n"
     end
     print "\n#{@timer.format}\n\n#{@tally.format}\n"
   end
 
+  # A convenience method to allow printing to different outputs.
   def print(*args)
     @out.print(*args)
   end
-
-  def message(exc)
-    if exc.message.empty?
-      "<No message>"
-    elsif exc.class == ExpectationNotMetError
-      exc.message
-    else
-      "#{exc.class}: #{exc.message}"
-    end
-  end
-
-  def failure?(state)
-    state.exceptions.all? { |msg, exc| state.failure?(exc) }
-  end
-  private :failure?
-
-  def backtrace(exc)
-    begin
-      return exc.awesome_backtrace.show
-    rescue Exception
-      return exc.backtrace && exc.backtrace.join("\n")
-    end
-  end
-  private :backtrace
 end