jruby · Feb 3, 2016 · Feb 3, 2016
diff --git a/spec/mspec/.travis.yml b/spec/mspec/.travis.yml
@@ -1,3 +1,4 @@
+sudo: false
 language: ruby
 script:
   - bundle exec rspec

diff --git a/spec/mspec/lib/mspec/matchers/raise_error.rb b/spec/mspec/lib/mspec/matchers/raise_error.rb
@@ -9,17 +9,26 @@ def matches?(proc)
     @result = proc.call
     return false
   rescue Exception => @actual
-    return false unless @exception === @actual
+    if matching_exception?(@actual)
+      return true
+    else
+      raise @actual
+    end
+  end
+
+  def matching_exception?(exc)
+    return false unless @exception === exc
     if @message then
       case @message
-      when String then
-        return false if @message != @actual.message
-      when Regexp then
-        return false if @message !~ @actual.message
+      when String
+        return false if @message != exc.message
+      when Regexp
+        return false if @message !~ exc.message
       end
     end
 
-    @block[@actual] if @block
+    # The block has its own expectations and will throw an exception if it fails
+    @block[exc] if @block
 
     return true
   end

diff --git a/spec/mspec/lib/mspec/runner/evaluate.rb b/spec/mspec/lib/mspec/runner/evaluate.rb
@@ -8,7 +8,7 @@ def self.desc
   end
 
   def initialize(ruby, desc)
-    @ruby = ruby
+    @ruby = ruby.rstrip
     @desc = desc || self.class.desc
   end
 
@@ -18,8 +18,8 @@ def initialize(ruby, desc)
   # the source does contain newline characters, sets the indent level to four
   # characters.
   def format(ruby, newline=true)
-    if /\n/ =~ ruby
-      lines = ruby.rstrip.each_line.to_a
+    if ruby.include?("\n")
+      lines = ruby.each_line.to_a
       if /( *)/ =~ lines.first
         if $1.size > 4
           dedent = $1.size - 4
@@ -31,7 +31,7 @@ def format(ruby, newline=true)
       end
       "\n#{ruby}"
     else
-      "'#{ruby}'"
+      "'#{ruby.lstrip}'"
     end
   end
 

diff --git a/spec/mspec/lib/mspec/utils/name_map.rb b/spec/mspec/lib/mspec/utils/name_map.rb
@@ -110,7 +110,7 @@ def map(hash, constants, mod=nil)
       ms.map! { |x| x.to_s }
       hash["#{name}#"] = ms.sort unless ms.empty?
 
-      map hash, m.constants, name
+      map hash, m.constants(false), name
     end
 
     hash

diff --git a/spec/mspec/lib/mspec/utils/options.rb b/spec/mspec/lib/mspec/utils/options.rb
@@ -150,7 +150,7 @@ def parse(argv=ARGV)
         opt, arg, rest = split rest, 1
         opt = "-" + opt
         option = process argv, opt, opt, arg
-        break if option.arg?
+        break if !option or option.arg?
       end
     end
 

diff --git a/spec/mspec/spec/matchers/raise_error_spec.rb b/spec/mspec/spec/matchers/raise_error_spec.rb
@@ -8,7 +8,8 @@ class UnexpectedException < Exception; end
 describe RaiseErrorMatcher do
   it "matches when the proc raises the expected exception" do
     proc = Proc.new { raise ExpectedException }
-    RaiseErrorMatcher.new(ExpectedException, nil).matches?(proc).should == true
+    matcher = RaiseErrorMatcher.new(ExpectedException, nil)
+    matcher.matches?(proc).should == true
   end
 
   it "executes it's optional block if matched" do
@@ -25,28 +26,50 @@ class UnexpectedException < Exception; end
 
   it "matches when the proc raises the expected exception with the expected message" do
     proc = Proc.new { raise ExpectedException, "message" }
-    RaiseErrorMatcher.new(ExpectedException, "message").matches?(proc).should == true
+    matcher = RaiseErrorMatcher.new(ExpectedException, "message")
+    matcher.matches?(proc).should == true
+  end
+
+  it "matches when the proc raises the expected exception with a matching message" do
+    proc = Proc.new { raise ExpectedException, "some message" }
+    matcher = RaiseErrorMatcher.new(ExpectedException, /some/)
+    matcher.matches?(proc).should == true
   end
 
   it "does not match when the proc does not raise the expected exception" do
-    proc = Proc.new { raise UnexpectedException }
-    RaiseErrorMatcher.new(ExpectedException, nil).matches?(proc).should == false
+    exc = UnexpectedException.new
+    matcher = RaiseErrorMatcher.new(ExpectedException, nil)
+
+    matcher.matching_exception?(exc).should == false
+    lambda {
+      matcher.matches?(Proc.new { raise exc })
+    }.should raise_error(UnexpectedException)
   end
 
   it "does not match when the proc raises the expected exception with an unexpected message" do
-    proc = Proc.new { raise ExpectedException, "unexpected" }
-    RaiseErrorMatcher.new(ExpectedException, "expected").matches?(proc).should == false
+    exc = ExpectedException.new("unexpected")
+    matcher = RaiseErrorMatcher.new(ExpectedException, "expected")
+
+    matcher.matching_exception?(exc).should == false
+    lambda {
+      matcher.matches?(Proc.new { raise exc })
+    }.should raise_error(ExpectedException)
   end
 
   it "does not match when the proc does not raise an exception" do
     proc = Proc.new {}
-    RaiseErrorMatcher.new(ExpectedException, "expected").matches?(proc).should == false
+    matcher = RaiseErrorMatcher.new(ExpectedException, "expected")
+    matcher.matches?(proc).should == false
   end
 
   it "provides a useful failure message" do
-    proc = Proc.new { raise UnexpectedException, "unexpected" }
+    exc = UnexpectedException.new("unexpected")
     matcher = RaiseErrorMatcher.new(ExpectedException, "expected")
-    matcher.matches?(proc)
+
+    matcher.matching_exception?(exc).should == false
+    lambda {
+      matcher.matches?(Proc.new { raise exc })
+    }.should raise_error(UnexpectedException)
     matcher.failure_message.should ==
       ["Expected ExpectedException (expected)", "but got UnexpectedException (unexpected)"]
   end

diff --git a/spec/mspec/spec/matchers/raise_exception_spec.rb b/spec/mspec/spec/matchers/raise_exception_spec.rb
@@ -6,77 +6,7 @@ class ExpectedException < Exception; end
 class UnexpectedException < Exception; end
 
 describe RaiseExceptionMatcher do
-  it "matches when the proc raises the expected exception" do
-    proc = Proc.new { raise ExpectedException }
-    RaiseErrorMatcher.new(ExpectedException, nil).matches?(proc).should == true
-  end
-
-  it "executes it's optional block if matched" do
-    run = false
-    proc = Proc.new { raise ExpectedException }
-    matcher = RaiseErrorMatcher.new(ExpectedException, nil) { |error|
-      run = true
-      error.class.should == ExpectedException
-    }
-
-    matcher.matches?(proc).should == true
-    run.should == true
-  end
-
-  it "matches when the proc raises the expected exception with the expected message" do
-    proc = Proc.new { raise ExpectedException, "message" }
-    RaiseErrorMatcher.new(ExpectedException, "message").matches?(proc).should == true
-  end
-
-  it "does not match when the proc does not raise the expected exception" do
-    proc = Proc.new { raise UnexpectedException }
-    RaiseErrorMatcher.new(ExpectedException, nil).matches?(proc).should == false
-  end
-
-  it "does not match when the proc raises the expected exception with an unexpected message" do
-    proc = Proc.new { raise ExpectedException, "unexpected" }
-    RaiseErrorMatcher.new(ExpectedException, "expected").matches?(proc).should == false
-  end
-
-  it "does not match when the proc does not raise an exception" do
-    proc = Proc.new {}
-    RaiseErrorMatcher.new(ExpectedException, "expected").matches?(proc).should == false
-  end
-
-  it "does not match when the raised exception is not an instance of the expected exception" do
-    proc = Proc.new { raise Exception }
-    RaiseErrorMatcher.new(ExpectedException, nil).matches?(proc).should == false
-  end
-
-  it "provides a useful failure message" do
-    proc = Proc.new { raise UnexpectedException, "unexpected" }
-    matcher = RaiseErrorMatcher.new(ExpectedException, "expected")
-    matcher.matches?(proc)
-    matcher.failure_message.should ==
-      ["Expected ExpectedException (expected)", "but got UnexpectedException (unexpected)"]
-  end
-
-  it "provides a useful failure message when no exception is raised" do
-    proc = Proc.new { 120 }
-    matcher = RaiseErrorMatcher.new(ExpectedException, "expected")
-    matcher.matches?(proc)
-    matcher.failure_message.should ==
-      ["Expected ExpectedException (expected)", "but no exception was raised (120 was returned)"]
-  end
-
-  it "provides a useful negative failure message" do
-    proc = Proc.new { raise ExpectedException, "expected" }
-    matcher = RaiseErrorMatcher.new(ExpectedException, "expected")
-    matcher.matches?(proc)
-    matcher.negative_failure_message.should ==
-      ["Expected to not get ExpectedException (expected)", ""]
-  end
-
-  it "provides a useful negative failure message for strict subclasses of the matched exception class" do
-    proc = Proc.new { raise UnexpectedException, "unexpected" }
-    matcher = RaiseErrorMatcher.new(Exception, nil)
-    matcher.matches?(proc)
-    matcher.negative_failure_message.should ==
-      ["Expected to not get Exception", "but got UnexpectedException (unexpected)"]
+  it "is a legac alias of RaiseErrorMatcher" do
+    RaiseExceptionMatcher.should equal(RaiseErrorMatcher)
   end
 end