rspec-expectations 2.14.5 → 2.99.0.beta1

checksums.yaml

@@ -1,7 +1,15 @@
---- 
-SHA1: 
-  metadata.gz: f05471f3e092a7949e6a65050baebd47319f3244
-  data.tar.gz: d285c05c76c8e3185c735444436bb26f09f76900
-SHA512: 
-  metadata.gz: e035793f67b9d902d8afa94ede41915f39aa8bfacddf8cb1a03ed2c89d2e40ee0ecee5dc4bc8557d8ad933d9f33179a971d3cdd1bb2944cfdec12f27b0ddbb90
-  data.tar.gz: f217c62ff802d25bde703e383e7b73deb28b9c895edc14e8576fae14db9ada4264bdd4cc8edd29372e5bb8dd37abf7ca1c21eda446d6bdea9d034b5c1017abd2
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZWNiMjczZmU0MjNkMzFhOTQxYzdkNWJjZDc1MTc4MWJlZmJmODhhZA==
+  data.tar.gz: !binary |-
+    NjMyZWVhYjFmYzRkNjM5YWRiMDFhMGRmMDhmNTNlYWJhMzg3NDlmNQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    NzYyZDgzZjM5ODk5MjliNWI3YWE2MzY1ZmQ4YzQxNDQzOGU0ZDRiYzczZWMx
+    NGI5NzdjOTIwZmMyMDRkMGE2YzY2YTk2MjBiNGZlM2M5NjU4MmMzZjVhODFj
+    MDcxMDJhYTIwNTI4MTFlNmI4NjBkMjAxYTE1NzA4MDgwODJiODM=
+  data.tar.gz: !binary |-
+    YzA0Mzg2MzBmYzc1ZmFjNDI3YjQzOTVkMzYwNzQ1OWU1NDYwZTg3YjFhMzQy
+    Y2JjYWZkMzNiZDJjMDJkYmMyZDZjYmJlMmU0MTlkNmZiNDVkY2E0OTUwMmJj
+    MGM0ODI1ZWZmMjUxYmQzMDAzYzM1M2I3MzM3YWVjMDQ4YmIzMmM=

data/Changelog.md

@@ -1,9 +1,27 @@
-### 2.14.5 / 2014-02-01
-[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.14.4...v2.14.5)
+### 2.99.0.beta1 / 2013-11-07
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.14.4...v2.99.0.beta1)
 
-Bug fixes
+Deprecations
 
-* Fix wrong matcher descriptions with falsey expected value (yujinakayama)
+* Deprecate `have`, `have_at_least` and `have_at_most`. You can continue using those
+	matchers through https://github.com/rspec/rspec-collection_matchers, or
+	you can rewrite your expectations with something like
+	`expect(your_object.size).to eq(num)`. (Hugo Baraúna)
+* Deprecate `be_xyz` predicate matcher when `xyz?` is a private method.
+  (Jon Rowe)
+* Deprecate `be_true`/`be_false` in favour of `be_truthy`/`be_falsey`
+  (for Ruby's conditional semantics) or `be true`/`be false`
+  (for exact equality). (Sam Phippen)
+* Deprecate calling helper methods from a custom matcher with the wrong
+  scope. (Myron Marston)
+  * `def self.foo` / `extend Helper` can be used to add macro methods
+    (e.g. methods that call the custom matcher DSL methods), but should
+    not be used to define helper methods called from within the DSL
+    blocks.
+  * `def foo` / `include Helper` is the opposite: it's for helper methods
+    callable from within a DSL block, but not for defining macros.
+  * RSpec 2.x allowed helper methods defined either way to be used for
+    either purpose, but RSpec 3.0 will not.
 
 ### 2.14.4 / 2013-11-06
 [full changelog](http://github.com/rspec/rspec-expectations/compare/v2.14.3...v2.14.4)

data/features/built_in_matchers/be.feature

@@ -3,101 +3,101 @@ Feature: "be" matchers
   There are several related "be" matchers:
 
     ```ruby
-    obj.should be_true  # passes if obj is truthy (not nil or false)
-    obj.should be_false # passes if obj is falsy (nil or false)
+    obj.should be_truthy  # passes if obj is truthy (not nil or false)
+    obj.should be_falsey # passes if obj is falsy (nil or false)
     obj.should be_nil   # passes if obj is nil
     obj.should be       # passes if obj is truthy (not nil or false)
     ```
 
-  Scenario: be_true matcher
-    Given a file named "be_true_spec.rb" with:
+  Scenario: be_truthy matcher
+    Given a file named "be_truthy_spec.rb" with:
       """ruby
-      describe "be_true matcher" do
-        specify { true.should be_true }
-        specify { 7.should be_true }
-        specify { "foo".should be_true }
-        specify { nil.should_not be_true }
-        specify { false.should_not be_true }
+      describe "be_truthy matcher" do
+        specify { true.should be_truthy }
+        specify { 7.should be_truthy }
+        specify { "foo".should be_truthy }
+        specify { nil.should_not be_truthy }
+        specify { false.should_not be_truthy }
 
         # deliberate failures
-        specify { true.should_not be_true }
-        specify { 7.should_not be_true }
-        specify { "foo".should_not be_true }
-        specify { nil.should be_true }
-        specify { false.should be_true }
+        specify { true.should_not be_truthy }
+        specify { 7.should_not be_truthy }
+        specify { "foo".should_not be_truthy }
+        specify { nil.should be_truthy }
+        specify { false.should be_truthy }
       end
       """
-    When I run `rspec be_true_spec.rb`
+    When I run `rspec be_truthy_spec.rb`
     Then the output should contain "10 examples, 5 failures"
     And the output should contain:
       """
-             expected: non-true value
+             expected: falsey value
                   got: true
       """
     And the output should contain:
       """
-             expected: non-true value
+             expected: falsey value
                   got: 7
       """
     And the output should contain:
       """
-             expected: non-true value
+             expected: falsey value
                   got: "foo"
       """
     And the output should contain:
       """
-             expected: true value
+             expected: truthy value
                   got: nil
       """
     And the output should contain:
       """
-             expected: true value
+             expected: truthy value
                   got: false
       """
 
-  Scenario: be_false matcher
-    Given a file named "be_false_spec.rb" with:
+  Scenario: be_falsey matcher
+    Given a file named "be_falsey_spec.rb" with:
       """ruby
-      describe "be_false matcher" do
-        specify { nil.should be_false }
-        specify { false.should be_false }
-        specify { true.should_not be_false }
-        specify { 7.should_not be_false }
-        specify { "foo".should_not be_false }
+      describe "be_falsey matcher" do
+        specify { nil.should be_falsey }
+        specify { false.should be_falsey }
+        specify { true.should_not be_falsey }
+        specify { 7.should_not be_falsey }
+        specify { "foo".should_not be_falsey }
 
         # deliberate failures
-        specify { nil.should_not be_false }
-        specify { false.should_not be_false }
-        specify { true.should be_false }
-        specify { 7.should be_false }
-        specify { "foo".should be_false }
+        specify { nil.should_not be_falsey }
+        specify { false.should_not be_falsey }
+        specify { true.should be_falsey }
+        specify { 7.should be_falsey }
+        specify { "foo".should be_falsey }
       end
       """
-    When I run `rspec be_false_spec.rb`
+    When I run `rspec be_falsey_spec.rb`
     Then the output should contain "10 examples, 5 failures"
     And the output should contain:
       """
-             expected: non-false value
+             expected: truthy value
                   got: nil
       """
     And the output should contain:
       """
-             expected: non-false value
+             expected: truthy value
                   got: false
       """
     And the output should contain:
       """
-             expected: false value
+             expected: falsey value
                   got: true
       """
     And the output should contain:
       """
-             expected: false value
+             expected: falsey value
                   got: 7
       """
     And the output should contain:
       """
-             expected: false value
+             expected: falsey value
                   got: "foo"
       """
 

data/lib/rspec/expectations/caller_filter.rb

@@ -0,0 +1,55 @@
+module RSpec
+  # Consistent implementation for "cleaning" the caller method to strip out
+  # non-rspec lines. This enables errors to be reported at the call site in
+  # the code using the library, which is far more useful than the particular
+  # internal method that raised an error.
+  class CallerFilter
+
+    RSPEC_LIBS = %w[
+      core
+      mocks
+      expectations
+      matchers
+      rails
+    ]
+
+    ADDITIONAL_TOP_LEVEL_FILES = %w[ autorun ]
+
+    LIB_REGEX = %r{/lib/rspec/(#{(RSPEC_LIBS + ADDITIONAL_TOP_LEVEL_FILES).join('|')})(\.rb|/)}
+
+    if RUBY_VERSION >= '2.0.0'
+      def self.first_non_rspec_line
+        # `caller` is an expensive method that scales linearly with the size of
+        # the stack. The performance hit for fetching it in chunks is small,
+        # and since the target line is probably near the top of the stack, the
+        # overall improvement of a chunked search like this is significant.
+        #
+        # See benchmarks/caller.rb for measurements.
+
+        # Initial value here is mostly arbitrary, but is chosen to give good
+        # performance on the common case of creating a double.
+        increment = 5
+        i         = 1
+        line      = nil
+
+        while !line
+          stack = caller(i, increment)
+          raise "No non-lib lines in stack" unless stack
+
+          line = stack.find { |l| l !~ LIB_REGEX }
+
+          i         += increment
+          increment *= 2 # The choice of two here is arbitrary.
+        end
+
+        line
+      end
+    else
+      # Earlier rubies do not support the two argument form of `caller`. This
+      # fallback is logically the same, but slower.
+      def self.first_non_rspec_line
+        caller.find { |line| line !~ LIB_REGEX }
+      end
+    end
+  end
+end

data/lib/rspec/expectations/deprecation.rb

@@ -1,27 +1,15 @@
+require 'rspec/expectations/caller_filter' unless defined?(::RSpec::CallerFilter)
+
 module RSpec
   module Expectations
     module Deprecation
-     RSPEC_LIBS = %w[
-        core
-        mocks
-        expectations
-        matchers
-        rails
-      ]
-
-      ADDITIONAL_TOP_LEVEL_FILES = %w[ autorun ]
-
-      LIB_REGEX = %r{/lib/rspec/(#{(RSPEC_LIBS + ADDITIONAL_TOP_LEVEL_FILES).join('|')})(\.rb|/)}
-
       # @private
       #
       # Used internally to print deprecation warnings
       def deprecate(deprecated, options={})
-        call_site = caller.find { |line| line !~ LIB_REGEX }
-
         message = "DEPRECATION: #{deprecated} is deprecated."
         message << " Use #{options[:replacement]} instead." if options[:replacement]
-        message << " Called from #{call_site}."
+        message << " Called from #{CallerFilter.first_non_rspec_line}."
         warn message
       end
     end

data/lib/rspec/expectations/version.rb

@@ -2,8 +2,7 @@ module RSpec
   module Expectations
     # @private
     module Version
-      STRING = '2.14.5'
+      STRING = '2.99.0.beta1'
     end
   end
 end
-

data/lib/rspec/matchers.rb

@@ -183,24 +183,42 @@ module RSpec
       obj.respond_to?(:failure_message_for_should) || obj.respond_to?(:failure_message)
     end
 
-    # Passes if actual is truthy (anything but false or nil)
     def be_true
-      BuiltIn::BeTrue.new
+      RSpec.deprecate("`be_true`", :replacement =>
+        "`be_truthy` (for Ruby's conditional semantics) or " +
+        "`be true` (for exact `== true` equality)"
+      )
+      BuiltIn::BeTruthy.new
     end
 
-    # Passes if actual is falsy (false or nil)
     def be_false
-      BuiltIn::BeFalse.new
+      RSpec.deprecate("`be_false`", :replacement =>
+        "`be_falsey` (for Ruby's conditional semantics) or " +
+        "`be false` (for exact `== false` equality)"
+      )
+      BuiltIn::BeFalsey.new
+    end
+
+    # Passes if actual is truthy (anything but false or nil)
+    def be_truthy
+      BuiltIn::BeTruthy.new
     end
 
+    # Passes if actual is falsy (false or nil)
+    def be_falsey
+      BuiltIn::BeFalsey.new
+    end
+
+    alias_method :be_falsy, :be_falsey
+
     # Passes if actual is nil
     def be_nil
       BuiltIn::BeNil.new
     end
 
     # @example
-    #   expect(actual).to     be_true
-    #   expect(actual).to     be_false
+    #   expect(actual).to     be_truthy
+    #   expect(actual).to     be_falsey
     #   expect(actual).to     be_nil
     #   expect(actual).to     be_[arbitrary_predicate](*args)
     #   expect(actual).not_to be_nil

data/lib/rspec/matchers/built_in.rb

@@ -4,8 +4,8 @@ module RSpec
       require 'rspec/matchers/built_in/base_matcher'
       autoload :BeAnInstanceOf, 'rspec/matchers/built_in/be_instance_of'
       autoload :Be,             'rspec/matchers/built_in/be'
-      autoload :BeTrue,         'rspec/matchers/built_in/be'
-      autoload :BeFalse,        'rspec/matchers/built_in/be'
+      autoload :BeTruthy,         'rspec/matchers/built_in/be'
+      autoload :BeFalsey,        'rspec/matchers/built_in/be'
       autoload :BeNil,          'rspec/matchers/built_in/be'
       autoload :BeComparedTo,   'rspec/matchers/built_in/be'
       autoload :BePredicate,    'rspec/matchers/built_in/be'

data/lib/rspec/matchers/built_in/base_matcher.rb

@@ -14,12 +14,10 @@ module RSpec
       class BaseMatcher
         include RSpec::Matchers::Pretty
 
-        UNDEFINED = Object.new.freeze
-
         attr_reader :actual, :expected, :rescued_exception
 
-        def initialize(expected = UNDEFINED)
-          @expected = expected unless UNDEFINED.equal?(expected)
+        def initialize(expected = nil)
+          @expected = expected
         end
 
         def matches?(actual)
@@ -38,17 +36,17 @@ module RSpec
         end
 
         def failure_message_for_should
-          assert_ivars :@actual
+          assert_ivars :@actual, :@expected
           "expected #{@actual.inspect} to #{name_to_sentence}#{expected_to_sentence}"
         end
 
         def failure_message_for_should_not
-          assert_ivars :@actual
+          assert_ivars :@actual, :@expected
           "expected #{@actual.inspect} not to #{name_to_sentence}#{expected_to_sentence}"
         end
 
         def description
-          defined?(@expected) ? "#{name_to_sentence} #{@expected.inspect}" : name_to_sentence
+          expected ? "#{name_to_sentence} #{@expected.inspect}" : name_to_sentence
         end
 
         def diffable?

data/lib/rspec/matchers/built_in/be.rb

@@ -3,31 +3,31 @@ require 'rspec/matchers/dsl'
 module RSpec
   module Matchers
     module BuiltIn
-      class BeTrue < BaseMatcher
+      class BeTruthy < BaseMatcher
         def match(_, actual)
           !!actual
         end
 
         def failure_message_for_should
-          "expected: true value\n     got: #{actual.inspect}"
+          "expected: truthy value\n     got: #{actual.inspect}"
         end
 
         def failure_message_for_should_not
-          "expected: non-true value\n     got: #{actual.inspect}"
+          "expected: falsey value\n     got: #{actual.inspect}"
         end
       end
 
-      class BeFalse < BaseMatcher
+      class BeFalsey < BaseMatcher
         def match(_, actual)
           !actual
         end
 
         def failure_message_for_should
-          "expected: false value\n     got: #{actual.inspect}"
+          "expected: falsey value\n     got: #{actual.inspect}"
         end
 
         def failure_message_for_should_not
-          "expected: non-false value\n     got: #{actual.inspect}"
+          "expected: truthy value\n     got: #{actual.inspect}"
         end
       end
 
@@ -141,6 +141,13 @@ it is a bit confusing.
 
         def matches?(actual)
           @actual = actual
+
+          if is_private_on?( @actual )
+            RSpec.deprecate "matching with be_#{predicate.to_s.gsub(/\?$/,'')} on private method #{predicate}",
+              :replacement => "`expect(object.send(#{predicate.inspect})).to be_true` or change the method's visibility to public",
+              :call_site => caller(0)[3]
+          end
+
           begin
             return @result = actual.__send__(predicate, *@args, &@block)
           rescue NameError => predicate_missing_error
@@ -170,6 +177,17 @@ it is a bit confusing.
 
         private
 
+        # support 1.8.7
+        if methods.first.is_a? String
+          def is_private_on? actual
+            actual.private_methods.include? predicate.to_s
+          end
+        else
+          def is_private_on? actual
+            actual.private_methods.include? predicate
+          end
+        end
+
         def predicate
           "#{@expected}?".to_sym
         end