rhodes-framework 1.0.10 → 1.1.0

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

@@ -0,0 +1,22 @@
+class TimerAction
+  def register
+    MSpec.register :start, self
+    MSpec.register :finish, self
+  end
+
+  def start
+    @start = Time.now
+  end
+
+  def finish
+    @stop = Time.now
+  end
+
+  def elapsed
+    @stop - @start
+  end
+
+  def format
+    "Finished in %f seconds" % elapsed
+  end
+end

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

@@ -0,0 +1,188 @@
+# 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
+  attr_reader :state, :parent, :parents, :children, :examples, :to_s
+
+  def initialize(mod, options=nil)
+    @to_s = mod.to_s
+    if options.is_a? Hash
+      @options = options
+    else
+      @to_s += "#{".:#".include?(options[0,1]) ? "" : " "}#{options}" if options
+      @options = { }
+    end
+    @options[:shared] ||= false
+
+    @parsed   = false
+    @before   = { :all => [], :each => [] }
+    @after    = { :all => [], :each => [] }
+    @pre      = {}
+    @post     = {}
+    @examples = []
+    @parent   = nil
+    @parents  = [self]
+    @children = []
+
+    @mock_verify         = lambda { Mock.verify_count }
+    @mock_cleanup        = lambda { Mock.cleanup }
+    @expectation_missing = lambda { raise ExpectationNotFoundError }
+  end
+
+  # Returns true if this is a shared +ContextState+. Essentially, when
+  # created with: describe "Something", :shared => true { ... }
+  def shared?
+    return @options[:shared]
+  end
+
+  # Set the parent (enclosing) +ContextState+ for this state. Creates
+  # the +parents+ list.
+  def parent=(parent)
+    @description = nil
+    @parent = parent
+    parent.child self if parent and not shared?
+
+    state = parent
+    while state
+      parents.unshift state
+      state = state.parent
+    end
+  end
+
+  # Add the ContextState instance +child+ to the list of nested
+  # describe blocks.
+  def child(child)
+    @children << child
+  end
+
+  # Returns a list of all before(+what+) blocks from self and any parents.
+  def pre(what)
+    @pre[what] ||= parents.inject([]) { |l, s| l.push(*s.before(what)) }
+  end
+
+  # Returns a list of all after(+what+) blocks from self and any parents.
+  # The list is in reverse order. In other words, the blocks defined in
+  # inner describes are in the list before those defined in outer describes,
+  # and in a particular describe block those defined later are in the list
+  # before those defined earlier.
+  def post(what)
+    @post[what] ||= parents.inject([]) { |l, s| l.unshift(*s.after(what)) }
+  end
+
+  # Records before(:each) and before(:all) blocks.
+  def before(what, &block)
+    return if MSpec.guarded?
+    block ? @before[what].push(block) : @before[what]
+  end
+
+  # Records after(:each) and after(:all) blocks.
+  def after(what, &block)
+    return if MSpec.guarded?
+    block ? @after[what].unshift(block) : @after[what]
+  end
+
+  # Creates an ExampleState instance for the block and stores it
+  # in a list of examples to evaluate unless the example is filtered.
+  def it(desc, &block)
+    puts "- it \"#{desc}\""
+    example = ExampleState.new(self, desc, block)
+    MSpec.actions :add, example
+    return if MSpec.guarded?
+    @examples << example
+  end
+
+  # Evaluates the block and resets the toplevel +ContextState+ to #parent.
+  def describe(&block)
+    puts "describe \"#{self.to_s}\""
+    @parsed = protect @to_s, block, false
+    MSpec.register_current parent
+    MSpec.register_shared self if shared?
+  end
+
+  # Returns a description string generated from self and all parents
+  def description
+    @description ||= parents.map { |p| p.to_s }.join(" ")
+  end
+
+  # Injects the before/after blocks and examples from the shared
+  # describe block into this +ContextState+ instance.
+  def it_should_behave_like(desc)
+    return if MSpec.guarded?
+
+    unless state = MSpec.retrieve_shared(desc)
+      raise Exception, "Unable to find shared 'describe' for #{desc}"
+    end
+
+    state.examples.each { |ex| ex.context = self; @examples << ex }
+    state.before(:all).each { |b| before :all, &b }
+    state.before(:each).each { |b| before :each, &b }
+    state.after(:each).each { |b| after :each, &b }
+    state.after(:all).each { |b| after :all, &b }
+  end
+
+  # Evaluates each block in +blocks+ using the +MSpec.protect+ method
+  # so that exceptions are handled and tallied. Returns true and does
+  # NOT evaluate any blocks if +check+ is true and
+  # <tt>MSpec.mode?(:pretend)</tt> is true.
+  def protect(what, blocks, check=true)
+    return true if check and MSpec.mode? :pretend
+    Array(blocks).all? { |block| MSpec.protect what, &block }
+  end
+
+  # Removes filtered examples. Returns true if there are examples
+  # left to evaluate.
+  def filter_examples
+    @examples.reject! { |ex| ex.filtered? }
+    not @examples.empty?
+  end
+
+  # Evaluates the examples in a +ContextState+. Invokes the MSpec events
+  # for :enter, :before, :after, :leave.
+  def process
+    MSpec.register_current self
+
+    if @parsed and filter_examples
+      MSpec.shuffle @examples if MSpec.randomize?
+      MSpec.actions :enter, description
+
+      if protect "before :all", pre(:all)
+        @examples.each do |state|
+          @state  = state
+          example = state.example
+          MSpec.actions :before, state
+
+          if protect "before :each", pre(:each)
+            MSpec.clear_expectations
+            if example
+              passed = protect nil, example
+              MSpec.actions :example, state, example
+              protect nil, @expectation_missing unless MSpec.expectation? or not passed
+            end
+            protect "after :each", post(:each)
+            protect "Mock.verify_count", @mock_verify
+          end
+
+          protect "Mock.cleanup", @mock_cleanup
+          MSpec.actions :after, state
+          @state = nil
+        end
+        protect "after :all", post(:all)
+      else
+        protect "Mock.cleanup", @mock_cleanup
+      end
+
+      MSpec.actions :leave
+    end
+
+    MSpec.register_current nil
+    children.each { |child| child.process }
+  end
+end

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

@@ -0,0 +1,34 @@
+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
+  attr_reader   :context, :it, :example
+
+  def initialize(context, it, example=nil)
+    @context  = context
+    @it       = it
+    @example  = example
+  end
+
+  def context=(context)
+    @description = nil
+    @context = context
+  end
+
+  def describe
+    @context.description
+  end
+
+  def description
+    @description ||= "#{describe} #{@it}"
+  end
+
+  def filtered?
+    incl = MSpec.retrieve(:include) || []
+    excl = MSpec.retrieve(:exclude) || []
+    included   = incl.empty? || incl.any? { |f| f === description }
+    included &&= excl.empty? || !excl.any? { |f| f === description }
+    not included
+  end
+end

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

@@ -0,0 +1,43 @@
+class ExceptionState
+  attr_reader :description, :describe, :it, :exception
+
+  PATH = /#{File.expand_path(File.dirname(__FILE__) + '/../../..')}/
+
+  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?
+    [ExpectationNotMetError, ExpectationNotFoundError].any? { |e| @exception.is_a? e }
+  end
+
+  def message
+    if @exception.message.empty?
+      "<No message>"
+    elsif @exception.class == ExpectationNotMetError ||
+          @exception.class == ExpectationNotFoundError
+      @exception.message
+    else
+      "#{@exception.class}: #{@exception.message}"
+    end
+  end
+
+  def backtrace
+    begin
+      bt = @exception.awesome_backtrace.show.split "\n"
+    rescue Exception
+      bt = @exception.backtrace || []
+    end
+    bt.reject { |line| PATH =~ line }.join("\n")
+  end
+end

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

@@ -0,0 +1,4 @@
+require 'mspec/runner/filters/match'
+require 'mspec/runner/filters/regexp'
+require 'mspec/runner/filters/tag'
+require 'mspec/runner/filters/profile'

data/spec/app/mspec/runner/filters/match.rb

@@ -0,0 +1,22 @@
+class MatchFilter
+  def initialize(what, *strings)
+    @what = what
+    @descriptions = to_regexp(*strings)
+  end
+
+  def to_regexp(*strings)
+    strings.map { |str| Regexp.new Regexp.escape(str) }
+  end
+
+  def ===(string)
+    @descriptions.any? { |d| d === string }
+  end
+
+  def register
+    MSpec.register @what, self
+  end
+
+  def unregister
+    MSpec.unregister @what, self
+  end
+end

data/spec/app/mspec/runner/filters/profile.rb

@@ -0,0 +1,54 @@
+class ProfileFilter
+  def initialize(what, *files)
+    @what = what
+    @methods = load(*files)
+    @pattern = /([^ .#]+[.#])([^ ]+)/
+  end
+
+  def find(name)
+    return name if File.exist?(File.expand_path(name))
+
+    ["spec/profiles", "spec", "profiles", "."].each do |dir|
+      file = File.join dir, name
+      return file if File.exist? file
+    end
+  end
+
+  def parse(file)
+    pattern = /(\S+):\s*/
+    key = ""
+    file.inject(Hash.new { |h,k| h[k] = [] }) do |hash, line|
+      line.chomp!
+      if line[0,2] == "- "
+        hash[key] << line[2..-1].gsub(/[ '"]/, "")
+      elsif m = pattern.match(line)
+        key = m[1]
+      end
+      hash
+    end
+  end
+
+  def load(*files)
+    files.inject({}) do |hash, file|
+      next hash unless name = find(file)
+
+      File.open name, "r" do |f|
+        hash.merge parse(f)
+      end
+    end
+  end
+
+  def ===(string)
+    return false unless m = @pattern.match(string)
+    return false unless l = @methods[m[1]]
+    l.include? m[2]
+  end
+
+  def register
+    MSpec.register @what, self
+  end
+
+  def unregister
+    MSpec.unregister @what, self
+  end
+end

data/spec/app/mspec/runner/filters/regexp.rb

@@ -0,0 +1,7 @@
+require 'mspec/runner/filters/match'
+
+class RegexpFilter < MatchFilter
+  def to_regexp(*strings)
+    strings.map { |str| Regexp.new str }
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'mspec/runner/filters/match'
+
+class TagFilter
+  def initialize(what, *tags)
+    @what = what
+    @tags = tags
+  end
+
+  def load
+    desc = MSpec.read_tags(@tags).map { |t| t.description }
+
+    @filter = MatchFilter.new(@what, *desc)
+    @filter.register
+  end
+
+  def unload
+    @filter.unregister if @filter
+  end
+
+  def register
+    MSpec.register :load, self
+    MSpec.register :unload, self
+  end
+
+  def unregister
+    MSpec.unregister :load, self
+    MSpec.unregister :unload, self
+  end
+end

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

@@ -0,0 +1,10 @@
+require 'mspec/runner/formatters/describe'
+require 'mspec/runner/formatters/dotted'
+require 'mspec/runner/formatters/file'
+require 'mspec/runner/formatters/specdoc'
+require 'mspec/runner/formatters/html'
+require 'mspec/runner/formatters/summary'
+require 'mspec/runner/formatters/unit'
+require 'mspec/runner/formatters/spinner'
+require 'mspec/runner/formatters/method'
+require 'mspec/runner/formatters/yaml'

data/spec/app/mspec/runner/formatters/describe.rb

@@ -0,0 +1,24 @@
+require 'mspec/runner/formatters/dotted'
+require 'mspec/runner/actions/tally'
+
+class DescribeFormatter < DottedFormatter
+  # Callback for the MSpec :finish event. Prints a summary of
+  # the number of errors and failures for each +describe+ block.
+  def finish
+    describes = Hash.new { |h,k| h[k] = Tally.new }
+
+    @exceptions.each do |exc|
+      desc = describes[exc.describe]
+      exc.failure? ? desc.failures! : desc.errors!
+    end
+
+    print "\n"
+    describes.each do |d, t|
+      text = d.size > 40 ? "#{d[0,37]}..." : d.ljust(40)
+      print "\n#{text} #{t.failure}, #{t.error}"
+    end
+    print "\n" unless describes.empty?
+
+    print "\n#{@timer.format}\n\n#{@tally.format}\n"
+  end
+end