mspec 1.0.0

data/lib/mspec/matchers/raise_error.rb

@@ -0,0 +1,48 @@
+class RaiseErrorMatcher
+  def initialize(exception, message, &block)
+    @exception = exception
+    @message = message
+    @block = block
+  end
+
+  def matches?(proc)
+    proc.call
+    return false
+  rescue Exception => @actual
+    return false unless @exception === @actual
+    if @message then
+      case @message
+      when String then
+        return false if @message != @actual.message
+      when Regexp then
+        return false if @message !~ @actual.message
+      end
+    end
+
+    @block[@actual] if @block
+
+    return true
+  end
+
+  def failure_message
+    message = ["Expected #{@exception}#{%[ (#{@message})] if @message}"]
+
+    if @actual then
+      message << "but got #{@actual.class}#{%[ (#{@actual.message})] if @actual.message}"
+    else
+      message << "but no exception was raised"
+    end
+
+    message
+  end
+
+  def negative_failure_message
+    ["Expected to not get #{@exception}#{%[ (#{@message})] if @message}", ""]
+  end
+end
+
+class Object
+  def raise_error(exception=Exception, message=nil, &block)
+    RaiseErrorMatcher.new(exception, message, &block)
+  end
+end

data/lib/mspec/mocks.rb

@@ -0,0 +1,3 @@
+require 'mspec/mocks/mock'
+require 'mspec/mocks/proxy'
+require 'mspec/mocks/object'

data/lib/mspec/mocks/mock.rb

@@ -0,0 +1,123 @@
+require 'mspec/expectations/expectations'
+
+module Mock
+  def self.reset
+    @expects = nil
+  end
+
+  def self.expects
+    @expects ||= Hash.new { |h,k| h[k] = [] }
+  end
+
+  def self.replaced_name(sym)
+    :"__ms_#{sym}__"
+  end
+
+  def self.install_method(obj, sym, type = :mock)
+    meta = class << obj; self; end
+
+    if (sym.to_sym == :respond_to? or obj.respond_to?(sym)) and !meta.instance_methods.include?(replaced_name(sym).to_s)
+      meta.__send__ :alias_method, replaced_name(sym), sym.to_sym
+    end
+
+    meta.class_eval <<-END
+      def #{sym}(*args, &block)
+        Mock.verify_call self, :#{sym}, *args, &block
+      end
+    END
+
+    MSpec.actions :expectation, MSpec.current.state
+
+    proxy = MockProxy.new
+
+    if type == :stub
+      expects[[obj, sym]] << proxy
+      proxy.at_least(0)
+    else
+      expects[[obj, sym]].unshift proxy
+      proxy.exactly(1)
+    end
+  end
+
+  def self.verify_count
+    expects.each do |key, proxies|
+      obj, sym = key.first, key.last
+
+      proxies.each do |proxy|
+        qualifier, count = proxy.count
+        pass = case qualifier
+        when :at_least
+          proxy.calls >= count
+        when :at_most
+          proxy.calls <= count
+        when :exactly
+          proxy.calls == count
+        else
+          false
+        end
+        unless pass
+          Expectation.fail_with("Mock #{obj.inspect}\nexpected to receive #{sym} #{qualifier.to_s.sub('_', ' ')} #{count} times",
+                                "but received it #{proxy.calls} times")
+        end
+      end
+    end
+  end
+
+  def self.verify_call(obj, sym, *args, &block)
+    compare = *args
+
+    expects[[obj, sym]].each do |proxy|
+      pass = case proxy.arguments
+      when :any_args
+        true
+      when :no_args
+        compare.nil?
+      else
+        proxy.arguments == compare
+      end
+      
+      if proxy.yielding?
+        if block
+          proxy.yielding.each do |args_to_yield|
+            if block.arity == -1 || block.arity == args_to_yield.size
+              block.call(*args_to_yield)
+            else
+              Expectation.fail_with("Mock #{obj.inspect} asked to yield |#{proxy.yielding.join(', ')}| on #{sym}\n",
+                                    "but a block with arity #{block.arity} was passed")
+            end
+          end
+        else
+          Expectation.fail_with("Mock #{obj.inspect} asked to yield |[#{proxy.yielding.join('], [')}]| on #{sym}\n",
+                                "but no block was passed")
+        end
+      end
+
+      if pass
+        proxy.called
+        return proxy.returning
+      end
+    end
+
+    if sym.to_sym == :respond_to?
+      return obj.__send__(replaced_name(sym), compare)
+    else
+      Expectation.fail_with("Mock #{obj.inspect}: method #{sym}\n",
+                            "called with unexpected arguments (#{Array(compare).join(' ')})")
+    end
+  end
+
+  def self.cleanup
+    expects.keys.each do |obj, sym|
+      meta = class << obj; self; end
+
+      replaced = replaced_name(sym)
+      if meta.instance_methods.include?(replaced.to_s)
+        meta.__send__ :alias_method, sym.to_sym, replaced
+        meta.__send__ :remove_method, replaced
+      else
+        meta.__send__ :remove_method, sym.to_sym
+      end
+    end
+    reset
+  end
+end

data/lib/mspec/mocks/object.rb

@@ -0,0 +1,28 @@
+require 'mspec/mocks/proxy'
+
+class MockObject
+  def initialize(name)
+    @name = name
+  end
+end
+
+class Object
+  def stub!(sym)
+    Mock.install_method self, sym, :stub
+  end
+  
+  def should_receive(sym)
+    Mock.install_method self, sym
+  end
+
+  def should_not_receive(sym)
+    proxy = Mock.install_method self, sym
+    proxy.exactly(0).times
+    # return nil so that further chained calls will raise
+    nil
+  end
+
+  def mock(name)
+    MockObject.new(name)
+  end
+end

data/lib/mspec/mocks/proxy.rb

@@ -0,0 +1,112 @@
+class MockProxy
+  def initialize
+    @multiple_returns = nil
+    @returning = nil
+    @yielding  = []
+    @arguments = :any_args
+  end
+
+  def count
+    @count ||= [:exactly, 0]
+  end
+
+  def arguments
+    @arguments
+  end
+
+  def returning
+    if @multiple_returns
+      if @returning.size == 1
+        @multiple_returns = false
+        return @returning = @returning.shift
+      end
+      return @returning.shift
+    end
+    @returning
+  end
+
+  def times
+    self
+  end
+
+  def calls
+    @calls ||= 0
+  end
+
+  def called
+    @calls = calls + 1
+  end
+
+  def exactly(n)
+    @count = [:exactly, n_times(n)]
+    self
+  end
+
+  def at_least(n)
+    @count = [:at_least, n_times(n)]
+    self
+  end
+
+  def at_most(n)
+    @count = [:at_most, n_times(n)]
+    self
+  end
+
+  def once
+    exactly 1
+  end
+
+  def twice
+    exactly 2
+  end
+
+  def any_number_of_times
+    at_least 0
+  end
+
+  def with(*args)
+    raise ArgumentError, "you must specify the expected arguments" if args.empty?
+    @arguments = *args
+    self
+  end
+
+  def and_return(*args)
+    case args.size
+    when 0
+      @returning = nil
+    when 1
+      @returning = args[0]
+    else
+      @multiple_returns = true
+      @returning = args
+      count[1] = args.size if count[1] < args.size
+    end
+    self
+  end
+
+  def and_yield(*args)
+    @yielding << args
+    self
+  end
+  
+  def yielding
+    @yielding
+  end
+  
+  def yielding?
+    !@yielding.empty?
+  end
+
+  private
+
+  def n_times(n)
+    case n
+    when :once
+      1
+    when :twice
+      2
+    else
+      Integer n
+    end
+  end
+end

data/lib/mspec/runner.rb

@@ -0,0 +1,13 @@
+require 'mspec/mocks'
+require 'mspec/runner/mspec'
+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/lib/mspec/runner/actions.rb

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

data/lib/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/lib/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/lib/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/lib/mspec/runner/actions/tag.rb

@@ -0,0 +1,97 @@
+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 = []
+  end
+
+  def ===(string)
+    return true unless @sfilter or @tfilter
+    @sfilter === string or @tfilter === string
+  end
+
+  def after(state)
+    if self === state.description and outcome? state
+      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
+
+  def outcome?(state)
+    @outcome == :all or
+        (@outcome == :pass and not state.exception?) or
+        (@outcome == :fail and state.exception?)
+  end
+
+  def report
+    @report.join("\n") + "\n"
+  end
+  private :report
+
+  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 :after, self
+    MSpec.register :finish, self
+  end
+
+  def unregister
+    super
+    MSpec.unregister :after, self
+  end
+end