rspec-expectations 2.0.0.beta.22 → 2.6.0

data/.gitignore

@@ -1,6 +1,6 @@
 *.sw?
 .DS_Store
-coverage
+coverage*
 rdoc
 pkg
 doc

data/.travis.yml

@@ -0,0 +1,7 @@
+script: "rake"
+rvm:
+  - 1.8.6
+  - 1.8.7
+  - 1.9.1
+  - 1.9.2
+  - ree

data/Gemfile

@@ -1,18 +1,40 @@
 source "http://rubygems.org"
 
-gem "rake"
-gem "cucumber"
-gem "aruba", ">= 0.2.0"
-gem "autotest"
-gem "diff-lcs"
-gem "rspec-expectations", :path => "."
-gem "rspec-core", :path => "../rspec-core"
-gem "rspec-mocks", :path => "../rspec-mocks"
-gem "watchr"
+### rspec libs
+%w[rspec rspec-core rspec-expectations rspec-mocks].each do |lib|
+  library_path = File.expand_path("../../#{lib}", __FILE__)
+  if File.exist?(library_path)
+    gem lib, :path => library_path
+  else
+    gem lib, :git => "git://github.com/rspec/#{lib}.git"
+  end
+end
 
-case RUBY_VERSION
-when '1.9.2'
-  gem 'ruby-debug19'
-when /^1\.8/
+### dev dependencies
+gem "rake", "0.8.7"
+gem "cucumber", "~> 0.10.2"
+gem "aruba", "~> 0.3.6"
+gem "rcov", "0.9.9", :platforms => :mri
+gem "relish", "0.2.0"
+gem "guard-rspec", "0.1.9"
+gem "growl", "1.0.3"
+gem "nokogiri", "1.4.4"
+
+platforms :mri_18 do
   gem 'ruby-debug'
 end
+
+platforms :mri_19 do
+  gem 'linecache19', '0.5.11' # 0.5.12 cannot install on 1.9.1, and 0.5.11 appears to work with both 1.9.1 & 1.9.2
+  gem 'ruby-debug19'
+  gem 'ruby-debug-base19', RUBY_VERSION == '1.9.1' ? '0.11.23' : '~> 0.11.24'
+end
+
+platforms :mri_18, :mri_19 do
+  gem "rb-fsevent", "~> 0.3.9"
+  gem "ruby-prof", "~> 0.9.2"
+end
+
+platforms :jruby do
+  gem "jruby-openssl"
+end

data/Guardfile

@@ -0,0 +1,5 @@
+guard 'rspec', :version => 2 do
+  watch(/^spec\/(.*)_spec.rb/)
+  watch(/^lib\/(.*)\.rb/)         { |m| "spec/#{m[1]}_spec.rb" }
+  watch(/^spec\/spec_helper.rb/)  { "spec" }
+end

data/License.txt

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2005-2010 The RSpec Development Team
+Copyright (c) 2005 The RSpec Development Team
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -0,0 +1,43 @@
+# RSpec Expectations
+
+rspec-expectations adds `should` and `should_not` to every object and includes
+RSpec::Matchers, a library of standard matchers.
+
+[![build status](http://travis-ci.org/rspec/rspec-expectations.png)](http://travis-ci.org/rspec/rspec-expectations)
+
+## Documentation
+
+The [Cucumber features](http://relishapp.com/rspec/rspec-expectations)
+are the most comprehensive and up-to-date docs for end-users.
+
+The [RDoc](http://rubydoc.info/gems/rspec-expectations/2.3.0/frames) provides
+additional information for contributors and/or extenders.
+
+All of the documentation is open source and a work in progress. If you find it
+lacking or confusing, you can help improve it by submitting requests and
+patches to the [rspec-expectations issue
+tracker](https://github.com/rspec/rspec-expectations/issues).
+
+## Install
+
+    gem install rspec               # for rspec-core, rspec-expectations, rspec-mocks
+    gem install rspec-expecctations # for rspec-expectations only
+
+## Matchers
+
+Matchers are objects used to compose expectations:
+
+    result.should eq("this value")
+
+In that example, `eq("this value")` returns a `Matcher` object that
+compares the actual `result` to the expected `"this value"`.
+
+## Contribute
+
+See [http://github.com/rspec/rspec-dev](http://github.com/rspec/rspec-dev)
+
+## Also see
+
+* [http://github.com/rspec/rspec](http://github.com/rspec/rspec)
+* [http://github.com/rspec/rspec-core](http://github.com/rspec/rspec-core)
+* [http://github.com/rspec/rspec-mocks](http://github.com/rspec/rspec-mocks)

data/Rakefile

@@ -5,20 +5,56 @@ Bundler::GemHelper.install_tasks
 require 'rake'
 require 'rake/rdoctask'
 require 'rspec/core/rake_task'
-require 'cucumber/rake/task'
+require 'rspec/expectations/version'
 
-RSpec::Core::RakeTask.new(:spec)
+begin
+  require 'cucumber/rake/task'
 
-class Cucumber::Rake::Task::ForkedCucumberRunner
-  # When cucumber shells out, we still need it to run in the context of our
-  # bundle.
-  def run
-    sh "bundle exec #{RUBY} " + args.join(" ")
+  class Cucumber::Rake::Task::ForkedCucumberRunner
+    # When cucumber shells out, we still need it to run in the context of our
+    # bundle.
+    def run
+      sh "bundle exec #{RUBY} " + args.join(" ")
+    end
   end
+
+  Cucumber::Rake::Task.new(:cucumber)
+
+  namespace :cucumber do
+    desc "Run cucumber features using rcov"
+    Cucumber::Rake::Task.new :rcov => :cleanup_rcov_files do |t|
+      t.cucumber_opts = %w{--format progress}
+      t.rcov = true
+      t.rcov_opts =  %[-Ilib -Ispec --exclude "gems/*,features"]
+      t.rcov_opts << %[--text-report --sort coverage --aggregate coverage.data]
+    end
+  end
+
+rescue LoadError => e
+  puts "unable to load cucumber, some tasks unavailable"
+  task :cucumber do
+    #no-op
+   end
+end
+
+
+task :cleanup_rcov_files do
+  rm_rf 'coverage.data'
 end
 
-Cucumber::Rake::Task.new do |t|
-  t.cucumber_opts = %w{--format progress}
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = %w[--color]
+end
+
+
+namespace :spec do
+  desc "Run all examples using rcov"
+  RSpec::Core::RakeTask.new :rcov => :cleanup_rcov_files do |t|
+    t.rcov = true
+    t.rcov_opts =  %[-Ilib -Ispec --exclude "gems/*,features"]
+    t.rcov_opts << %[--text-report --sort coverage --no-html --aggregate coverage.data]
+  end
 end
 
 task :default => [:spec, :cucumber]
@@ -30,6 +66,12 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
+desc "Push docs/cukes to relishapp using the relish-client-gem"
+task :relish, :version do |t, args|
+  raise "rake relish[VERSION]" unless args[:version]
+  sh "relish push rspec/rspec-expectations:#{args[:version]}"
+end
+
 task :clobber do
   rm_rf 'doc'
   rm_rf 'pkg'

data/cucumber.yml

@@ -1,3 +1,10 @@
-default: --require features --tags ~@wip --format progress
-wip: --require features --tags @wip:3 --wip features
+<%
+def tags(tag)
+  tags = [tag]
+  tags << "~@ruby-1.9" if RUBY_VERSION.to_f < 1.9
+  tags.join(" --tags ")
+end
+%>
 
+default: --require features --tags <%= tags("~@wip") %> --format progress
+wip: --require features --tags <%= tags("@wip:3") --wip features

data/features/.nav

@@ -0,0 +1,29 @@
+- Upgrade.md
+- Changelog.md
+- customized_message.feature
+- diffing.feature
+- implicit_docstrings.feature
+- built_in_matchers:
+  - be.feature
+  - be_within.feature
+  - equality.feature
+  - exist.feature
+  - expect_change.feature
+  - expect_error.feature
+  - have.feature
+  - include.feature
+  - match.feature
+  - operators.feature
+  - predicates.feature
+  - respond_to.feature
+  - satisfy.feature
+  - throw_symbol.feature
+  - types.feature
+- custom_matchers:
+  - define_matcher.feature
+  - define_diffable_matcher.feature
+  - define_matcher_with_fluent_interface.feature
+  - access_running_example.feature
+  - define_matcher_outside_rspec.feature
+- test_frameworks:
+  - test_unit.feature

data/features/Changelog.md

@@ -0,0 +1,101 @@
+### 2.6.0 / 2011-05-12
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.5.0...v2.6.0)
+
+* Enhancments
+  * `change` matcher accepts Regexps (Robert Davis)
+  * better descriptions for have_xxx matchers (Magnus Bergmark)
+  * range.should cover(*values) (Anders Furseth)
+
+* Bug fixes
+  * Removed non-ascii characters that were choking rcov (Geoffrey Byers)
+  * change matcher dups arrays and hashes so their before/after states can be
+    compared correctly.
+  * Fix the order of inclusion of RSpec::Matchers in
+    Test::Unit::TestCase and MiniTest::Unit::TestCase to prevent a
+    SystemStackError (Myron Marston)
+
+### 2.5.0 / 2011-02-05
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.4.0...v2.5.0)
+
+* Enhancements
+  * `should exist` works with `exist?` or `exists?` (Myron Marston)
+  * `expect { ... }.not_to do_something` (in addition to `to_not`)
+
+* Documentation
+  * improved docs for raise_error matcher (James Almond)
+
+### 2.4.0 / 2011-01-02
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.3.0...v2.4.0)
+
+No functional changes in this release, which was made to align with the
+rspec-core-2.4.0 release.
+
+* Enhancements
+  * improved RDoc for change matcher (Jo Liss)
+
+### 2.3.0 / 2010-12-12
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.2.1...v2.3.0)
+
+* Enhancements
+  * diff strings when include matcher fails (Mike Sassak)
+
+### 2.2.0 / 2010-11-28
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.1.0...v2.2.0)
+
+### 2.1.0 / 2010-11-07
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.0.1...v2.1.0)
+
+* Enhancements
+  * be_within(delta).of(expected) matcher (Myron Marston)
+  * Lots of new Cucumber features (Myron Marston)
+  * Raise error if you try "should != expected" on Ruby-1.9 (Myron Marston)
+  * Improved failure messages from throw_symbol (Myron Marston)
+
+* Bug fixes
+  * Eliminate hard dependency on RSpec::Core (Myron Marston)
+  * have_matcher - use pluralize only when ActiveSupport inflections are indeed
+    defined (Josep M Bach)
+  * throw_symbol matcher no longer swallows exceptions (Myron Marston)
+  * fix matcher chaining to avoid name collisions (Myron Marston)
+
+### 2.0.0 / 2010-10-10
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.0.0.rc...v2.0.0)
+
+* Enhancements
+  * Add match_for_should_not method to matcher DSL (Myron Marston)
+
+* Bug fixes
+  * respond_to matcher works correctly with should_not with multiple methods (Myron Marston)
+  * include matcher works correctly with should_not with multiple values (Myron Marston)
+
+### 2.0.0.rc / 2010-10-05
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.0.0.beta.22...v2.0.0.rc)
+
+* Enhancements
+  * require 'rspec/expectations' in a T::U or MiniUnit suite (Josep M. Bach)
+
+* Bug fixes
+  * change by 0 passes/fails correctly (Len Smith)
+  * Add description to satisfy matcher
+
+### 2.0.0.beta.22 / 2010-09-12
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.0.0.beta.20...v2.0.0.beta.22)
+
+* Enhancements
+  * diffing improvements
+    * diff multiline strings
+    * don't diff single line strings
+    * don't diff numbers (silly)
+    * diff regexp + multiline string
+
+* Bug fixes
+  * should[_not] change now handles boolean values correctly

data/features/README.markdown

@@ -1,12 +1,49 @@
-# Cucumber features
+rspec-expectations is used to define expected outcomes.
 
-RSpec is specified using both RSpec and
-[Cucumber](http://github.com/aslakhellesoy/cucumber). Cucumber provides
-_executable documentation_.  This means that the _.feature_ files below this
-directory serve as specification, documentation _and_ regression tests of the
-behaviour.
+    describe Account do
+      it "has a balance of zero when first created" do
+        Account.new.balance.should eq(Money.new(0))
+      end
+    end
+
+## Basic structure
+
+The basic structure of an rspec expectation is:
+
+    actual.should matcher(expected)
+    actual.should_not matcher(expected)
+
+## `should` and `should_not`
+
+`rspec-expectations` adds `should` and `should_not` to every object in
+the system. These methods each accept a matcher as an argument. This allows
+each matcher to work in a positive or negative mode:
+
+    5.should eq(5)
+    5.should_not eq(4)
+
+## What is a matcher?
+
+A Matcher is any object that responds to the following methods:
+
+    matches?(actual)
+    failure_message_for_should
+
+These methods are also part of the matcher protocol, but are optional:
+
+    does_not_match?(actual)
+    failure_message_for_should_not
+    description
+
+RSpec ships with a number of built-in matchers and a DSL for writing custom
+matchers.
 
 ## Issues
 
-If you find this documentation incomplete or confusing, please [submit an
-issue](http://github.com/rspec/rspec-expectations/issues).
+The documentation for rspec-expectations is a work in progress. We'll be adding
+Cucumber features over time, and clarifying existing ones.  If you have
+specific features you'd like to see added, find the existing documentation
+incomplete or confusing, or, better yet, wish to write a missing Cucumber
+feature yourself, please [submit an
+issue](http://github.com/rspec/rspec-expectations/issues) or a [pull
+request](http://github.com/rspec/rspec-expectations).

data/features/built_in_matchers/README.md

@@ -0,0 +1,71 @@
+## Object identity
+
+    actual.should equal(expected) # passes if actual.equal?(expected)
+    
+## Object equivalence
+
+    actual.should == expected   # passes if actual == expected
+    actual.should eql(expected) # passes if actual.eql?(expected)
+
+## Optional APIs for identity/equivalence
+
+    actual.should eq(expected)  # passes if actual == expected
+    actual.should be(expected)  # passes if actual.equal?(expected)
+
+## Comparisons
+
+    actual.should be >  expected
+    actual.should be >= expected
+    actual.should be <= expected
+    actual.should be <  expected
+    actual.should =~ /expression/
+    actual.should match(/expression/)
+    actual.should be_within(delta).of(expected)
+
+## Types/classes
+
+    actual.should be_instance_of(expected)
+    actual.should be_kind_of(expected)
+
+## Truthiness and existentialism
+
+    actual.should be_true  # passes if actual is anything but nil or false
+    actual.should be_false # passes if actual is nil or false
+    actual.should be_nil   # passes if actual is nil
+    actual.should be       # passes if actual is not nil
+
+## Expecting errors
+
+    expect { ... }.to raise_error
+    expect { ... }.to raise_error(ErrorClass)
+    expect { ... }.to raise_error("message")
+    expect { ... }.to raise_error(ErrorClass, "message")
+
+## Expecting throws
+
+    expect { ... }.to throw_symbol
+    expect { ... }.to throw_symbol(:symbol)
+    expect { ... }.to throw_symbol(:symbol, 'value')
+
+## Predicate matchers
+
+    actual.should be_xxx # passes if actual.xxx?
+
+### Example
+
+    [].should be_empty # passes because [].empty? returns true
+
+## Collection membership
+
+    actual.should include(expected)
+
+### Examples
+
+    [1,2,3].should include(1)
+    [1,2,3].should include(1, 2)
+    {:a => 'b'}.should include(:a => 'b')
+    "this string".should include("is str")
+
+## Ranges (1.9 only)
+
+    (1..10).should cover(3)

data/features/built_in_matchers/be.feature

@@ -0,0 +1,135 @@
+Feature: "be" matchers
+
+  There are several related "be" matchers:
+
+      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_nil   # passes if obj is nil
+      obj.should be       # passes if obj is not nil
+
+  Scenario: be_true matcher
+    Given a file named "be_true_spec.rb" with:
+      """
+      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 }
+
+        # 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 }
+      end
+      """
+    When I run `rspec be_true_spec.rb`
+    Then the output should contain all of these:
+      | 10 examples, 5 failures       |
+      | expected true not to be true  |
+      | expected 7 not to be true     |
+      | expected "foo" not to be true |
+      | expected nil to be true       |
+      | expected false to be true     |
+
+  Scenario: be_false matcher
+    Given a file named "be_false_spec.rb" with:
+      """
+      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 }
+
+        # 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 }
+      end
+      """
+    When I run `rspec be_false_spec.rb`
+    Then the output should contain all of these:
+      | 10 examples, 5 failures        |
+      | expected nil not to be false   |
+      | expected false not to be false |
+      | expected true to be false      |
+      | expected 7 to be false         |
+      | expected "foo" to be false     |
+
+  Scenario: be_nil matcher
+    Given a file named "be_nil_spec.rb" with:
+      """
+      describe "be_nil matcher" do
+        specify { nil.should be_nil }
+        specify { false.should_not be_nil }
+        specify { true.should_not be_nil }
+        specify { 7.should_not be_nil }
+        specify { "foo".should_not be_nil }
+
+        # deliberate failures
+        specify { nil.should_not be_nil }
+        specify { false.should be_nil }
+        specify { true.should be_nil }
+        specify { 7.should be_nil }
+        specify { "foo".should be_nil }
+      end
+      """
+    When I run `rspec be_nil_spec.rb`
+    Then the output should contain "10 examples, 5 failures"
+    And the output should contain:
+      """
+             expected: not nil
+                  got: nil
+      """
+    And the output should contain:
+      """
+             expected: nil
+                  got: false
+      """
+    And the output should contain:
+      """
+             expected: nil
+                  got: true
+      """
+    And the output should contain:
+      """
+             expected: nil
+                  got: 7
+      """
+    And the output should contain:
+      """
+             expected: nil
+                  got: "foo"
+      """
+
+  Scenario: be matcher
+    Given a file named "be_spec.rb" with:
+      """
+      describe "be_matcher" do
+        specify { true.should be }
+        specify { 7.should be }
+        specify { "foo".should be }
+        specify { nil.should_not be }
+        specify { false.should_not be }
+
+        # deliberate failures
+        specify { true.should_not be }
+        specify { 7.should_not be }
+        specify { "foo".should_not be }
+        specify { nil.should be }
+        specify { false.should be }
+      end
+      """
+    When I run `rspec be_spec.rb`
+    Then the output should contain all of these:
+      | 10 examples, 5 failures             |
+      | expected true to evaluate to false  |
+      | expected 7 to evaluate to false     |
+      | expected "foo" to evaluate to false |
+      | expected nil to evaluate to true    |
+      | expected false to evaluate to true  |

data/features/built_in_matchers/be_within.feature

@@ -0,0 +1,43 @@
+Feature: be_within matcher
+
+  Normal equality expectations do not work well for floating point values.
+  Consider this irb session:
+
+      > radius = 3
+        => 3 
+      > area_of_circle = radius * radius * Math::PI
+        => 28.2743338823081 
+      > area_of_circle == 28.2743338823081
+        => false 
+
+  Instead, you should use the be_within matcher to check that the value
+  is within a delta of your expected value:
+
+      area_of_circle.should be_within(0.1).of(28.3)
+
+  Note that the difference between the actual and expected values must be
+  smaller than your delta; if it is equal, the matcher will fail.
+
+  Scenario: basic usage
+    Given a file named "be_within_matcher_spec.rb" with:
+      """
+      describe 27.5 do
+        it { should be_within(0.5).of(27.9) }
+        it { should be_within(0.5).of(27.1) }
+        it { should_not be_within(0.5).of(28) }
+        it { should_not be_within(0.5).of(27) }
+
+        # deliberate failures
+        it { should_not be_within(0.5).of(27.9) }
+        it { should_not be_within(0.5).of(27.1) }
+        it { should be_within(0.5).of(28) }
+        it { should be_within(0.5).of(27) }
+      end
+      """
+    When I run `rspec be_within_matcher_spec.rb`
+    Then the output should contain all of these:
+      | 8 examples, 4 failures                     |
+      | expected 27.5 not to be within 0.5 of 27.9 |
+      | expected 27.5 not to be within 0.5 of 27.1 |
+      | expected 27.5 to be within 0.5 of 28       |
+      | expected 27.5 to be within 0.5 of 27       |