rspec-expectations 2.99.2 → 3.0.0.beta1

metadata.gz.sig

@@ -0,0 +1,4 @@
+���ެ��M���fQ��Ƽ��V��4���A"	5�f���G&ʱD+w���
+p>v�^4R-�)N�J�g�G�<���
+�UŽ�^���b'�
+i�������Ĩ�ik9�gu��@�5?a��Ejdڳ*:�)�WL�B�i�g�2q �GF��D?�UN|*�����/�|�>)�gMkĺ��<؛tZ

data/features/built_in_matchers/have.feature

@@ -1,109 +0,0 @@
-Feature: have(n).items matcher
-
-  RSpec provides several matchers that make it easy to set expectations about the
-  size of a collection.  There are three basic forms:
-
-    ```ruby
-    collection.should have(x).items
-    collection.should have_at_least(x).items
-    collection.should have_at_most(x).items
-    ```
-
-  In addition, #have_exactly is provided as an alias to #have.
-
-  These work on any collection-like object--the object just needs to respond to #size
-  or #length (or both).  When the matcher is called directly on a collection object,
-  the #items call is pure syntactic sugar.  You can use anything you want here.  These
-  are equivalent:
-
-    ```ruby
-    collection.should have(x).items
-    collection.should have(x).things
-    ```
-
-  You can also use this matcher on a non-collection object that returns a collection
-  from one of its methods.  For example, Dir#entries returns an array, so you could
-  set an expectation using the following:
-
-    ```ruby
-    Dir.new("my/directory").should have(7).entries
-    ```
-
-  Scenario: have(x).items on a collection
-    Given a file named "have_items_spec.rb" with:
-      """ruby
-      describe [1, 2, 3] do
-        it { should have(3).items }
-        it { should_not have(2).items }
-        it { should_not have(4).items }
-
-        it { should have_exactly(3).items }
-        it { should_not have_exactly(2).items }
-        it { should_not have_exactly(4).items }
-
-        it { should have_at_least(2).items }
-        it { should have_at_most(4).items }
-
-        # deliberate failures
-        it { should_not have(3).items }
-        it { should have(2).items }
-        it { should have(4).items }
-
-        it { should_not have_exactly(3).items }
-        it { should have_exactly(2).items }
-        it { should have_exactly(4).items }
-
-        it { should have_at_least(4).items }
-        it { should have_at_most(2).items }
-      end
-      """
-     When I run `rspec have_items_spec.rb`
-     Then the output should contain "16 examples, 8 failures"
-      And the output should contain "expected target not to have 3 items, got 3"
-      And the output should contain "expected 2 items, got 3"
-      And the output should contain "expected 4 items, got 3"
-      And the output should contain "expected at least 4 items, got 3"
-      And the output should contain "expected at most 2 items, got 3"
-
-  Scenario: have(x).words on a String when String#words is defined
-    Given a file named "have_words_spec.rb" with:
-      """ruby
-      class String
-        def words
-          split(' ')
-        end
-      end
-
-      describe "a sentence with some words" do
-        it { should have(5).words }
-        it { should_not have(4).words }
-        it { should_not have(6).words }
-
-        it { should have_exactly(5).words }
-        it { should_not have_exactly(4).words }
-        it { should_not have_exactly(6).words }
-
-        it { should have_at_least(4).words }
-        it { should have_at_most(6).words }
-
-        # deliberate failures
-        it { should_not have(5).words }
-        it { should have(4).words }
-        it { should have(6).words }
-
-        it { should_not have_exactly(5).words }
-        it { should have_exactly(4).words }
-        it { should have_exactly(6).words }
-
-        it { should have_at_least(6).words }
-        it { should have_at_most(4).words }
-      end
-      """
-     When I run `rspec have_words_spec.rb`
-     Then the output should contain "16 examples, 8 failures"
-      And the output should contain "expected target not to have 5 words, got 5"
-      And the output should contain "expected 4 words, got 5"
-      And the output should contain "expected 6 words, got 5"
-      And the output should contain "expected at least 6 words, got 5"
-      And the output should contain "expected at most 4 words, got 5"
-

data/features/built_in_matchers/operators.feature

@@ -1,227 +0,0 @@
-Feature: operator matchers
-
-  RSpec provides a number of matchers that are based on Ruby's built-in
-  operators. These pretty much work like you expect. For example, each of these
-  pass:
-
-    ```ruby
-    7.should == 7
-    [1, 2, 3].should == [1, 2, 3]
-    "this is a string".should =~ /^this/
-    "this is a string".should_not =~ /^that/
-    String.should === "this is a string"
-    ```
-
-  You can also use comparison operators combined with the "be" matcher like
-  this:
-
-    ```ruby
-    37.should be < 100
-    37.should be <= 38
-    37.should be >= 2
-    37.should be > 7
-    ```
-
-  RSpec also provides a `=~` matcher for arrays that disregards differences in
-  the ording between the actual and expected array.  For example:
-
-    ```ruby
-    [1, 2, 3].should =~ [2, 3, 1] # pass
-    [:a, :c, :b].should =~ [:a, :c] # fail
-    ```
-
-  Scenario: numeric operator matchers
-    Given a file named "numeric_operator_matchers_spec.rb" with:
-      """ruby
-      describe 18 do
-        it { should == 18 }
-        it { should be < 20 }
-        it { should be > 15 }
-        it { should be <= 19 }
-        it { should be >= 17 }
-
-        it { should_not == 28 }
-
-        # deliberate failures
-        it { should == 28 }
-        it { should be < 15 }
-        it { should be > 20 }
-        it { should be <= 17 }
-        it { should be >= 19 }
-
-        it { should_not == 18 }
-      end
-      """
-     When I run `rspec numeric_operator_matchers_spec.rb`
-     Then the output should contain "12 examples, 6 failures"
-      And the output should contain:
-      """
-           Failure/Error: it { should == 28 }
-             expected: 28
-                  got: 18 (using ==)
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should be < 15 }
-             expected: < 15
-                  got:   18
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should be > 20 }
-             expected: > 20
-                  got:   18
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should be <= 17 }
-             expected: <= 17
-                  got:    18
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should be >= 19 }
-             expected: >= 19
-                  got:    18
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should_not == 18 }
-             expected not: == 18
-                      got:    18
-      """
-
-  Scenario: string operator matchers
-    Given a file named "string_operator_matchers_spec.rb" with:
-      """ruby
-      describe "Strawberry" do
-        it { should == "Strawberry" }
-        it { should be < "Tomato" }
-        it { should be > "Apple" }
-        it { should be <= "Turnip" }
-        it { should be >= "Banana" }
-        it { should =~ /berry/ }
-
-        it { should_not == "Peach" }
-        it { should_not =~ /apple/ }
-
-        it "reports that it is a string using ===" do
-          String.should === subject
-        end
-
-        # deliberate failures
-        it { should == "Peach" }
-        it { should be < "Cranberry" }
-        it { should be > "Zuchini" }
-        it { should be <= "Potato" }
-        it { should be >= "Tomato" }
-        it { should =~ /apple/ }
-
-        it { should_not == "Strawberry" }
-        it { should_not =~ /berry/ }
-
-        it "fails a spec asserting that it is a symbol" do
-          Symbol.should === subject
-        end
-      end
-      """
-     When I run `rspec string_operator_matchers_spec.rb`
-     Then the output should contain "18 examples, 9 failures"
-      And the output should contain:
-      """
-           Failure/Error: it { should == "Peach" }
-             expected: "Peach"
-                  got: "Strawberry" (using ==)
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should be < "Cranberry" }
-             expected: < "Cranberry"
-                  got:   "Strawberry"
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should be > "Zuchini" }
-             expected: > "Zuchini"
-                  got:   "Strawberry"
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should be <= "Potato" }
-             expected: <= "Potato"
-                  got:    "Strawberry"
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should be >= "Tomato" }
-             expected: >= "Tomato"
-                  got:    "Strawberry"
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should =~ /apple/ }
-             expected: /apple/
-                  got: "Strawberry" (using =~)
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should_not == "Strawberry" }
-             expected not: == "Strawberry"
-                      got:    "Strawberry"
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should_not =~ /berry/ }
-             expected not: =~ /berry/
-                      got:    "Strawberry"
-      """
-      And the output should contain:
-      """
-           Failure/Error: Symbol.should === subject
-             expected: "Strawberry"
-                  got: Symbol (using ===)
-      """
-
-  Scenario: array operator matchers
-    Given a file named "array_operator_matchers_spec.rb" with:
-      """ruby
-      describe [1, 2, 3] do
-        it { should == [1, 2, 3] }
-        it { should_not == [1, 3, 2] }
-
-        it { should =~ [1, 2, 3] }
-        it { should =~ [1, 3, 2] }
-        it { should =~ [2, 1, 3] }
-        it { should =~ [2, 3, 1] }
-        it { should =~ [3, 1, 2] }
-        it { should =~ [3, 2, 1] }
-
-        # deliberate failures
-        it { should_not == [1, 2, 3] }
-        it { should == [1, 3, 2] }
-        it { should =~ [1, 2, 1] }
-      end
-      """
-     When I run `rspec array_operator_matchers_spec.rb`
-     Then the output should contain "11 examples, 3 failures"
-      And the output should contain:
-      """
-           Failure/Error: it { should_not == [1, 2, 3] }
-             expected not: == [1, 2, 3]
-                      got:    [1, 2, 3]
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should == [1, 3, 2] }
-             expected: [1, 3, 2]
-                  got: [1, 2, 3] (using ==)
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should =~ [1, 2, 1] }
-             expected collection contained:  [1, 1, 2]
-             actual collection contained:    [1, 2, 3]
-             the missing elements were:      [1]
-             the extra elements were:        [3]
-      """
-

data/lib/rspec/expectations/caller_filter.rb

@@ -1,60 +0,0 @@
-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.
-
-  unless defined?(CallerFilter)
-
-    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)
-            return nil 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
-end

data/lib/rspec/expectations/deprecation.rb

@@ -1,27 +0,0 @@
-require 'rspec/expectations/caller_filter' unless defined?(::RSpec::CallerFilter)
-
-module RSpec
-  module Expectations
-    module Deprecation
-      # @private
-      #
-      # Used internally to print deprecation warnings
-      def deprecate(deprecated, options={})
-        message = "DEPRECATION: #{deprecated} is deprecated."
-        message << " Use #{options[:replacement]} instead." if options[:replacement]
-        message << " Called from #{CallerFilter.first_non_rspec_line}."
-        warn message
-      end
-
-      # @private
-      #
-      # Used internally to print deprecation warnings
-      def warn_deprecation(warning)
-        message = "\nDEPRECATION: #{warning}\n"
-        warn message
-      end
-    end
-  end
-
-  extend(Expectations::Deprecation) unless respond_to?(:deprecate)
-end

data/lib/rspec/expectations/extensions/array.rb

@@ -1,9 +0,0 @@
-# @private
-class Array
-  unless public_instance_methods.map {|m| m.to_s}.include?('none?')
-    # Supports +none?+ on early patch levels of Ruby 1.8.6
-    def none?(&block)
-      !any?(&block)
-    end
-  end
-end

data/lib/rspec/matchers/be_close.rb

@@ -1,12 +0,0 @@
-module RSpec
-  module Matchers
-    # @deprecated use +be_within+ instead.
-    def be_close(expected, delta)
-      RSpec.deprecate("be_close(#{expected}, #{delta})",
-        :replacement => "be_within(#{delta}).of(#{expected})",
-        :type        => 'the be_close matcher'
-      )
-      be_within(delta).of(expected)
-    end
-  end
-end