mspec 1.0.0

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

@@ -0,0 +1,8 @@
+require 'mspec/expectations/expectations'
+require 'mspec/runner/formatters/dotted'
+
+class SummaryFormatter < DottedFormatter
+  def after(state)
+    @states << state if state.exception?
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'mspec/expectations/expectations'
+require 'mspec/runner/formatters/dotted'
+
+class UnitdiffFormatter < DottedFormatter
+  def finish
+    print "\n\n#{@timer.format}\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 "Exception occurred during: #{msg}\n" if msg
+        print((exc.message.empty? ? "<No message>" : exc.message) + ": \n")
+        print backtrace(exc)
+        print "\n"
+      end
+    end
+    print "\n#{@tally.format}\n"
+  end
+
+  def backtrace(exc)
+    exc.backtrace && exc.backtrace.join("\n")
+  end
+  private :backtrace
+end

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

@@ -0,0 +1,43 @@
+require 'mspec/expectations/expectations'
+require 'mspec/runner/formatters/dotted'
+
+class YamlFormatter < DottedFormatter
+  def initialize(out=nil)
+    @states = []
+    @out = $stdout
+
+    if out.nil?
+      @finish = $stdout
+    else
+      @finish = File.open out, "w"
+    end
+  end
+
+  def switch
+    @out = @finish
+  end
+
+  def finish
+    switch
+
+    print "---\n"
+    print "exceptions:\n"
+    @states.each do |state|
+      state.exceptions.each do |msg, exc|
+        outcome = failure?(state) ? "FAILED" : "ERROR"
+        str =  "#{state.description} #{outcome}\n"
+        str << "#{exc.class.name} occurred during: #{msg}\n" if msg
+        str << message(exc)
+        str << backtrace(exc)
+        print "- ", str.inspect, "\n"
+      end
+    end
+
+    print "time: ",         @timer.elapsed,              "\n"
+    print "files: ",        @tally.counter.files,        "\n"
+    print "examples: ",     @tally.counter.examples,     "\n"
+    print "expectations: ", @tally.counter.expectations, "\n"
+    print "failures: ",     @tally.counter.failures,     "\n"
+    print "errors: ",       @tally.counter.errors,       "\n"
+  end
+end

data/lib/mspec/runner/mspec.rb

@@ -0,0 +1,232 @@
+
+require 'mspec/runner/state'
+require 'mspec/runner/tag'
+require 'fileutils'
+
+module MSpec
+
+  @exit    = nil
+  @start   = nil
+  @enter   = nil
+  @before  = nil
+  @after   = nil
+  @leave   = nil
+  @finish  = nil
+  @exclude = nil
+  @include = nil
+  @leave   = nil
+  @mode    = nil
+  @load    = nil
+  @unload  = nil
+  @randomize   = nil
+  @expectation = nil
+
+  def self.describe(mod, msg=nil, &block)
+    stack.push RunState.new
+
+    current.describe(mod, msg, &block)
+    current.process
+
+    stack.pop
+  end
+
+  def self.process
+    actions :start
+    files
+    actions :finish
+  end
+
+  def self.files
+    return unless files = retrieve(:files)
+
+    shuffle files if randomize?
+    files.each do |file|
+      store :file, file
+      actions :load
+      protect("loading #{file}") { Kernel.load file }
+      actions :unload
+    end
+  end
+
+  def self.actions(action, *args)
+    actions = retrieve(action)
+    actions.each { |obj| obj.send action, *args } if actions
+  end
+
+  def self.register_exit(code)
+    store :exit, code
+  end
+
+  def self.exit_code
+    retrieve(:exit).to_i
+  end
+
+  def self.register_files(files)
+    store :files, files
+  end
+
+  def self.register_tags_path(path)
+    store :tags_path, path
+  end
+
+  def self.register_mode(mode)
+    store :mode, mode
+  end
+
+  def self.retrieve(symbol)
+    instance_variable_get :"@#{symbol}"
+  end
+
+  def self.store(symbol, value)
+    instance_variable_set :"@#{symbol}", value
+  end
+
+  # This method is used for registering actions that are
+  # run at particular points in the spec cycle:
+  #   :start        before any specs are run
+  #   :load         before a spec file is loaded
+  #   :enter        before a describe block is run
+  #   :before       before a single spec is run
+  #   :expectation  before a 'should', 'should_receive', etc.
+  #   :after        after a single spec is run
+  #   :leave        after a describe block is run
+  #   :unload       after a spec file is run
+  #   :finish       after all specs are run
+  #
+  # Objects registered as actions above should respond to
+  # a method of the same name. For example, if an object
+  # is registered as a :start action, it should respond to
+  # a #start method call.
+  #
+  # Additionally, there are two "action" lists for
+  # filtering specs:
+  #   :include  return true if the spec should be run
+  #   :exclude  return true if the spec should NOT be run
+  #
+  def self.register(symbol, action)
+    unless value = retrieve(symbol)
+      value = store symbol, []
+    end
+    value << action unless value.include? action
+  end
+
+  def self.unregister(symbol, action)
+    if value = retrieve(symbol)
+      value.delete action
+    end
+  end
+
+  def self.protect(msg, &block)
+    begin
+      instance_eval(&block)
+    rescue Exception => e
+      register_exit 1
+      if current and current.state
+        current.state.exceptions << [msg, e]
+      else
+        STDERR.write "\nAn exception occurred in #{msg}:\n#{e.class}: #{e.message.inspect}\n"
+        STDERR.write "#{e.backtrace.join "\n"}"
+      end
+    end
+  end
+
+  def self.stack
+    @stack ||= []
+  end
+
+  def self.current
+    stack.last
+  end
+
+  def self.verify_mode?
+    @mode == :verify
+  end
+
+  def self.report_mode?
+    @mode == :report
+  end
+
+  def self.pretend_mode?
+    @mode == :pretend
+  end
+
+  def self.randomize(flag=true)
+    @randomize = flag
+  end
+
+  def self.randomize?
+    @randomize == true
+  end
+
+  def self.shuffle(ary)
+    return if ary.empty?
+
+    size = ary.size
+    size.times do |i|
+      r = rand(size - i - 1)
+      ary[i], ary[r] = ary[r], ary[i]
+    end
+  end
+
+  def self.tags_path
+    retrieve(:tags_path) || "spec/tags"
+  end
+
+  def self.tags_file
+    path = tags_path
+    file = retrieve :file
+    tags_file = File.basename(file, '.*').sub(/_spec$/, '_tags') + '.txt'
+
+    m = file.match %r[.*spec/(.*)/.*_spec.rb]
+    path = File.join(path, m[1]) if m
+    File.join path, tags_file
+  end
+
+  def self.read_tags(*keys)
+    tags = []
+    file = tags_file
+    if File.exist? file
+      File.open(file, "r") do |f|
+        f.each_line do |line|
+          tag = SpecTag.new line.chomp
+          tags << tag if keys.include? tag.tag
+        end
+      end
+    end
+    tags
+  end
+
+  def self.write_tag(tag)
+    string = tag.to_s
+    file = tags_file
+    path = File.dirname file
+    FileUtils.mkdir_p(path) unless File.exist?(path)
+    if File.exist? file
+      File.open(file, "r") do |f|
+        f.each_line { |line| return false if line.chomp == string }
+      end
+    end
+    File.open(file, "a") { |f| f.puts string }
+    return true
+  end
+
+  def self.delete_tag(tag)
+    deleted = false
+    pattern = /#{tag.tag}.*#{Regexp.escape tag.description}/
+    file = tags_file
+    if File.exist? file
+      lines = IO.readlines(file)
+      File.open(file, "w") do |f|
+        lines.each do |line|
+          unless pattern =~ line.chomp
+            f.puts line
+          else
+            deleted = true
+          end
+        end
+      end
+      File.delete file unless File.size? file
+    end
+    return deleted
+  end
+end

data/lib/mspec/runner/object.rb

@@ -0,0 +1,20 @@
+class Object
+  def before(at=:each, &block)
+    MSpec.current.before at, &block
+  end
+
+  def after(at=:each, &block)
+    MSpec.current.after at, &block
+  end
+
+  def describe(mod, msg=nil, &block)
+    MSpec.describe mod, msg, &block
+  end
+
+  def it(msg, &block)
+    MSpec.current.it msg, &block
+  end
+
+  alias_method :context, :describe
+  alias_method :specify, :it
+end

data/lib/mspec/runner/shared.rb

@@ -0,0 +1,12 @@
+require 'mspec/runner/mspec'
+
+class Object
+  def shared(msg, &block)
+    MSpec.store msg.to_sym, block
+  end
+
+  def it_behaves_like(behavior, *args)
+    p = MSpec.retrieve behavior.to_sym
+    p[*args]
+  end
+end

data/lib/mspec/runner/state.rb

@@ -0,0 +1,116 @@
+require 'mspec/runner/mspec'
+
+class RunState
+  def initialize
+    @start = []
+    @before = []
+    @after = []
+    @finish = []
+    @spec = []
+  end
+
+  def state
+    @state
+  end
+
+  def before(at=:each, &block)
+    case at
+    when :each
+      @before << block
+    when :all
+      @start << block
+    end
+  end
+
+  def after(at=:each, &block)
+    case at
+    when :each
+      @after << block
+    when :all
+      @finish << block
+    end
+  end
+
+  def it(desc, &block)
+    state = SpecState.new @describe, desc
+    @spec << [desc, block, state] unless state.filtered?
+  end
+
+  def describe(mod, desc=nil, &block)
+    @describe = desc ? "#{mod} #{desc}" : mod.to_s
+    @block = block
+  end
+
+  def protect(what, blocks, check=true)
+    return if check and MSpec.pretend_mode?
+    Array(blocks).each { |block| MSpec.protect what, &block }
+  end
+
+  def process
+    protect @describe, @block, false
+    return unless @spec.any? { |desc, spec, state| state.unfiltered? }
+
+    MSpec.shuffle @spec if MSpec.randomize?
+    MSpec.actions :enter, @describe
+    protect "before :all", @start
+    @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 }
+      protect "Mock.cleanup", lambda { Mock.cleanup }
+      MSpec.actions :after, state
+      @state = nil
+    end
+    protect "after :all", @finish
+    MSpec.actions :leave
+  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