rhodes-framework 1.0.10 → 1.1.0

data/spec/app/mspec/runner.rb

@@ -0,0 +1,15 @@
+require 'mspec/mocks'
+require 'mspec/runner/mspec'
+require 'mspec/runner/context'
+require 'mspec/runner/example'
+require 'mspec/runner/object'
+require 'mspec/runner/formatters'
+require 'mspec/runner/actions'
+require 'mspec/runner/filters'
+require 'mspec/runner/shared'
+require 'mspec/runner/tag'
+
+def $stderr.write(str)
+  # The 'useless use of' warnings are a crime against OO.
+  str =~ /useless use of/ ? nil : super
+end

data/spec/app/mspec/runner/actions.rb

@@ -0,0 +1,8 @@
+require 'mspec/runner/actions/tally'
+require 'mspec/runner/actions/timer'
+require 'mspec/runner/actions/filter'
+require 'mspec/runner/actions/tag'
+require 'mspec/runner/actions/taglist'
+require 'mspec/runner/actions/tagpurge'
+require 'mspec/runner/actions/debug'
+require 'mspec/runner/actions/gdb'

data/spec/app/mspec/runner/actions/debug.rb

@@ -0,0 +1,17 @@
+require 'mspec/runner/actions/filter'
+
+class DebugAction < ActionFilter
+  def before(state)
+    Kernel.debugger if self === state.description
+  end
+
+  def register
+    super
+    MSpec.register :before, self
+  end
+
+  def unregister
+    super
+    MSpec.unregister :before, self
+  end
+end

data/spec/app/mspec/runner/actions/filter.rb

@@ -0,0 +1,40 @@
+require 'mspec/runner/filters/match'
+
+# ActionFilter is a base class for actions that are triggered by
+# specs that match the filter. The filter may be specified by
+# strings that match spec descriptions or by tags for strings
+# that match spec descriptions.
+#
+# Unlike TagFilter and RegexpFilter, ActionFilter instances do
+# not affect the specs that are run. The filter is only used to
+# trigger the action.
+
+class ActionFilter
+  def initialize(tags=nil, descs=nil)
+    @tags = Array(tags)
+    descs = Array(descs)
+    @sfilter = MatchFilter.new(nil, *descs) unless descs.empty?
+  end
+
+  def ===(string)
+    @sfilter === string or @tfilter === string
+  end
+
+  def load
+    @tfilter = nil
+    return if @tags.empty?
+
+    desc = MSpec.read_tags(@tags).map { |t| t.description }
+    return if desc.empty?
+
+    @tfilter = MatchFilter.new(nil, *desc)
+  end
+
+  def register
+    MSpec.register :load, self
+  end
+
+  def unregister
+    MSpec.unregister :load, self
+  end
+end

data/spec/app/mspec/runner/actions/gdb.rb

@@ -0,0 +1,17 @@
+require 'mspec/runner/actions/filter'
+
+class GdbAction < ActionFilter
+  def before(state)
+    Kernel.yield_gdb(true) if self === state.description
+  end
+
+  def register
+    super
+    MSpec.register :before, self
+  end
+
+  def unregister
+    super
+    MSpec.unregister :before, self
+  end
+end

data/spec/app/mspec/runner/actions/tag.rb

@@ -0,0 +1,133 @@
+require 'mspec/runner/actions/filter'
+
+# TagAction - Write tagged spec description string to a
+# tag file associated with each spec file.
+#
+# The action is triggered by specs whose descriptions
+# match the filter created with 'tags' and/or 'desc'
+#
+# The action fires in the :after event, after the spec
+# had been run. The action fires if the outcome of
+# running the spec matches 'outcome'.
+#
+# The arguments are:
+#
+#   action:  :add, :del
+#   outcome: :pass, :fail, :all
+#   tag:     the tag to create/delete
+#   comment: the comment to create
+#   tags:    zero or more tags to get matching
+#            spec description strings from
+#   desc:    zero or more strings to match the
+#            spec description strings
+
+class TagAction < ActionFilter
+  def initialize(action, outcome, tag, comment, tags=nil, descs=nil)
+    super tags, descs
+    @action = action
+    @outcome = outcome
+    @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 to true.
+  def exception(exception)
+    @exception = true
+  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?
+      tag = SpecTag.new
+      tag.tag = @tag
+      tag.comment = @comment
+      tag.description = state.description
+
+      case @action
+      when :add
+        changed = MSpec.write_tag tag
+      when :del
+        changed = MSpec.delete_tag tag
+      end
+
+      @report << state.description if changed
+    end
+  end
+
+  # 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 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
+    @report.join("\n") + "\n"
+  end
+  private :report
+
+  # Callback for the MSpec :finish event. Prints the actions
+  # performed while evaluating the examples.
+  def finish
+    case @action
+    when :add
+      if @report.empty?
+        print "\nTagAction: no specs were tagged with '#{@tag}'\n"
+      else
+        print "\nTagAction: specs tagged with '#{@tag}':\n\n"
+        print report
+      end
+    when :del
+      if @report.empty?
+        print "\nTagAction: no tags '#{@tag}' were deleted\n"
+      else
+        print "\nTagAction: tag '#{@tag}' deleted for specs:\n\n"
+        print report
+      end
+    end
+  end
+
+  def register
+    super
+    MSpec.register :before,    self
+    MSpec.register :exception, self
+    MSpec.register :after,     self
+    MSpec.register :finish,    self
+  end
+
+  def unregister
+    super
+    MSpec.unregister :before,    self
+    MSpec.unregister :exception, self
+    MSpec.unregister :after,     self
+    MSpec.unregister :finish,    self
+  end
+end

data/spec/app/mspec/runner/actions/taglist.rb

@@ -0,0 +1,56 @@
+require 'mspec/runner/actions/filter'
+
+# TagListAction - prints out the descriptions for any specs
+# tagged with +tags+. If +tags+ is an empty list, prints out
+# descriptions for any specs that are tagged.
+class TagListAction
+  def initialize(tags=nil)
+    @tags = tags.nil? || tags.empty? ? nil : Array(tags)
+    @filter = nil
+  end
+
+  # Returns true. This enables us to match any tag when loading
+  # tags from the file.
+  def include?(arg)
+    true
+  end
+
+  # Returns true if any tagged descriptions matches +string+.
+  def ===(string)
+    @filter === string
+  end
+
+  # Prints a banner about matching tagged specs.
+  def start
+    if @tags
+      print "\nListing specs tagged with #{@tags.map { |t| "'#{t}'" }.join(", ") }\n\n"
+    else
+      print "\nListing all tagged specs\n\n"
+    end
+  end
+
+  # Creates a MatchFilter for specific tags or for all tags.
+  def load
+    @filter = nil
+    desc = MSpec.read_tags(@tags || self).map { |t| t.description }
+    @filter = MatchFilter.new(nil, *desc) unless desc.empty?
+  end
+
+  # Prints the spec description if it matches the filter.
+  def after(state)
+    return unless self === state.description
+    print state.description, "\n"
+  end
+
+  def register
+    MSpec.register :start, self
+    MSpec.register :load,  self
+    MSpec.register :after, self
+  end
+
+  def unregister
+    MSpec.unregister :start, self
+    MSpec.unregister :load,  self
+    MSpec.unregister :after, self
+  end
+end

data/spec/app/mspec/runner/actions/tagpurge.rb

@@ -0,0 +1,56 @@
+require 'mspec/runner/actions/filter'
+require 'mspec/runner/actions/taglist'
+
+# TagPurgeAction - removes all tags not matching any spec
+# descriptions.
+class TagPurgeAction < TagListAction
+  attr_reader :matching
+
+  def initialize
+    @matching = []
+    @filter   = nil
+    @tags     = nil
+  end
+
+  # Prints a banner about purging tags.
+  def start
+    print "\nRemoving tags not matching any specs\n\n"
+  end
+
+  # Creates a MatchFilter for all tags.
+  def load
+    @filter = nil
+    @tags = MSpec.read_tags self
+    desc = @tags.map { |t| t.description }
+    @filter = MatchFilter.new(nil, *desc) unless desc.empty?
+  end
+
+  # Saves any matching tags
+  def after(state)
+    @matching << state.description if self === state.description
+  end
+
+  # Rewrites any matching tags. Prints non-matching tags.
+  # Deletes the tag file if there were no tags (this cleans
+  # up empty or malformed tag files).
+  def unload
+    if @filter
+      matched = @tags.select { |t| @matching.any? { |s| s == t.description } }
+      MSpec.write_tags matched
+
+      (@tags - matched).each { |t| print t.description, "\n" }
+    else
+      MSpec.delete_tags
+    end
+  end
+
+  def register
+    super
+    MSpec.register :unload, self
+  end
+
+  def unregister
+    super
+    MSpec.unregister :unload, self
+  end
+end

data/spec/app/mspec/runner/actions/tally.rb

@@ -0,0 +1,116 @@
+class Tally
+  attr_accessor :files, :examples, :expectations, :failures, :errors, :guards
+
+  def initialize
+    @files = @examples = @expectations = @failures = @errors = @guards = 0
+  end
+
+  def files!(add=1)
+    @files += add
+  end
+
+  def examples!(add=1)
+    @examples += add
+  end
+
+  def expectations!(add=1)
+    @expectations += add
+  end
+
+  def failures!(add=1)
+    @failures += add
+  end
+
+  def errors!(add=1)
+    @errors += add
+  end
+
+  def guards!(add=1)
+    @guards += add
+  end
+
+  def file
+    pluralize files, "file"
+  end
+
+  def example
+    pluralize examples, "example"
+  end
+
+  def expectation
+    pluralize expectations, "expectation"
+  end
+
+  def failure
+    pluralize failures, "failure"
+  end
+
+  def error
+    pluralize errors, "error"
+  end
+
+  def guard
+    pluralize guards, "guard"
+  end
+
+  def format
+    results = [ file, example, expectation, failure, error ]
+    results << guard if [:report, :report_on, :verify].any? { |m| MSpec.mode? m }
+    results.join(", ")
+  end
+
+  alias_method :to_s, :format
+
+  def pluralize(count, singular)
+    "#{count} #{singular}#{'s' unless count == 1}"
+  end
+  private :pluralize
+end
+
+class TallyAction
+  attr_reader :counter
+
+  def initialize
+    @counter = Tally.new
+  end
+
+  def register
+    MSpec.register :load,        self
+    MSpec.register :exception,   self
+    MSpec.register :example,     self
+    MSpec.register :expectation, self
+  end
+
+  def unregister
+    MSpec.unregister :load,        self
+    MSpec.unregister :exception,   self
+    MSpec.unregister :example,     self
+    MSpec.unregister :expectation, self
+  end
+
+  def load
+    @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 :example event. Increments the tally
+  # of examples.
+  def example(state, block)
+    @counter.examples!
+  end
+
+  def format
+    @counter.format
+  end
+end