rspec-sleeping_king_studios 2.6.0 → 2.7.0.rc.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c218158ac4229d6cd818cec2837832e27086b1407bc54a90b43921be5ad6ef2d
-  data.tar.gz: 1afecef7b021d634b9203b8bab2c72d2faed3498a92eac0081ffab0f2ee4a674
+  metadata.gz: 6c41b78a115cc4c2c5d876a2841738696c233e394ff10a965200636bb9146cb4
+  data.tar.gz: 51b7c5c228673431eb1c550cdf51291966527ff99664feff835f5b9455534aa0
 SHA512:
-  metadata.gz: b59b280dd97fd18691887d504407c0a70e849a0e9cca3cff65f71078b155050eb0c2590cea2fb5cb192af8c3951f50798b8bc22a3832d58d679a761ab32f4b8a
-  data.tar.gz: b71d3fb856bf0eecb962219edc68103b49b3d71e42699d677db42432f52ef67d1ac97e9232f51c01d807654f1e58d30ded38b9c66fb7ba27b55783d375c1271e
+  metadata.gz: e4680d113beb15829ad1af0cf6879d1d7ebc5a9764accab33fe847233328b8d70b5456cb64307bef4999b5c7cb95da48b867a008664e67b101a63cca2dff31cd
+  data.tar.gz: 3025e278333fb4aa95efb9473a11cb410b76a0f2e0adce1cb2b3709f20d6cb3b2f25e23fcd9c11468177f611aed7a3faaca89c96696a45c4c7379f04218a7603

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 2.7.0
+
+### Concerns
+
+Implemented RSpec::SleepingKingStudios::Contract and the IncludeContract concern. These provide a mechanism for documenting and sharing specifications between projects.
+
+### Matchers
+
+Renamed the `#alias_method` matcher to `#have_aliased_method`, and renamed the AliasMethodMatcher to HaveAliasedMethodMatcher. Using the older matcher will trigger a deprecation warning.
+
 ## 2.6.0
 
 Deprecated the DelegateMethod matcher. Use `rspec-mocks` expectations instead.

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+merlin@sleepingkingstudios.com.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+[https://www.contributor-covenant.org/version/2/0/code_of_conduct.html][v2.0].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available
+at [https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.0]: https://www.contributor-covenant.org/version/2/0/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/DEVELOPMENT.md

@@ -1,9 +1,5 @@
 # Development Notes
 
-## Version 2.6
-
-- Deprecate `delegate_method` matcher, `include` matcher with block.
-
 ## Version 3.0
 
 - Extract out Rails-specific matchers to RSpec::SleepingKingStudios::Rails.

data/README.md

@@ -2,31 +2,38 @@
 
 A collection of matchers and extensions to ease TDD/BDD using RSpec. Extends built-in matchers with new functionality, such as support for Ruby 2.0+ keyword arguments, and adds new matchers for testing boolean-ness, object reader/writer properties, object constructor arguments, ActiveModel validations, and more. Also defines shared example groups for more expressive testing.
 
-## Support
+## About
 
-RSpec::SleepingKingStudios is tested against RSpec 3.3 through 3.7.
+### Compatibility
 
-Currently, the following versions of Ruby are officially supported:
+RSpec::SleepingKingStudios is tested against the following dependencies:
 
-* 2.4
-* 2.5
-* 2.6
+- Ruby (MRI) 2.6 through 3.0
+- RSpec versions 3.4 through 3.10
+- ActiveModel versions 3.0 through 6.1
 
-For Ruby 2.0 support, use version 2.1 or earlier: `gem "rspec-sleeping_king_studios", "~> 2.1.1"`.
+### Documentation
 
-For RSpec 3.0 to 3.2 support, use version 2.2 or earlier: `gem "rspec-sleeping_king_studios", "~> 2.2.2"`.
+Documentation is generated using [YARD](https://yardoc.org/), and can be generated locally using the `yard` gem.
 
-If you require a previous version of Ruby or RSpec, the 1.0 branch supports Ruby 1.9.3 and RSpec 2: `gem "rspec-sleeping_king_studios", "~> 1.0.1"`. However, changes from 2.0 and higher will not be backported.
+### License
 
-## Contribute
+Copyright (c) 2013-2021 Rob Smith
 
-### GitHub
+RSpec::SleepingKingStudios is released under the [MIT License](https://opensource.org/licenses/MIT).
+
+### Contribute
 
 The canonical repository for this gem is located at https://github.com/sleepingkingstudios/rspec-sleeping_king_studios.
 
-### A Note From The Developer
+To report a bug or submit a feature request, please use the [Issue Tracker](https://github.com/sleepingkingstudios/rspec-sleeping_king_studios/issues).
+
+To contribute code, please fork the repository, make the desired updates, and then provide a [Pull Request](https://github.com/sleepingkingstudios/rspec-sleeping_king_studios/pulls). Pull requests must include appropriate tests for consideration, and all code must be properly formatted.
+
+### Code of Conduct
+
+Please note that the `RSpec::SleepingKingStudios` project is released with a [Contributor Code of Conduct](https://github.com/sleepingkingstudios/rspec-sleeping_king_studios/blob/master/CODE_OF_CONDUCT.md). By contributing to this project, you agree to abide by its terms.
 
-Hi, I'm Rob Smith, a Ruby Engineer and the developer of this library. I use these tools every day, but they're not just written for me. If you find this project helpful in your own work, or if you have any questions, suggestions or critiques, please feel free to get in touch! I can be reached on GitHub (see above, and feel encouraged to submit bug reports or merge requests there) or via email at `merlin@sleepingkingstudios.com`. I look forward to hearing from you!
 
 ## Configuration
 
@@ -149,6 +156,113 @@ Sets the value of the named constant to the specified value within the context o
 
 Creates a new class with the specified base class and sets the value of the named constant to the created class within the context of the current example.
 
+<a id="include-contract"></a>
+
+### Include Contract
+
+```ruby
+require 'rspec/sleepingkingstudios/concerns/include_contract'
+```
+
+Defines helpers for including reusable contracts in RSpec example groups.
+
+Contracts are a mechanism for sharing tests between projects. For example, one library may define an interface or specification for a type of object, while a second library implements that object. By defining a contract and sharing that contract as part of the library, the developer ensures that any object that matches the contract has correctly implemented and conforms to the interface. This reduces duplication of tests and provides resiliency as an interface is developed over time and across versions of the library.
+
+Mechanically speaking, each contract encapsulates a section of RSpec code. When the contract is included in a spec, that code is then injected into the spec. Writing a contract, therefore, is no different than writing any other RSpec specification - it is only the delivery mechanism that differs. A contract can be any object that responds to #to_proc; the simplest contract is therefore a Proc or lambda that contains some RSpec code.
+
+Although the examples use bare `lambda`s, any object that responds to `#to_proc` can be used as a contract. See also [Contracts](#contracts), which provide an approach to defining contracts that makes documenting contracts much cleaner.
+
+```ruby
+module ExampleContracts
+  # This contract asserts that the object has the Enumerable module as an
+  # ancestor, and that it responds to the #each method.
+  SHOULD_BE_ENUMERABLE_CONTRACT = lambda do
+    it 'should be Enumerable' do
+      expect(subject).to be_a Enumerable
+    end
+
+    it 'should respond to #each' do
+      expect(subject).to respond_to(:each).with(0).arguments
+    end
+  end
+end
+
+RSpec.describe Array do
+  extend RSpec::SleepingKingStudios::Concerns::IncludeContract
+
+  include_contract ExampleContracts::SHOULD_BE_ENUMERABLE_CONTRACT
+end
+
+RSpec.describe Hash do
+  extend  RSpec::SleepingKingStudios::Concerns::IncludeContract
+  include ExampleContracts
+
+  include_contract 'should be enumerable'
+end
+```
+
+We can also write contracts that take parameters, allowing us to customize the expected behavior of the object.
+
+```ruby
+module SerializerContracts
+  # This contract asserts that the serialized result has the expected values.
+  SHOULD_SERIALIZE_ATTRIBUTES_CONTRACT = lambda \
+  do |*attributes, **values, &block|
+    describe '#serialize' do
+      let(:serialized) { subject.serialize }
+
+      it { expect(subject).to respond_to(:serialize).with(0).arguments }
+
+      attributes.each do |attribute|
+        it "should serialize #{attribute}" do
+          expect(serialized[attribute]).to be == subject[attribute]
+        end
+      end
+
+      values.each do |attribute, value|
+        it "should serialize #{attribute}" do
+          expect(serialized[attribute]).to be == value
+        end
+      end
+
+      instance_exec(&block) if block
+    end
+  end
+end
+
+RSpec.describe CaptainPicard do
+  extend  RSpec::SleepingKingStudios::Concerns::IncludeContract
+  include SerializerContracts
+
+  include_contract 'should serialize attributes',
+    :name,
+    :rank,
+    lights: 4 do
+      it 'should serialize the catchphrase' do
+        expect(serialized[:catchphrase]).to be == 'Make it so.'
+      end
+  end
+end
+```
+
+First, we pass the contract a series of attribute names. These are used to assert that the serialized attributes match the values on the original object.
+
+Second, we pass the contract a set of attribute names and values. These are used to assert that the serialized attributes have the specified values.
+
+Finally, we can pass the contract a block, which the contract then executes. Note that the block is executed in the context of our describe block, and thus can take advantage of our memoized #serialized helper method.
+
+#### `.include_contract`
+
+The `.include_contract` class method applies the contract to the current example group. It passes any additional arguments, keywords, or block to the contract implementation.
+
+#### `.finclude_contract`
+
+The `.finclude_contract` class method creates a new focused context inside the current example group and applies the contract to that context. If RSpec is configured to run only focused specs, then only the contract specs will be run. This is useful to quickly focus and run the specs from a particular contract.
+
+#### `.xinclude_contract`
+
+The `.xinclude_contract` class method creates a new skipped context inside the current example group and applies the contract to that context. The contract specs will not be run, but will instead be marked as pending. This is useful to temporarily disable the specs from a particular contract.
+
 ### Focus Examples
 
     require 'rspec/sleeping_king_studios/concerns/focus_examples'
@@ -328,158 +442,146 @@ A simplified syntax for re-using shared context or examples without having to ex
 require 'rspec/sleepingkingstudios/contract'
 ```
 
-A Contract encapsulates a set of RSpec expectations, which can then be used when defining a spec.
-
-```ruby
-module GreetContract
-  extend RSpec::SleepingKingStudios::Contract
+An `RSpec::SleepingKingStudios::Contract` object encapsulates a partial RSpec specification. Unlike a traditional shared example group, a contract can be reused across projects, allowing a library to define an interface, provide a reference implementation, and publish tests that validate other implementations.
 
-  describe '#greet' do
-    it { expect(subject).to respond_to(:greet).with(1).argument }
+Contracts can be added to an example group either through the `.apply` method or using the [Include Contract concern](#include-contract).
 
-    it { expect(subject.greet 'programs').to be == 'Greetings, programs!' }
+```ruby
+module ExampleContracts
+  # This contract asserts that the object has the Enumerable module as an
+  # ancestor, and that it responds to the #each method.
+  class ShouldBeEnumerableContract < RSpec::SleepingKingStudios::Contract
+    # @!method apply(example_group)
+    #   Adds the contract to the example group.
+
+    contract do
+      it 'should be Enumerable' do
+        expect(subject).to be_a Enumerable
+      end
+
+      it 'should respond to #each' do
+        expect(subject).to respond_to(:each).with(0).arguments
+      end
+    end
   end
 end
 
-RSpec.describe Greeter do
-  include GreetContract
+RSpec.describe Array do
+  ExampleContracts::SHOULD_BE_ENUMERABLE_CONTRACT.apply(self)
 end
-```
 
-Using a contract allows for examples to be shared between different specs, or even between projects.
-
-### Contract Methods
-
-Not all RSpec methods are defined in a Contract. Only methods that define an example (`it`) or an example group (`context` or `describe`) can be used at the top level of a Contract. However, all RSpec methods (including methods that modify the current scope, such as `let` and the `before`/`around`/`after` filters) can be used inside an example group as normal.
-
-#### `::context`
-
-Defines an example group inside the contract. This example group will be defined on all specs that include the contract.
-
-```ruby
-module TransformationContract
-  extend RSpec::SleepingKingStudios::Contract
+RSpec.describe Hash do
+  extend  RSpec::SleepingKingStudios::Concerns::IncludeContract
+  include ExampleContracts
 
-  context 'when the moon is full' do
-    let(:moon_phase) { :full }
-
-    it { expect(werewolf).to be_transformed }
-  end
+  include_contract 'should be enumerable'
 end
 ```
 
-#### `::describe`
+The major advantage a Contract object provides over using a Proc is documentation - tools such as YARD do not gracefully handle bare lambdas, while the functionality and requirements of a Contract can be specified using standard patterns, such as documenting the parameters passed to a contract using the #apply method.
 
-Defines an example group inside the contract. This example group will be defined on all specs that include the contract.
+Contracts can be defined with parameters, which allows us to customize the expected behavior of the object.
 
 ```ruby
-module SilverContract
-  extend RSpec::SleepingKingStudios::Contract
-
-  describe 'with a silver weapon' do
-    before(:example) do
-      weapon.material = 'silver'
+module SerializerContracts
+  # This contract asserts that the serialized result has the expected
+  # values.
+  #
+  # First, we pass the contract a series of attribute names. These are
+  # used to assert that the serialized attributes match the values on the
+  # original object.
+  #
+  # Second, we pass the contract a set of attribute names and values.
+  # These are used to assert that the serialized attributes have the
+  # specified values.
+  #
+  # Finally, we can pass the contract a block, which the contract then
+  # executes. Note that the block is executed in the context of our
+  # describe block, and thus can take advantage of our memoized
+  # #serialized helper method.
+  class ShouldSerializeAttributesContract
+    extend RSpec::SleepingKingStudios::Contract
+
+    contract do |*attributes, **values, &block|
+      describe '#serialize' do
+        let(:serialized) { subject.serialize }
+
+        it { expect(subject).to respond_to(:serialize).with(0).arguments }
+
+        attributes.each do |attribute|
+          it "should serialize #{attribute}" do
+            expect(serialized[attribute]).to be == subject[attribute]
+          end
+        end
+
+        values.each do |attribute, value|
+          it "should serialize #{attribute}" do
+            expect(serialized[attribute]).to be == value
+          end
+        end
+
+        instance_exec(&block) if block
+      end
     end
+  end
 
-    it 'should kill the werewolf' do
-      expect(attack(werewolf, weapon)).to change(werewolf, :alive?).to be false
+RSpec.describe CaptainPicard do
+  SerializerContracts::ShouldSerializeAttributesContract.apply(
+    self,
+    :name,
+    :rank,
+    lights: 4) \
+  do
+    it 'should serialize the catchphrase' do
+      expect(serialized[:catchphrase]).to be == 'Make it so.'
     end
   end
 end
 ```
 
-#### `::it`
+### Contract Methods
 
-Defines an example inside the contract.
+Each `RSpec::SleepingKingStudios::Contract` defines the following methods.
 
-```ruby
-module HowlingContract
-  extend RSpec::SleepingKingStudios::Contract
+#### `.apply`
 
-  it { expect(werewolf).to respond_to(:howl) }
-end
-```
-
-#### `::shared_context`
-
-Defines a shared example group.
+The `.apply` method adds the contract to the given example group, using the same internals used in the [Include Contract concern](#include-contract).
 
 ```ruby
-module MoonContract
-  extend RSpec::SleepingKingStudios::Contract
-
-  shared_context 'when the moon is full' do
-    before(:example) { moon.phase = :full }
-  end
+RSpec.describe Book do
+  subject(:book) { Book.first }
+
+  SerializerContracts::ShouldSerializeAttributesContract.apply(
+    self,
+    :title,
+    author: book.author.as_json
+  )
 end
 ```
 
-**Note:** When the `Contract` is included in an RSpec example group, any shared example groups defined at the top level of a contract are also included in that example group, even outside of the contract itself. This may cause namespace collisions with shared example groups defined elsewhere in the example group or by other included contracts.
+#### `.contract`
 
-#### `::shared_examples`
-
-Defines a shared example group.
+The `.contract` method is used to define the contract implementation.
 
 ```ruby
-module HairContract
-  extend RSpec::SleepingKingStudios::Contract
-
-  shared_examples 'should be hairy' do
-    describe '#hairy?' do
-      it { expect(werewolf.hairy?).to be true }
+module ModelContracts
+  class ShouldHavePrimaryKey
+    extend RSpec::SleepingKingStudios::Contract
+
+    contract do |primary_key_name: :id|
+      describe "##{primary_key_name}" do
+        it { expect(subject).to respond_to(primary_key_name).with(0).arguments }
+      end
     end
   end
 end
 ```
 
-**Note:** When the `Contract` is included in an RSpec example group, any shared example groups defined at the top level of a contract are also included in that example group, even outside of the contract itself. This may cause namespace collisions with shared example groups defined elsewhere in the example group or by other included contracts.
-
-### Developing Contracts
-
-```ruby
-module VampireContract
-  extend RSpec::SleepingKingStudios::Contract
-  extend RSpec::SleepingKingStudios::Contracts::Development
-
-  fdescribe '#drink' do
-    it { expect(drink 'blood').to be true }
-
-    xit { expect(drink 'holy water').to be false }
-  end
-
-  pending
-end
-```
-
-The `RSpec::SleepingKingStudios::Contracts::Development` module provides methods for defining focused or pending examples and example groups. These are intended for use when developing a contract, and should not be included in the final version. Having skipped or focused example groups in a shared contract can have unexpected effects when the contract is included by the end user.
-
-#### `::fcontext`
-
-Defines a focused example group inside the contract.
-
-#### `::fdescribe`
-
-Defines a focused example group inside the contract.
+If a block is not given, it returns the current implementation as a `Proc` (or `nil`, if a contract implementation has not yet been set).
 
-#### `::fit`
+#### `.to_proc`
 
-Defines a focused example inside the contract.
-
-#### `::pending`
-
-Marks the contract as pending.
-
-#### `::xcontext`
-
-Defines a skipped example group inside the contract.
-
-#### `::xdescribe`
-
-Defines a skipped example group inside the contract.
-
-#### `::xit`
-
-Defines a skipped example inside the contract.
+The `.to_proc` method returns the current implementation as a `Proc` (or `nil`, if a contract implementation has not yet been set).
 
 ## Matchers
 
@@ -590,22 +692,6 @@ Now has additional chaining functionality to validate the number of arguments ac
 
 These matchers check core functionality, such as object boolean-ness, the existence of properties, and so on.
 
-#### `#alias_method` Matcher
-
-    require 'rspec/sleeping_king_studios/matchers/core/alias_method'
-
-Checks if the object aliases the specified method with the specified other name. Matches if and only if the object responds to both the old and new method names, and if the old method and the new method are the same method.
-
-**How To Use**:
-
-    expect(object).to alias_method(:old_method).as(:new_method)
-
-**Parameters:** Old method name. Expects the name of the method which has been aliased as a String or Symbol.
-
-**Chaining:**
-
-* **`#as`:** Required. Expects one String or Symbol, which is the name of the generated method.
-
 #### `#be_a_uuid` Matcher
 
     require 'rspec/sleeping_king_studios/matchers/core/be_a_uuid'
@@ -709,34 +795,21 @@ When the value does not match the expectation, the failure message will provide
     #   + :errors => got ["Insufficient funds"]
     #   ~ :status => expected 200, got 400
 
-#### `#delegate_method` Matcher
+#### `#have_aliased_method` Matcher
 
-    require 'rspec/sleeping_king_studios/matchers/core/delegate_method'
+    require 'rspec/sleeping_king_studios/matchers/core/have_aliased_method'
 
-Checks if the actual object forwards the specified method to the specified target. Can also specify that arguments, keywords, and/or a block are passed to the target, and that the object returns the specified values.
-
-**How To Use:**
-
-    expect(object).to delegate_method(:my_method).to(target)
+Checks if the object aliases the specified method with the specified other name. Matches if and only if the object responds to both the old and new method names, and if the old method and the new method are the same method.
 
-    # Specify that arguments must be passed to the target.
-    expect(object).to delegate_method(:my_method).to(target).with_arguments(:ichi, :ni, :san)
-    expect(object).to delegate_method(:my_method).to(target).with_keywords(:foo => 'foo', :bar => 'bar')
-    expect(object).to delegate_method(:my_method).to(target).with_a_block
+**How To Use**:
 
-    # Specify that the method must return the specified value.
-    expect(object).to delegate_method(:my_method).to(target).and_return(true)    # Called 1 time.
-    expect(object).to delegate_method(:my_method).to(target).and_return(0, 1, 2) # Called 3 times.
+    expect(object).to have_aliased_method(:old_method).as(:new_method)
 
-**Parameters:** Method name. Expects a string or symbol that is a valid identifier.
+**Parameters:** Old method name. Expects the name of the method which has been aliased as a String or Symbol.
 
 **Chaining:**
 
-* **`#to`:** Required. Expects an object, which is the target the method should be forwarded to.
-* **`#with_arguments`:** (also `and_arguments`) Expects one or more arguments. Specifies that when the method is called on the actual object with the given arguments, those arguments are then passed on to the target object when the method is called on the target.
-* **`#with_keywords:`** (also `and_keywords`) Expects a hash of keywords and values. Specifies that when the method is called on the actual object with the given keywords, those keywords are then passed on to the target object when the method is called on the target.
-* **`#with_a_block:`** (also `and_a_block`) Specifies that when the method is called on the actual object a block argument, thhe block is then passed on to the target object when the method is called on the target.
-* **`#and_return`:** Expects one or more arguments. The method is called on the actual object one time for each value passed into `#and_return`. Specifies that the return value of calling the method on the actual object is the corresponding value passed into `#and_return`.
+* **`#as`:** Required. Expects one String or Symbol, which is the name of the generated method.
 
 #### `#have_changed` Matcher
 

data/lib/rspec/sleeping_king_studios/all.rb

@@ -1,5 +1,6 @@
 # lib/rspec/sleeping_king_studios/all.rb
 
 require 'rspec/sleeping_king_studios/concerns/all'
+require 'rspec/sleeping_king_studios/contract'
 require 'rspec/sleeping_king_studios/examples/all'
 require 'rspec/sleeping_king_studios/matchers/all'