shoulda-matchers 3.1.0 → 5.2.0

data/README.md

@@ -1,17 +1,358 @@
-# Shoulda Matchers [![Gem Version][version-badge]][rubygems] [![Build Status][travis-badge]][travis] ![Downloads][downloads-badge]
+# Shoulda Matchers [![Gem Version][version-badge]][rubygems] [![Build Status][github-actions-badge]][github-actions] [![Total Downloads][downloads-total]][rubygems] [![Downloads][downloads-badge]][rubygems]
 
-Shoulda Matchers provides RSpec- and Minitest-compatible one-liners that test
-common Rails functionality. These tests would otherwise be much longer, more
+[version-badge]: https://img.shields.io/gem/v/shoulda-matchers.svg
+[rubygems]: https://rubygems.org/gems/shoulda-matchers
+[github-actions-badge]: https://img.shields.io/github/workflow/status/thoughtbot/shoulda-matchers/Test
+[github-actions]: https://github.com/thoughtbot/shoulda-matchers/actions
+[downloads-total]: https://img.shields.io/gem/dt/shoulda-matchers.svg
+[downloads-badge]: https://img.shields.io/gem/dtv/shoulda-matchers.svg
+[downloads-badge]: https://img.shields.io/gem/dtv/shoulda-matchers.svg
+
+[![shoulda-matchers][logo]][website]
+
+[logo]: https://matchers.shoulda.io/images/shoulda-matchers-logo.png
+[website]: https://matchers.shoulda.io/
+
+Shoulda Matchers provides RSpec- and Minitest-compatible one-liners to test
+common Rails functionality that, if written by hand, would be much longer, more
 complex, and error-prone.
 
-[View the official documentation for the latest version (3.0.0).][rubydocs]
+## Quick links
+
+📖 **[Read the documentation for the latest version][rubydocs].**
+📢 **[See what's changed in recent versions][changelog].**
+
+[rubydocs]: https://matchers.shoulda.io/docs
+[changelog]: CHANGELOG.md
+
+## Table of contents
+
+* [Getting started](#getting-started)
+   * [RSpec](#rspec)
+   * [Minitest](#minitest)
+* [Usage](#usage)
+  * [On the subject of `subject`](#on-the-subject-of-subject)
+  * [Availability of RSpec matchers in example groups](#availability-of-rspec-matchers-in-example-groups)
+  * [`should` vs `is_expected.to`](#should-vs-is_expectedto)
+* [Matchers](#matchers)
+   * [ActiveModel matchers](#activemodel-matchers)
+   * [ActiveRecord matchers](#activerecord-matchers)
+   * [ActionController matchers](#actioncontroller-matchers)
+   * [Independent matchers](#independent-matchers)
+* [Extensions](#extensions)
+* [Contributing](#contributing)
+* [Compatibility](#compatibility)
+* [Versioning](#versioning)
+* [Team](#team)
+* [Copyright/License](#copyright-license)
+* [About thoughtbot](#about-thoughtbot)
+
+## Getting started
+
+### RSpec
+
+Start by including `shoulda-matchers` in your Gemfile:
+
+```ruby
+group :test do
+  gem 'shoulda-matchers', '~> 5.0'
+end
+```
+
+Then run `bundle install`.
+
+Now you need to configure the gem by telling it:
+
+* which matchers you want to use in your tests
+* that you're using RSpec so that it can make those matchers available in
+  your example groups
+
+#### Rails apps
+
+If you're working on a Rails app, simply place this at the bottom of
+`spec/rails_helper.rb` (or in a support file if you so choose):
+
+```ruby
+Shoulda::Matchers.configure do |config|
+  config.integrate do |with|
+    with.test_framework :rspec
+    with.library :rails
+  end
+end
+```
+
+#### Non-Rails apps
+
+If you're not working on a Rails app, but you still make use of ActiveRecord or
+ActiveModel in your project, you can still use this gem too! In that case,
+you'll want to place the following configuration at the bottom of
+`spec/spec_helper.rb`:
+
+```ruby
+Shoulda::Matchers.configure do |config|
+  config.integrate do |with|
+    with.test_framework :rspec
+
+    # Keep as many of these lines as are necessary:
+    with.library :active_record
+    with.library :active_model
+  end
+end
+```
+
+### Minitest
+
+If you're using our umbrella gem [Shoulda], then make sure that you're using the
+latest version:
+
+```ruby
+group :test do
+  gem 'shoulda', '~> 4.0'
+end
+```
+
+[Shoulda]: https://github.com/thoughtbot/shoulda
+
+Otherwise, add `shoulda-matchers` to your Gemfile:
+
+```ruby
+group :test do
+  gem 'shoulda-matchers', '~> 5.0'
+end
+```
+
+Then run `bundle install`.
+
+Now you need to configure the gem by telling it:
+
+* which matchers you want to use in your tests
+* that you're using Minitest so that it can make those matchers available in
+  your test case classes
+
+#### Rails apps
+
+If you're working on a Rails app, simply place this at the bottom of
+`test/test_helper.rb`:
+
+```ruby
+Shoulda::Matchers.configure do |config|
+  config.integrate do |with|
+    with.test_framework :minitest
+    with.library :rails
+  end
+end
+```
+
+#### Non-Rails apps
+
+If you're not working on a Rails app, but you still make use of ActiveRecord or
+ActiveModel in your project, you can still use this gem too! In that case,
+you'll want to place the following configuration at the bottom of
+`test/test_helper.rb`:
+
+```ruby
+Shoulda::Matchers.configure do |config|
+  config.integrate do |with|
+    with.test_framework :minitest
+
+    # Keep as many of these lines as are necessary:
+    with.library :active_record
+    with.library :active_model
+  end
+end
+```
+
+## Usage
+
+Most of the matchers provided by this gem are useful in a Rails context, and as
+such, can be used for different parts of a Rails app:
+
+* [database models backed by ActiveRecord](#activemodel-matchers)
+* [non-database models, form objects, etc. backed by
+  ActiveModel](#activerecord-matchers)
+* [controllers](#actioncontroller-matchers)
+* [routes](#routing-matchers) (RSpec only)
+* [Rails-specific features like `delegate`](#independent-matchers)
+
+As the name of the gem indicates, most matchers are designed to be used in
+"one-liner" form using the `should` macro, a special directive available in both
+RSpec and [Shoulda]. For instance, a model test case may look something like:
+
+``` ruby
+# RSpec
+RSpec.describe MenuItem, type: :model do
+  describe 'associations' do
+    it { should belong_to(:category).class_name('MenuCategory') }
+  end
+
+  describe 'validations' do
+    it { should validate_presence_of(:name) }
+    it { should validate_uniqueness_of(:name).scoped_to(:category_id) }
+  end
+end
+
+# Minitest (Shoulda)
+class MenuItemTest < ActiveSupport::TestCase
+  context 'associations' do
+    should belong_to(:category).class_name('MenuCategory')
+  end
+
+  context 'validations' do
+    should validate_presence_of(:name)
+    should validate_uniqueness_of(:name).scoped_to(:category_id)
+  end
+end
+```
+
+[See below](#matchers) for the full set of matchers that you can use.
+
+### On the subject of `subject`
+
+For both RSpec and Shoulda, the **subject** is an implicit reference to the
+object under test, and through the use of `should` as demonstrated above, all of
+the matchers make use of `subject` internally when they are run. A `subject` is
+always set automatically by your test framework in any given test case; however,
+in certain cases it can be advantageous to override it. For instance, when
+testing validations in a model, it is customary to provide a valid model instead
+of a fresh one:
+
+``` ruby
+# RSpec
+RSpec.describe Post, type: :model do
+  describe 'validations' do
+    # Here we're using FactoryBot, but you could use anything
+    subject { build(:post) }
+
+    it { should validate_presence_of(:title) }
+  end
+end
+
+# Minitest (Shoulda)
+class PostTest < ActiveSupport::TestCase
+  context 'validations' do
+    subject { build(:post) }
+
+    should validate_presence_of(:title)
+  end
+end
+```
+
+When overriding the subject in this manner, then, it's important to provide the
+correct object. **When in doubt, provide an instance of the class under test.**
+This is particularly necessary for controller tests, where it is easy to
+accidentally write something like:
+
+``` ruby
+RSpec.describe PostsController, type: :controller do
+  describe 'GET #index' do
+    subject { get :index }
+
+    # This may work...
+    it { should have_http_status(:success) }
+    # ...but this will not!
+    it { should permit(:title, :body).for(:post) }
+  end
+end
+```
+
+In this case, you would want to use `before` rather than `subject`:
+
+``` ruby
+RSpec.describe PostsController, type: :controller do
+  describe 'GET #index' do
+    before { get :index }
+
+    # Notice that we have to assert have_http_status on the response here...
+    it { expect(response).to have_http_status(:success) }
+    # ...but we do not have to provide a subject for render_template
+    it { should render_template('index') }
+  end
+end
+```
+
+### Availability of RSpec matchers in example groups
+
+#### Rails projects
+
+If you're using RSpec, then you're probably familiar with the concept of example
+groups. Example groups can be assigned tags order to assign different behavior
+to different kinds of example groups. This comes into play especially when using
+`rspec-rails`, where, for instance, controller example groups, tagged with
+`type: :controller`, are written differently than request example groups, tagged
+with `type: :request`. This difference in writing style arises because
+`rspec-rails` mixes different behavior and methods into controller example
+groups vs. request example groups.
+
+Relying on this behavior, Shoulda Matchers automatically makes certain matchers
+available in certain kinds of example groups:
+
+* ActiveRecord and ActiveModel matchers are available only in model example
+  groups, i.e., those tagged with `type: :model` or in files located under
+  `spec/models`.
+* ActionController matchers are available only in controller example groups,
+  i.e., those tagged with `type: :controller` or in files located under
+  `spec/controllers`.
+* The `route` matcher is available in routing example groups, i.e., those
+  tagged with `type: :routing` or in files located under `spec/routing`.
+* Independent matchers are available in all example groups.
+
+As long as you're using Rails, you don't need to worry about these details —
+everything should "just work".
+
+#### Non-Rails projects
+
+**What if you are using ActiveModel or ActiveRecord outside of Rails, however,
+and you want to use model matchers in a certain example group?** Then you'll
+need to manually include the module that holds those matchers into that example
+group. For instance, you might have to say:
+
+``` ruby
+RSpec.describe MySpecialModel do
+  include Shoulda::Matchers::ActiveModel
+  include Shoulda::Matchers::ActiveRecord
+end
+```
+
+If you have a lot of similar example groups in which you need to do this, then
+you might find it more helpful to tag your example groups appropriately, then
+instruct RSpec to mix these modules into any example groups that have that tag.
+For instance, you could add this to your `rails_helper.rb`:
+
+```ruby
+RSpec.configure do |config|
+  config.include(Shoulda::Matchers::ActiveModel, type: :model)
+  config.include(Shoulda::Matchers::ActiveRecord, type: :model)
+end
+```
+
+And from then on, you could say:
+
+```ruby
+RSpec.describe MySpecialModel, type: :model do
+  # ...
+end
+```
+
+### `should` vs `is_expected.to`
 
-----
+In this README and throughout the documentation, you'll notice that we use the
+`should` form of RSpec's one-liner syntax over `is_expected.to`. Beside being
+the namesake of the gem itself, this is our preferred syntax as it's short and
+sweet. But if you prefer to use `is_expected.to`, you can do that too:
+
+```ruby
+RSpec.describe Person, type: :model do
+  it { is_expected.to validate_presence_of(:name) }
+end
+```
+
+## Matchers
+
+Here is the full list of matchers that ship with this gem. If you need details
+about any of them, make sure to [consult the documentation][rubydocs]!
 
 ### ActiveModel matchers
 
-* **[allow_mass_assignment_of](lib/shoulda/matchers/active_model/allow_mass_assignment_of_matcher.rb)**
-  tests usage of Rails 3's `attr_accessible` and `attr_protected` macros.
 * **[allow_value](lib/shoulda/matchers/active_model/allow_value_matcher.rb)**
   tests that an attribute is valid or invalid if set to one or more values.
   *(Aliased as #allow_values.)*
@@ -42,18 +383,26 @@ complex, and error-prone.
   tests your `belongs_to` associations.
 * **[define_enum_for](lib/shoulda/matchers/active_record/define_enum_for_matcher.rb)**
   tests usage of the `enum` macro.
-* **[have_and_belong_to_many](lib/shoulda/matchers/active_record/association_matcher.rb)**
+* **[have_and_belong_to_many](lib/shoulda/matchers/active_record/association_matcher.rb#L827)**
   tests your `has_and_belongs_to_many` associations.
 * **[have_db_column](lib/shoulda/matchers/active_record/have_db_column_matcher.rb)**
   tests that the table that backs your model has a specific column.
 * **[have_db_index](lib/shoulda/matchers/active_record/have_db_index_matcher.rb)**
   tests that the table that backs your model has an index on a specific column.
-* **[have_many](lib/shoulda/matchers/active_record/association_matcher.rb)**
+* **[have_implicit_order_column](lib/shoulda/matchers/active_record/have_implicit_order_column.rb)**
+  tests usage of `implicit_order_column`.
+* **[have_many](lib/shoulda/matchers/active_record/association_matcher.rb#L328)**
   tests your `has_many` associations.
-* **[have_one](lib/shoulda/matchers/active_record/association_matcher.rb)**
+* **[have_many_attached](lib/shoulda/matchers/active_record/have_attached_matcher.rb)**
+  tests your `has_many_attached` associations.
+* **[have_one](lib/shoulda/matchers/active_record/association_matcher.rb#L598)**
   tests your `has_one` associations.
+* **[have_one_attached](lib/shoulda/matchers/active_record/have_attached_matcher.rb)**
+  tests your `has_one_attached` associations.
 * **[have_readonly_attribute](lib/shoulda/matchers/active_record/have_readonly_attribute_matcher.rb)**
   tests usage of the `attr_readonly` macro.
+* **[have_rich_text](lib/shoulda/matchers/active_record/have_rich_text_matcher.rb)**
+  tests your `has_rich_text` associations.
 * **[serialize](lib/shoulda/matchers/active_record/serialize_matcher.rb)** tests
   usage of the `serialize` macro.
 * **[validate_uniqueness_of](lib/shoulda/matchers/active_record/validate_uniqueness_of_matcher.rb)**
@@ -81,15 +430,17 @@ complex, and error-prone.
   makes assertions on the `session` hash.
 * **[set_flash](lib/shoulda/matchers/action_controller/set_flash_matcher.rb)**
   makes assertions on the `flash` hash.
-* **[use_after_action](lib/shoulda/matchers/action_controller/callback_matcher.rb#L79)**
-  tests that an `after_action` callback is defined in your controller. *(Aliased
-  as #use_after_filter.)*
-* **[use_around_action](lib/shoulda/matchers/action_controller/callback_matcher.rb#L129)**
-  tests that an `around_action` callback is defined in your controller. *(Aliased
-  as #use_around_filter.)*
-* **[use_before_action](lib/shoulda/matchers/action_controller/callback_matcher.rb#L54)**
-  tests that a `before_action` callback is defined in your controller. *(Aliased
-  as #use_before_filter.)*
+* **[use_after_action](lib/shoulda/matchers/action_controller/callback_matcher.rb#L29)**
+  tests that an `after_action` callback is defined in your controller.
+* **[use_around_action](lib/shoulda/matchers/action_controller/callback_matcher.rb#L75)**
+  tests that an `around_action` callback is defined in your controller.
+* **[use_before_action](lib/shoulda/matchers/action_controller/callback_matcher.rb#L4)**
+  tests that a `before_action` callback is defined in your controller.
+
+### Routing matchers
+
+* **[route](lib/shoulda/matchers/action_controller/route_matcher.rb)** tests
+  your routes.
 
 ### Independent matchers
 
@@ -97,242 +448,66 @@ complex, and error-prone.
   tests that an object forwards messages to other, internal objects by way of
   delegation.
 
-## Getting started
-
-### RSpec
-
-Include `shoulda-matchers` in your Gemfile:
-
-``` ruby
-group :test do
-  gem 'shoulda-matchers', '~> 3.0'
-end
-```
-
-[Then, configure the gem to integrate with RSpec](#configuration).
-
-Now you can use matchers in your tests. For instance a model test might look
-like this:
-
-``` ruby
-describe Person do
-  it { should validate_presence_of(:name) }
-end
-```
-
-#### Availability of matchers in various example groups
-
-Since shoulda-matchers provides four categories of matchers, there are four
-different levels where you can use these matchers:
-
-* ActiveRecord and ActiveModel matchers are available only in model example
-  groups, i.e., those tagged with `type: :model` or in files located under
-  `spec/models`.
-* ActionController matchers are available only in controller example groups,
-  i.e., those tagged with `type: :controller` or in files located under
-  `spec/controllers`.
-* The `route` matcher is available also in routing example groups, i.e., those
-  tagged with `type: :routing` or in files located under `spec/routing`.
-* Independent matchers are available in all example groups.
-
-**If you are using ActiveModel or ActiveRecord outside of Rails** and you want
-to use model matchers in certain example groups, you'll need to manually include
-them. Here's a good way of doing that:
-
-``` ruby
-RSpec.configure do |config|
-  config.include(Shoulda::Matchers::ActiveModel, type: :model)
-  config.include(Shoulda::Matchers::ActiveRecord, type: :model)
-end
-```
-
-Then you can say:
-
-``` ruby
-describe MyModel, type: :model do
-  # ...
-end
-```
-
-#### `should` vs `is_expected.to`
+## Extensions
 
-Note that in this README and throughout the documentation we're using the
-`should` form of RSpec's one-liner syntax over `is_expected.to`. The `should`
-form works regardless of how you've configured RSpec -- meaning you can still
-use it even when using the `expect` syntax. But if you prefer to use
-`is_expected.to`, you can do that too:
+Over time our community has created extensions to Shoulda Matchers. If you've
+created something that you want to share, please [let us know][new-issue]!
 
-``` ruby
-describe Person do
-  it { is_expected.to validate_presence_of(:name) }
-end
-```
-
-### Minitest
-
-Shoulda Matchers was originally a component of [Shoulda][shoulda], a gem that
-also provides `should` and `context` syntax via
-[`shoulda-context`][shoulda-context].
-
-At the moment, `shoulda` has not been updated to support `shoulda-matchers` 3.0,
-so you'll want to add the following to your Gemfile:
-
-```ruby
-group :test do
-  gem 'shoulda', '~> 3.5'
-  gem 'shoulda-matchers', '~> 2.0'
-end
-```
-
-[Then, configure the gem to integrate with Minitest](#configuration).
-
-Now you can use matchers in your tests. For instance a model test might look
-like this:
-
-``` ruby
-class PersonTest < ActiveSupport::TestCase
-  should validate_presence_of(:name)
-end
-```
-
-### Configuration
-
-Before you can use Shoulda Matchers, you'll need to tell it a couple of things:
-
-* Which test framework you're using
-* Which portion of the matchers you want to use
-
-You can supply this information by using a configuration block. Place the
-following in `rails_helper.rb` (if you're using RSpec) or `test_helper.rb` (if
-you're using Minitest):
-
-``` ruby
-Shoulda::Matchers.configure do |config|
-  config.integrate do |with|
-    # Choose a test framework:
-    with.test_framework :rspec
-    with.test_framework :minitest
-    with.test_framework :minitest_4
-    with.test_framework :test_unit
-
-    # Choose one or more libraries:
-    with.library :active_record
-    with.library :active_model
-    with.library :action_controller
-    # Or, choose the following (which implies all of the above):
-    with.library :rails
-  end
-end
-```
-
-## Running tests
-
-### Unit tests
-
-Unit tests are the most common kind of tests in this gem, and the best way to
-run them is by using [Zeus].
-
-You'll want to run `zeus start` in one shell, then in another shell, instead of
-using `rspec` to run tests, you can use `zeus rspec`. So for instance, you might
-say:
-
-```
-zeus rspec spec/unit/shoulda/matchers/active_model/validate_inclusion_of_matcher_spec.rb
-```
-
-As a shortcut, you can also drop the initial part of the path and say this
-instead:
+* **[shoulda-matchers-cucumber]** – Adds support for using Shoulda Matchers in
+  Cucumber tests.
 
-```
-zeus rspec active_model/validate_inclusion_of_matcher_spec.rb
-```
-
-### Acceptance tests
+[new-issue]: https://github.com/thoughtbot/shoulda-matchers/issues/new
+[shoulda-matchers-cucumber]: https://github.com/majioa/shoulda-matchers-cucumber
 
-The gem uses [Appraisal] to test against multiple versions of Rails and Ruby.
-This means that if you're trying to run a single test file, you'll need to
-specify which appraisal to use. For instance, you can't simply say:
-
-```
-rspec spec/acceptance/active_model_integration_spec.rb
-```
-
-Instead, you need to say
-
-```
-bundle exec appraisal 4.2 rspec spec/acceptance/active_model_integration_spec.rb
-```
-
-### All tests
-
-You can run all tests by saying:
-
-```
-bundle exec rake
-```
-
-## Generating documentation
-
-YARD is used to generate documentation, which can be viewed [online][rubydocs].
-You can preview changes you make to the documentation locally by running
+## Contributing
 
-    yard doc
+Have a fix for a problem you've been running into or an idea for a new feature
+you think would be useful? Take a look at the [Contributing
+document](CONTRIBUTING.md) for instructions on setting up the repo on your
+machine, understanding the codebase, and creating a good pull request.
 
-from this directory. Then, open `doc/index.html` in your browser.
+## Compatibility
 
-If you want to be able to regenerate the docs as you work without having to run
-`yard doc` over and over again, keep this command running in a separate terminal
-session:
+Shoulda Matchers is tested and supported against Ruby 2.6+, Rails
+5.2+, RSpec 3.x, and Minitest 5.x.
 
-    rake docs:autogenerate
+- For Ruby < 2.4 and Rails < 4.1 compatibility, please use [v3.1.3][v3.1.3].
+- For Ruby < 3.0 and Rails < 6.1 compatibility, please use [v4.5.1][v4.5.1].
 
-## Contributing
+[v3.1.3]: https://github.com/thoughtbot/shoulda-matchers/tree/v3.1.3
+[v4.5.1]: https://github.com/thoughtbot/shoulda-matchers/tree/v4.5.1
 
-Shoulda Matchers is open source, and we are grateful for
-[everyone][contributors] who's contributed so far.
+## Versioning
 
-If you'd like to contribute, please take a look at the
-[instructions](CONTRIBUTING.md) for installing dependencies and crafting a good
-pull request.
+Shoulda Matchers follows Semantic Versioning 2.0 as defined at
+<https://semver.org>.
 
-## Compatibility
+## Team
 
-Shoulda Matchers is tested and supported against Rails 4.x, RSpec 3.x, Minitest
-5, Minitest 4, and Ruby 2.x.
+Shoulda Matchers is maintained by [Elliot Winkler][mcmire] and [Gui
+Albuk][guialbuk].
 
-## Versioning
+[mcmire]: https://github.com/mcmire
+[guialbuk]: https://github.com/guialbuk
 
-Shoulda Matchers follows Semantic Versioning 2.0 as defined at
-<http://semver.org>.
+## Copyright/License
 
-## License
+Shoulda Matchers is copyright © 2006-2022 Tammer Saleh and [thoughtbot,
+inc][thoughtbot-website]. It is free and opensource software and may be
+redistributed under the terms specified in the [LICENSE](LICENSE) file.
 
-Shoulda Matchers is copyright © 2006-2016
-[thoughtbot, inc](https://thoughtbot.com/). It is free software,
-and may be redistributed under the terms specified in the
-[MIT-LICENSE](MIT-LICENSE) file.
+[thoughtbot-website]: https://thoughtbot.com
 
 ## About thoughtbot
 
-![thoughtbot](https://thoughtbot.com/logo.png)
+![thoughtbot][thoughtbot-logo]
+
+[thoughtbot-logo]: https://presskit.thoughtbot.com/images/thoughtbot-logo-for-readmes.svg
 
-Shoulda Matchers is maintained and funded by thoughtbot, inc.
 The names and logos for thoughtbot are trademarks of thoughtbot, inc.
 
-We are passionate about open source software.
-See [our other projects][community].
-We are [available for hire][hire].
+We are passionate about open source software. See [our other
+projects][community]. We are [available for hire][hire].
 
 [community]: https://thoughtbot.com/community?utm_source=github
 [hire]: https://thoughtbot.com?utm_source=github
-[version-badge]: http://img.shields.io/gem/v/shoulda-matchers.svg
-[rubygems]: http://rubygems.org/gems/shoulda-matchers
-[travis-badge]: http://img.shields.io/travis/thoughtbot/shoulda-matchers/master.svg
-[travis]: http://travis-ci.org/thoughtbot/shoulda-matchers
-[downloads-badge]: http://img.shields.io/gem/dtv/shoulda-matchers.svg
-[rubydocs]: http://matchers.shoulda.io/docs
-[contributors]: https://github.com/thoughtbot/shoulda-matchers/contributors
-[shoulda]: http://github.com/thoughtbot/shoulda
-[shoulda-context]: http://github.com/thoughtbot/shoulda-context
-[Zeus]: https://github.com/burke/zeus
-[Appraisal]: https://github.com/thoughtbot/appraisal