Use proper source location for should calls without a block (#92)

lib/shoulda/context/context.rb

@@ -56,10 +56,20 @@ def teardown(&blk)
         self.teardown_blocks << blk
       end
 
-      def should(name_or_matcher, options = {}, &blk)
+      class LambdaWithLocation < Proc
+        attr_reader :source_location
+
+        def initialize(source_location, &blk)
+          @source_location = source_location
+          super(&blk)
+        end
+      end
+
+      def should(name_or_matcher, options = {}, source_location = (loc = caller_locations(1, 1)[0]
+                                                                   [loc.path, loc.lineno]), &blk)
         if name_or_matcher.respond_to?(:description) && name_or_matcher.respond_to?(:matches?)
           name = name_or_matcher.description
-          blk = lambda { assert_accepts name_or_matcher, subject }
+          blk = LambdaWithLocation.new(source_location, &lambda { assert_accepts name_or_matcher, subject })
         else
           name = name_or_matcher
         end
@@ -71,9 +81,10 @@ def should(name_or_matcher, options = {}, &blk)
         end
       end
 
-      def should_not(matcher)
+      def should_not(matcher, source_location = (loc = caller_locations(1, 1)[0]
+                                                 [loc.path, loc.lineno]))
         name = matcher.description
-        blk = lambda { assert_rejects matcher, subject }
+        blk = LambdaWithLocation.new(source_location, &lambda { assert_rejects matcher, subject })
         self.shoulds << { :name => "not #{name}", :block => blk }
       end
 

lib/shoulda/context/dsl.rb

@@ -61,13 +61,14 @@ module ClassMethods
         #   should validate_presence_of(:first_name).with_message(/gotta be there/)
         #
 
-        def should(name_or_matcher, options = {}, &blk)
+        def should(name_or_matcher, options = {}, source_location = (loc = caller_locations(1, 1)[0]
+                                                                     [loc.path, loc.lineno]), &blk)
           if Shoulda::Context.current_context
-            Shoulda::Context.current_context.should(name_or_matcher, options, &blk)
+            Shoulda::Context.current_context.should(name_or_matcher, options, source_location, &blk)
           else
             context_name = self.name.gsub(/Test$/, "") if name
             context = Shoulda::Context::Context.new(context_name, self) do
-              should(name_or_matcher, options, &blk)
+              should(name_or_matcher, options, source_location, &blk)
             end
             context.build
           end
@@ -80,13 +81,14 @@ def should(name_or_matcher, options = {}, &blk)
         # === Example:
         #
         #   should_not set_the_flash
-        def should_not(matcher)
+        def should_not(matcher, source_location = (loc = caller_locations(1, 1)[0]
+                                                   [loc.path, loc.lineno]))
           if Shoulda::Context.current_context
-            Shoulda::Context.current_context.should_not(matcher)
+            Shoulda::Context.current_context.should_not(matcher, source_location)
           else
             context_name = self.name.gsub(/Test$/, "") if name
             context = Shoulda::Context::Context.new(context_name, self) do
-              should_not(matcher)
+              should_not(matcher, source_location)
             end
             context.build
           end

test/shoulda/rerun_snippet_test.rb

@@ -11,25 +11,44 @@ class RerunSnippetTest < PARENT_TEST_CASE
           require_relative "../../config/environment"
 
           class FailingTest < #{PARENT_TEST_CASE}
+            class FakeMatcher
+              attr_reader :subject
+              attr_accessor :fail
+
+              def description
+                "be a fake matcher"
+              end
+
+              def matches?(subject)
+                @subject = subject
+                !@fail
+              end
+
+              def failure_message
+                "positive failure message"
+              end
+
+              def failure_message_when_negated
+                "negative failure message"
+              end
+            end
+
             should "fail" do
               assert false
             end
+
+            should_not FakeMatcher.new.tap { |m| m.fail = false }
+            should FakeMatcher.new.tap { |m| m.fail = true }
           end
         RUBY
 
         command_runner = app.run_n_unit_test_suite
 
-        expected_file_path_with_line_number =
-          if rails_version >= 6
-            "rails test test/models/failing_test.rb:5"
-          else
-            "bin/rails test test/models/failing_test.rb:5"
-          end
+        expected_executable = rails_version >= 6 ? "rails test" : "bin/rails test"
 
-        assert_includes(
-          command_runner.output,
-          expected_file_path_with_line_number
-        )
+        assert_includes(command_runner.output, "#{expected_executable} test/models/failing_test.rb:27")
+        assert_includes(command_runner.output, "#{expected_executable} test/models/failing_test.rb:31")
+        assert_includes(command_runner.output, "#{expected_executable} test/models/failing_test.rb:32")
       end
     end
   end

test/shoulda/should_test.rb

@@ -271,7 +271,7 @@ def test_should_create_a_new_context_and_build_it_on_test_case_context
 
   def test_should_create_a_one_off_context_and_build_it_on_test_case_should
     s = mock("test")
-    Shoulda::Context::Context.any_instance.expects(:should).with("rock", {}).returns(s)
+    Shoulda::Context::Context.any_instance.expects(:should).with("rock", {}, [__FILE__, __LINE__ + 2]).returns(s)
     Shoulda::Context::Context.any_instance.expects(:build)
     self.class.should "rock" do; end
   end