mspec 1.0.0

data/lib/mspec/matchers/be_ancestor_of.rb

@@ -0,0 +1,24 @@
+class BeAncestorOfMatcher
+  def initialize(expected)
+    @expected = expected
+  end
+
+  def matches?(actual)
+    @actual = actual
+    @expected.ancestors.include? @actual
+  end
+
+  def failure_message
+    ["Expected #{@actual}", "to be an ancestor of #{@expected}"]
+  end
+
+  def negative_failure_message
+    ["Expected #{@actual}", "not to be an ancestor of #{@expected}"]
+  end
+end
+
+class Object
+  def be_ancestor_of(expected)
+    BeAncestorOfMatcher.new(expected)
+  end
+end

data/lib/mspec/matchers/be_close.rb

@@ -0,0 +1,27 @@
+TOLERANCE = 0.00003 unless Object.const_defined?(:TOLERANCE)
+
+class BeCloseMatcher
+  def initialize(expected, tolerance)
+    @expected = expected
+    @tolerance = tolerance
+  end
+
+  def matches?(actual)
+    @actual = actual
+    (@actual - @expected).abs < @tolerance
+  end
+
+  def failure_message
+    ["Expected #{@expected}", "to be within +/- #{@tolerance} of #{@actual}"]
+  end
+
+  def negative_failure_message
+    ["Expected #{@expected}", "not to be within +/- #{@tolerance} of #{@actual}"]
+  end
+end
+
+class Object
+  def be_close(expected, tolerance)
+    BeCloseMatcher.new(expected, tolerance)
+  end
+end

data/lib/mspec/matchers/be_empty.rb

@@ -0,0 +1,20 @@
+class BeEmptyMatcher
+  def matches?(actual)
+    @actual = actual
+    @actual.empty?
+  end
+
+  def failure_message
+    ["Expected #{@actual.inspect}", "to be empty"]
+  end
+
+  def negative_failure_message
+    ["Expected #{@actual.inspect}", "not to be empty"]
+  end
+end
+
+class Object
+  def be_empty
+    BeEmptyMatcher.new
+  end
+end

data/lib/mspec/matchers/be_false.rb

@@ -0,0 +1,20 @@
+class BeFalseMatcher
+  def matches?(actual)
+    @actual = actual
+    @actual == false
+  end
+
+  def failure_message
+    ["Expected #{@actual.inspect}", "to be false"]
+  end
+  
+  def negative_failure_message
+    ["Expected #{@actual.inspect}", "not to be false"]
+  end
+end
+
+class Object
+  def be_false
+    BeFalseMatcher.new
+  end
+end

data/lib/mspec/matchers/be_kind_of.rb

@@ -0,0 +1,24 @@
+class BeKindOfMatcher
+  def initialize(expected)
+    @expected = expected
+  end
+
+  def matches?(actual)
+    @actual = actual
+    @actual.is_a?(@expected)
+  end
+
+  def failure_message
+    ["Expected #{@actual.inspect} (#{@actual.class})", "to be kind of #{@expected}"]
+  end
+
+  def negative_failure_message
+    ["Expected #{@actual.inspect} (#{@actual.class})", "not to be kind of #{@expected}"]
+  end
+end
+
+class Object
+  def be_kind_of(expected)
+    BeKindOfMatcher.new(expected)
+  end
+end

data/lib/mspec/matchers/be_nil.rb

@@ -0,0 +1,20 @@
+class BeNilMatcher
+  def matches?(actual)
+    @actual = actual
+    @actual.nil?
+  end
+
+  def failure_message
+    ["Expected #{@actual.inspect}", "to be nil"]
+  end
+  
+  def negative_failure_message
+    ["Expected #{@actual.inspect}", "not to be nil"]
+  end
+end
+
+class Object
+  def be_nil
+    BeNilMatcher.new
+  end
+end

data/lib/mspec/matchers/be_true.rb

@@ -0,0 +1,20 @@
+class BeTrueMatcher
+  def matches?(actual)
+    @actual = actual
+    @actual == true
+  end
+
+  def failure_message
+    ["Expected #{@actual.inspect}", "to be true"]
+  end
+  
+  def negative_failure_message
+    ["Expected #{@actual.inspect}", "not to be true"]
+  end
+end
+
+class Object
+  def be_true
+    BeTrueMatcher.new
+  end
+end

data/lib/mspec/matchers/complain.rb

@@ -0,0 +1,56 @@
+require 'mspec/helpers/io'
+
+class ComplainMatcher
+  def initialize(complaint)
+    @complaint = complaint
+  end
+
+  def matches?(proc)
+    @saved_err = $stderr
+    @stderr = $stderr = IOStub.new
+    @verbose = $VERBOSE
+    $VERBOSE = false
+
+    proc.call
+
+    unless @complaint.nil?
+      case @complaint
+      when Regexp
+        return false unless $stderr =~ @complaint
+      else
+        return false unless $stderr == @complaint
+      end
+    end
+
+    return $stderr.empty? ? false : true
+  ensure
+    $VERBOSE = @verbose
+    $stderr = @saved_err
+  end
+
+  def failure_message
+    if @complaint.nil?
+      ["Expected a warning", "but received none"]
+    elsif @complaint.kind_of? Regexp
+      ["Expected warning to match:", @complaint.inspect]
+    else
+      ["Expected warning: #{@complaint.inspect}", "but got: #{@stderr.chomp.inspect}"]
+    end
+  end
+
+  def negative_failure_message
+    if @complaint.nil?
+      ["Unexpected warning: ", @stderr.chomp.inspect]
+    elsif @complaint.kind_of? Regexp
+      ["Expected warning not to match:", @complaint.inspect]
+    else
+      ["Expected warning: #{@complaint.inspect}", "but got: #{@stderr.chomp.inspect}"]
+    end
+  end
+end
+
+class Object
+  def complain(complaint=nil)
+    ComplainMatcher.new(complaint)
+  end
+end

data/lib/mspec/matchers/eql.rb

@@ -0,0 +1,26 @@
+class EqlMatcher
+  def initialize(expected)
+    @expected = expected
+  end
+
+  def matches?(actual)
+    @actual = actual
+    @actual.eql?(@expected)
+  end
+
+  def failure_message
+    ["Expected #{@actual.pretty_inspect}",
+     "to have same value and type as #{@expected.pretty_inspect}"]
+  end
+
+  def negative_failure_message
+    ["Expected #{@actual.pretty_inspect}",
+     "not to have same value or type as #{@expected.pretty_inspect}"]
+  end
+end
+
+class Object
+  def eql(expected)
+    EqlMatcher.new(expected)
+  end
+end

data/lib/mspec/matchers/equal.rb

@@ -0,0 +1,26 @@
+class EqualMatcher
+  def initialize(expected)
+    @expected = expected
+  end
+
+  def matches?(actual)
+    @actual = actual
+    @actual.equal?(@expected)
+  end
+
+  def failure_message
+    ["Expected #{@actual.pretty_inspect}",
+     "to be identical to #{@expected.pretty_inspect}"]
+  end
+
+  def negative_failure_message
+    ["Expected #{@actual.pretty_inspect}",
+     "not to be identical to #{@expected.pretty_inspect}"]
+  end
+end
+
+class Object
+  def equal(expected)
+    EqualMatcher.new(expected)
+  end
+end

data/lib/mspec/matchers/equal_utf16.rb

@@ -0,0 +1,34 @@
+class EqualUtf16Matcher
+  def initialize(expected)
+    @expected = expected
+  end
+
+  def matches?(actual)
+    @actual = actual
+    @actual == @expected || @actual == expected_swapped
+  end
+
+  def expected_swapped
+    if @expected.respond_to?(:to_str)
+      @expected_swapped ||= @expected.to_str.gsub(/(.)(.)/, '\2\1')
+    else
+      @expected_swapped ||= @expected.collect { |s| s.to_str.gsub(/(.)(.)/, '\2\1') }
+    end
+  end
+
+  def failure_message
+    ["Expected #{@actual.pretty_inspect}",
+     "to equal #{@expected.pretty_inspect} or #{expected_swapped.pretty_inspect}"]
+  end
+
+  def negative_failure_message
+    ["Expected #{@actual.pretty_inspect}",
+     "not to equal #{@expected.pretty_inspect} nor #{expected_swapped.pretty_inspect}"]
+  end
+end
+
+class Object
+  def equal_utf16(expected)
+    EqualUtf16Matcher.new(expected)
+  end
+end

data/lib/mspec/matchers/include.rb

@@ -0,0 +1,32 @@
+class IncludeMatcher
+  def initialize(*expected)
+    @expected = expected
+  end
+
+  def matches?(actual)
+    @actual = actual
+    @expected.each do |e|
+      @element = e
+      unless @actual.include?(e)
+        return false
+      end
+    end
+    return true
+  end
+
+  def failure_message
+    ["Expected #{@actual.inspect}", "to include #{@element.inspect}"]
+  end
+
+  def negative_failure_message
+    ["Expected #{@actual.inspect}", "not to include #{@element.inspect}"]
+  end
+end
+
+# Cannot override #include at the toplevel in MRI
+module MSpec
+  def include(*expected)
+    IncludeMatcher.new(*expected)
+  end
+  module_function :include
+end

data/lib/mspec/matchers/output.rb

@@ -0,0 +1,67 @@
+require 'mspec/helpers/io'
+
+class OutputMatcher
+  def initialize(stdout, stderr)
+    @out = stdout
+    @err = stderr
+  end
+
+  def matches?(proc)
+    @saved_out = $stdout
+    @saved_err = $stderr
+    @stdout = $stdout = IOStub.new
+    @stderr = $stderr = IOStub.new
+
+    proc.call
+
+    unless @out.nil?
+      case @out
+      when Regexp
+        return false unless $stdout =~ @out
+      else
+        return false unless $stdout == @out
+      end
+    end
+
+    unless @err.nil?
+      case @err
+      when Regexp
+        return false unless $stderr =~ @err
+      else
+        return false unless $stderr == @err
+      end
+    end
+
+    return true
+  ensure
+    $stdout = @saved_out
+    $stderr = @saved_err
+  end
+
+  def failure_message
+    expected_out = "\n"
+    actual_out = "\n"
+    unless @out.nil?
+      expected_out << "  $stdout: #{@out.inspect}\n"
+      actual_out << "  $stdout: #{@stdout.chomp.inspect}\n"
+    end
+    unless @err.nil?
+      expected_out << "  $stderr: #{@err.inspect}\n"
+      actual_out << "  $stderr: #{@stderr.chomp.inspect}\n"
+    end
+    ["Expected:#{expected_out}", "     got:#{actual_out}"]
+  end
+
+  def negative_failure_message
+    out = ""
+    out << "  $stdout: #{@stdout.chomp.dump}\n" unless @out.nil?
+    out << "  $stderr: #{@stderr.chomp.dump}\n" unless @err.nil?
+    ["Expected output not to be:\n", out]
+  end
+end
+
+class Object
+  def output(stdout=nil, stderr=nil)
+    OutputMatcher.new(stdout, stderr)
+  end
+end

data/lib/mspec/matchers/output_to_fd.rb

@@ -0,0 +1,71 @@
+require 'mspec/helpers/tmp'
+require 'fileutils'
+
+# Lower-level output speccing mechanism for a single
+# output stream. Unlike OutputMatcher which provides
+# methods to capture the output, we actually replace
+# the FD itself so that there is no reliance on a
+# certain method being used.
+class OutputToFDMatcher
+  def initialize(expected, to)
+    @to, @expected = to, expected
+
+    case @to
+    when STDOUT
+      @to_name = "STDOUT"
+    when STDERR
+      @to_name = "STDERR"
+    when IO
+      @to_name = @to.object_id.to_s
+    else
+      raise ArgumentError, "#{@to.inspect} is not a supported output target"
+    end
+  end
+
+  def matches?(block)
+    old_to = @to.dup
+    out = File.open(tmp("mspec_output_to_#{$$}_#{Time.now.to_i}"), 'w+')
+
+    # Replacing with a file handle so that Readline etc. work
+    @to.reopen out
+
+    block.call
+
+  ensure
+    begin
+      @to.reopen old_to
+
+      out.rewind
+      @actual = out.read
+
+      case @expected
+        when Regexp
+          return !(@actual =~ @expected).nil?
+        else
+          return @actual == @expected
+      end
+
+    # Clean up
+    ensure
+      out.close unless out.closed?
+      FileUtils.rm out.path
+    end
+
+    return true
+  end
+
+  def failure_message()
+    ["Expected (#{@to_name}): #{@expected.inspect}\n",
+     "#{'but got'.rjust(@to_name.length + 10)}: #{@actual.inspect}\nBacktrace"]
+  end
+
+  def negative_failure_message()
+    ["Expected output (#{@to_name}) to NOT be:\n", @actual.inspect]
+  end
+end
+
+class Object
+  def output_to_fd(what, where = STDOUT)
+    OutputToFDMatcher.new what, where
+  end
+end