activeinteractor 0.1.7 → 1.0.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62ffd94a00a7a624dc305a07dfb9347ac55d9b863b6a6acaf87d74a653bea21f
-  data.tar.gz: bf704329e8360caaa6c750fb65722e8bf3cd53c0c633d7d1ed96f1b68fd4af0b
+  metadata.gz: f04cfc71e44fdbf89253cb31c1252781a094fa107763c0d27aa853f9d008774e
+  data.tar.gz: 2ca6bff9224913bd7420f74387c4d7cec2b704ac45f0d79ab5a4fa64ad46894b
 SHA512:
-  metadata.gz: 22600e40ed597c10695c5bc1859f7338495c25b2204d9d58f959be3c74cb1e943f98776e0669dfc12e784eaf16babab7fc0531a98e15fbf2e6a0bbd42710d693
-  data.tar.gz: f61f0ad8378ac49577e19c745566a202e5723cd107f7e867d0ed34249926c6827e258f81e42a7c617546e3e53448f106aba3a3754b1171fbb2d5c2f303217119
+  metadata.gz: 0d106d19d463424f0a406183713dc18ed27d6830fce6b685a96264a6f4396fd9ea18847c819b8dff12639cb319a42bb9ea22a5e5fbfade7e0678fe489a9fe25c
+  data.tar.gz: 75e3ef76a19f93ca5f795572403ad10338ef42c23db7e97b582fbe1922db8eafa946da83e02c5b20c129e415feb67b4e7c135c89151fd45a3f415c00e4fd0bf0

data/CHANGELOG.md

@@ -7,6 +7,40 @@ and this project adheres to [Semantic Versioning].
 
 ## [Unreleased]
 
+## [v1.0.0-beta.1] - 2020-01-06
+
+### Added
+
+- `ActiveInteractor.logger=`
+- `ActiveInteractor::Base#dup`
+- `ActiveInteractor::Context::Loader`
+- `ActiveInteractor::Error::InvalidContextClass`
+- `ActiveInteractor::Interactor::Context#context_fail!`
+- `ActiveInteractor::Interactor::Context#context_rollback!`
+- `ActiveInteractor::Interactor::Context.contextualize_with`
+- `ActiveInteractor::Interactor::Context#finalize_context!`
+
+### Changed
+
+- `ActiveInteractor::Context::Attributes.attributes` now excepts arguments for attributes
+- `ActiveInteractor::Generators` various improvements to rails generators
+- `ActiveInteractor::Interactor::Context.context_class` will now first attempt to find an
+  existing context class, and only create a new context class if a context is not found.
+- `ActiveInteractor::Organizer.organize` now excepts symbols and strings as arguments.
+
+### Removed
+
+- `ActiveInteractor::Configuration`
+- `ActiveInteractor::Context::Attributes.attributes=` in favor of `ActiveInteractor::Context#attributes`
+- `ActiveInteractor::Context::Attributes.attribute_aliases`
+- `ActiveInteractor::Context::Attributes#clean!`
+- `ActiveInteractor::Context::Attributes#keys`
+- `ActiveInteractor::Interactor#fail_on_invalid_context?`
+- `ActiveInteractor::Interactor#should_clean_context?`
+- `ActiveInteractor::Interactor::Callbacks.clean_context_on_completion`
+- `ActiveInteractor::Interactor::Context.context_attribute_aliases`
+- `ActiveInteractor::Interactor::Execution`
+
 ## [v0.1.7] - 2019-09-10
 
 ### Fixed
@@ -74,7 +108,8 @@ and this project adheres to [Semantic Versioning].
 
 <!-- versions -->
 
-[Unreleased]: https://github.com/aaronmallen/activeinteractor/compare/v0.1.7..HEAD
+[Unreleased]: https://github.com/aaronmallen/activeinteractor/compare/v1.0.0-beta.1..HEAD
+[v1.0.0-beta.1]: https://github.com/aaronmallen/activeinteractor/compare/v0.1.7...v1.0.0-beta.1
 [v0.1.7]: https://github.com/aaronmallen/activeinteractor/compare/v0.1.6...v0.1.7
 [v0.1.6]: https://github.com/aaronmallen/activeinteractor/compare/v0.1.5...v0.1.6
 [v0.1.5]: https://github.com/aaronmallen/activeinteractor/compare/v0.1.4...v0.1.5

data/README.md

@@ -1,15 +1,45 @@
 # ActiveInteractor
 
-[![Version](https://img.shields.io/gem/v/activeinteractor.svg?logo=ruby&style=for-the-badge)](https://rubygems.org/gems/activeinteractor)
-[![License](https://img.shields.io/github/license/aaronmallen/activeinteractor.svg?maxAge=300&style=for-the-badge)](https://github.com/aaronmallen/activeinteractor/blob/master/LICENSE)
-[![Dependencies](https://img.shields.io/depfu/aaronmallen/activeinteractor.svg?maxAge=300&style=for-the-badge)](https://depfu.com/github/aaronmallen/activeinteractor)
+[![Version](https://img.shields.io/gem/v/activeinteractor.svg?logo=ruby)](https://rubygems.org/gems/activeinteractor)
+[![License](https://img.shields.io/github/license/aaronmallen/activeinteractor.svg?maxAge=300)](https://github.com/aaronmallen/activeinteractor/blob/master/LICENSE)
+[![Dependencies](https://img.shields.io/depfu/aaronmallen/activeinteractor.svg?maxAge=300)](https://depfu.com/github/aaronmallen/activeinteractor)
 
-[![Build Status](https://img.shields.io/travis/com/aaronmallen/activeinteractor/master.svg?logo=travis&maxAge=300&style=for-the-badge)](https://www.travis-ci.com/aaronmallen/activeinteractor)
-[![Maintainability](https://img.shields.io/codeclimate/maintainability/aaronmallen/activeinteractor.svg?maxAge=300&style=for-the-badge)](https://codeclimate.com/github/aaronmallen/activeinteractor/maintainability)
-[![Test Coverage](https://img.shields.io/codeclimate/coverage/aaronmallen/activeinteractor.svg?maxAge=300&style=for-the-badge)](https://codeclimate.com/github/aaronmallen/activeinteractor/test_coverage)
+[![Build Status](https://github.com/aaronmallen/activeinteractor/workflows/Build/badge.svg)](https://github.com/aaronmallen/activeinteractor/actions)
+[![Maintainability](https://img.shields.io/codeclimate/maintainability/aaronmallen/activeinteractor.svg?maxAge=300)](https://codeclimate.com/github/aaronmallen/activeinteractor/maintainability)
+[![Codacy Badge](https://api.codacy.com/project/badge/Grade/be92c4ecf12347da82d266f6a4368b6e)](https://www.codacy.com/manual/aaronmallen/activeinteractor?utm_source=github.com&utm_medium=referral&utm_content=aaronmallen/activeinteractor&utm_campaign=Badge_Grade)
+[![Test Coverage](https://img.shields.io/codeclimate/coverage/aaronmallen/activeinteractor.svg?maxAge=300)](https://codeclimate.com/github/aaronmallen/activeinteractor/test_coverage)
 
 Ruby interactors with [ActiveModel::Validations] based on the [interactor][collective_idea_interactors] gem.
 
+<!-- TOC -->
+
+* [Getting Started](#getting-started)
+* [What is an Interactor](#what-is-an-interactor)
+* [Usage](#usage)
+  * [Context](#context)
+    * [Adding to the Context](#adding-to-the-context)
+    * [Failing the Context](#failing-the-context)
+    * [Dealing with Failure](#dealing-with-failure)
+    * [Context Attributes](#context-attributes)
+    * [Validating the Context](#validating-the-context)
+  * [Using Interactors](#using-interactors)
+    * [Kinds of Interactors](#kinds-of-interactors)
+    * [Interactors](#interactors)
+    * [Organizers](#organizers)
+    * [Rollback](#rollback)
+    * [Callbacks](#callbacks)
+      * [Validation Callbacks](#validation-callbacks)
+      * [Perform Callbacks](#perform-callbacks)
+      * [Rollback Callbacks](#rollback-callbacks)
+      * [Organizer Callbacks](#organizer-callbacks)
+* [Working With Rails](#working-with-rails)
+* [Development](#development)
+* [Contributing](#contributing)
+* [Acknowledgements](#acknowledgements)
+* [License](#license)
+
+<!-- TOC -->
+
 ## Getting Started
 
 Add this line to your application's Gemfile:
@@ -30,31 +60,6 @@ Or install it yourself as:
 gem install activeinteractor
 ```
 
-If you're working with a rails project you will also want to run:
-
-```bash
-rails generate active_interactor:install [directory]
-```
-
-The `directory` option allows you to customize what directory interactors
-will live in within your application (defaults to 'interactors').
-
-This will create an initializer and a new class called `ApplicationInteractor`
-at `app/<interactor directory>/application_interactor.rb`
-
-you can then automatically generate interactors and interactor organizers with:
-
-```bash
-rails generate interactor MyInteractor
-```
-
-```bash
-rails generate interactor:organizer MyInteractor1 MyInteractor2
-```
-
-These two generators will automatically create an interactor class which
-inherits from `ApplicationInteractor` and a matching spec or test file.
-
 ## What is an Interactor
 
 An interactor is a simple, single-purpose service object.
@@ -67,26 +72,58 @@ Each interactor represents one thing that your application does.
 
 ### Context
 
-Each interactor will have it's own immutable `context` and `context` class.
-For example:
+Each interactor will have it's own immutable context and context class.  All context classes should
+inherit from `ActiveInteractor::Context::Base`. By default an interactor will attempt to find an existing
+class following the naming conventions: `MyInteractor::Context` or `MyInteractorContext`.  If no class
+is found a context class will be created using the naming convention `MyInteractor::Context` for example:
 
 ```ruby
-class MyInteractor < ActiveInteractor::Base
-end
+class MyInteractor < ActiveInteractor::Base; end
+class MyInteractor::Context < ActiveInteractor::Context::Base; end
+
+MyInteractor.context_class #=> MyInteractor::Context
+```
+
+```ruby
+class MyInteractorContext < ActiveInteractor::Context::Base; end
+class MyInteractor < ActiveInteractor::Base; end
+
+MyInteractor.context_class #=> MyInteractorContext
+```
+
+```ruby
+class MyInteractor < ActiveInteractor::Base; end
 
 MyInteractor.context_class #=> MyInteractor::Context
 ```
 
-An interactor's context contains everything the interactor needs to do its work.
-When an interactor does its single purpose, it affects its given context.
+Additionally you can manually specify a context for an interactor with the `contextualize_with`
+method.
+
+```ruby
+class MyGenericContext < ActiveInteractor::Context::Base; end
+
+class MyInteractor
+  contextualize_with :my_generic_context
+end
+
+MyInteractor.context_class #=> MyGenericContext
+```
+
+An interactor's context contains everything the interactor needs to do its work. When an interactor does its single purpose,
+it affects its given context.
 
 #### Adding to the Context
 
-All instances of `context` inherit from `OpenStruct`. As an interactor runs it can
-add information to it's `context`.
+All instances of context inherit from `OpenStruct`. As an interactor runs it can add information to
+it's context.
 
 ```ruby
-context.user = user
+class MyInteractor
+  def perform
+    context.user = User.create(...)
+  end
+end
 ```
 
 #### Failing the Context
@@ -97,12 +134,12 @@ When something goes wrong in your interactor, you can flag the context as failed
 context.fail!
 ```
 
-When given a hash argument or an instance of `ActiveModel::Errors`, the fail!
-method can also update the context. The following are equivalent:
+When given an argument of an instance of `ActiveModel::Errors`, the `#fail!` method can also update the context.
+The following are equivalent:
 
 ```ruby
 context.errors.merge!(user.errors)
-context.fail!
+context.
 ```
 
 ```ruby
@@ -112,249 +149,348 @@ context.fail!(user.errors)
 You can ask a context if it's a failure:
 
 ```ruby
-context.failure? #=> false
-context.fail!
-context.failure? #=> true
+class MyInteractor
+  def perform
+    context.fail!
+  end
+end
+
+result = MyInteractor.perform
+result.failure? #=> true
 ```
 
 or if it's a success:
 
 ```ruby
-context.success? # => true
-context.fail!
-context.success? # => false
+class MyInteractor
+  def perform
+    context.user = User.create(...)
+  end
+end
+
+result = MyInteractor.perform
+result.success? #=> true
 ```
 
 #### Dealing with Failure
 
 `context.fail!` always throws an exception of type `ActiveInteractor::Error::ContextFailure`.
 
-Normally, however, these exceptions are not seen. In the recommended usage, the consuming
-object invokes the interactor using the class method call, then checks the `success?` method of
-the context.
+Normally, however, these exceptions are not seen. In the recommended usage, the consuming object invokes the interactor
+using the class method `perform`, then checks the `success?` method of the context.
 
-This works because the call class method swallows exceptions. When unit testing an interactor, if calling
-custom business logic methods directly and bypassing call, be aware that `fail!` will generate such exceptions.
+This works because the `perform` class method swallows exceptions. When unit testing an interactor, if calling custom business
+logic methods directly and bypassing `perform`, be aware that `fail!` will generate such exceptions.
 
 See [Using Interactors](#using-interactors), below, for the recommended usage of `perform` and `success?`.
 
 #### Context Attributes
 
-Each `context` instance have basic attribute assignment methods which can be invoked directly
-from the interactor.  You never need to directly interface with an interactor's context class.
-Assigning attributes to a `context` is a simple way to explicitly defined what properties a
-`context` should have after an interactor has done it's work.
+Each context instance have basic attribute assignment methods which can be invoked directly from the interactor.
+You never need to directly interface with an interactor's context class. Assigning attributes to a context is a
+simple way to explicitly defined what properties a context should have after an interactor has done it's work.
 
-You can see what attributes are defined on a given `context` with the `#attributes` method:
+You can see what attributes are defined on a given context with the `#attributes` method:
 
 ```ruby
-class MyInteractor < ActiveInteractor::Base
-  # we define user as an attribute because it will be assigned a value
-  # in the perform method.
-  context_attributes :first_name, :last_name, :email, :user
+class MyInteractorContext < ActiveInteractor::Context::Base
+  attributes :first_name, :last_name, :email, :user
 end
 
-context = MyInteractor.perform(
+class MyInteractor < ActiveInteractor::Base; end
+
+result = MyInteractor.perform(
   first_name: 'Aaron',
   last_name: 'Allen',
   email: 'hello@aaronmallen.me',
   occupation: 'Software Dude'
 )
-#=> <#<MyInteractor::Context first_name='Aaron', last_name='Allen, email='hello@aaronmallen.me', occupation='Software Dude'>
+#=> <#MyInteractor::Context first_name='Aaron' last_name='Allen' email='hello@aaronmallen.me' occupation='Software Dude'>
 
-context.attributes #=> { first_name: 'Aaron', last_name: 'Allen', email: 'hello@aaronmallen.me' }
-context.occupation #=> 'Software Dude'
+result.attributes #=> { first_name: 'Aaron', last_name: 'Allen', email: 'hello@aaronmallen.me' }
+result.occupation #=> 'Software Dude'
 ```
 
-You can see what properties are defined on a given `context` with the `#keys` method
-regardless of whether or not the properties are defined in a `context#attributes`:
+#### Validating the Context
 
-```ruby
-context.keys #=> [:first_name, :last_name, :email, :occupation]
-```
+ActiveInteractor delegates all the validation methods provided by [ActiveModel::Validations] onto an interactor's
+context class from the interactor itself. All of the methods found in [ActiveModel::Validations] can be invoked directly
+on your interactor with the prefix `context_`. However this can be confusing and it is recommended to make all validation
+calls on a context class directly.
 
-Finally you can invoke `#clean!` on a context to remove any properties not explicitly
-defined in a `context#attributes`:
+ActiveInteractor provides two validation callback steps:
+
+* `:calling` used before `#perform` is invoked on an interactor
+* `:called` used after `#perform` is invoked on an interactor
+
+A basic implementation might look like this:
 
 ```ruby
-context.clean! #=> { occupation: 'Software Dude' }
-context.occupation #=> nil
-```
+class MyInteractorContext < ActiveInteractor::Context::Base
+  attributes :first_name, :last_name, :email, :user
+  # only validates presence before perform is invoked
+  validates :first_name, presence: true, on: :calling
+  # validates before and after perform is invoked
+  validates :email, presence: true,
+                    format: { with: URI::MailTo::EMAIL_REGEXP }
+  # validates after perform is invoked
+  validates :user, presence: true, on: :called
+  validate :user_is_a_user, on: :called
 
-#### Aliasing Attributes
+  private
 
-Sometimes you may want to use the same interactor functionality with different
-model types having different naming conventions for similar attributes.  We can
-inform the interactors context of these aliases with the `context_attribute_aliases`
-method on our interactors.
+  def user_is_a_user
+    return if user.is_a?(User)
+
+    errors.add(:user, :invalid)
+  end
+end
 
-```ruby
 class MyInteractor < ActiveInteractor::Base
-  context_attributes :first_name, :last_name
-  context_attribute_aliases last_name: :sir_name
+  def perform
+    context.user = User.create_with(
+      first_name: context.first_name,
+      last_name: context.last_name
+    ).find_or_create_by(email: context.email)
+  end
 end
 
-context = MyInteractor.perform(first_name: 'Aaron', sir_name: 'Allen')
-# => <#MyInteractor::Context first_name='Aaron', last_name='Allen'>
+result = MyInteractor.perform(last_name: 'Allen')
+#=> <#MyInteractor::Context last_name='Allen>
+result.failure? #=> true
+result.valid? #=> false
+result.errors[:first_name] #=> ['can not be blank']
+
+result = MyInterator.perform(first_name: 'Aaron', email: 'hello@aaronmallen.me')
+#=> <#MyInteractor::Context first_name='Aaron' email='hello@aaronmallen.me' user=<#User ...>>
+result.success? #=> true
+result.valid? #=> true
+result.errors.empty? #=> true
 ```
 
-We can also pass an array of aliases to the attribute like this:
+### Using Interactors
+
+Most of the time, your application will use its interactors from its controllers. The following controller:
 
 ```ruby
-class MyInteractor < ActiveInteractor::Base
-  context_attributes :first_name, :last_name
-  context_attribute_aliases last_name: %i[sir_name sirname]
-end
+class SessionsController < ApplicationController
+  def create
+    if user = User.authenticate(session_params[:email], session_params[:password])
+      session[:user_token] = user.secret_token
+      redirect_to user
+    else
+      flash.now[:message] = "Please try again."
+      render :new
+    end
+  end
 
-context = MyInteractor.perform(first_name: 'Aaron', sir_name: 'Allen')
-# => <#MyInteractor::Context first_name='Aaron', last_name='Allen'>
+  private
 
-context = MyInteractor.perform(first_name: 'Aaron', sirname: 'Allen')
-# => <#MyInteractor::Context first_name='Aaron', last_name='Allen'>
+  def session_params
+    params.require(:session).permit(:email, :password)
+  end
+end
 ```
 
-#### Validating the Context
+can be refactored to:
+
+```ruby
+class SessionsController < ApplicationController
+  def create
+    result = AuthenticateUser.perform(session_params)
 
-`ActiveInteractor` delegates all the validation methods provided by [ActiveModel::Validations]
-onto an interactor's context class from the interactor itself.  All of the methods found in
-[ActiveModel::Validations] can be invoked directly on your interactor with the prefix `context_`.
+    if result.success?
+      session[:user_token] = result.token
+      redirect_to result.user
+    else
+      flash.now[:message] = t(result.errors.full_messages)
+      render :new
+    end
+  end
 
-`ActiveInteractor` provides two validation callback steps:
+  private
 
-* `:calling` used before `#perform` is invoked
-* `:called` used after `#perform` is invoked
+  def session_params
+    params.require(:session).permit(:email, :password)
+  end
+end
+```
 
-A basic implementation might look like this:
+given the basic interactor and context:
 
 ```ruby
-class MyInteractor < ActiveInteractor::Base
-  context_attributes :first_name, :last_name, :email, :user
-  # only validates presence before perform is invoked
-  context_validates :first_name, presence: true, on: :calling
-  # validates before and after perform is invoked
-  context_validates :email, presence: true,
-                            format: { with: URI::MailTo::EMAIL_REGEXP }
-  # validates after perform is invoked
-  context_validates :user, presence: true, on: :called
-  context_validate :user_is_a_user, on: :called
+class AuthenticateUserContext < ActiveInteractor::Context::Base
+  attributes :email, :password, :user, :token
+  validates :email, presence: true,
+                    format: { with: URI::MailTo::EMAIL_REGEXP }
+  validates :password, presence: true
+  validates :user, presence: true, on: :called
+end
 
+class AuthenticateUser < ActiveInteractor::Base
   def perform
-    context.user = User.create_with(
-      first_name: context.first_name,
-      last_name: context.last_name
-    ).find_or_create_by(email: context.email)
+    context.user = User.authenticate(
+      context.email,
+      context.password
+    )
+    context.token = context.user.secret_token
   end
+end
+```
 
-  private
+The `perform` class method is the proper way to invoke an interactor. The hash argument is converted to the interactor instance's
+context. The `perform` instance method is invoked along with any callbacks and validations that the interactor might define.
+Finally, the context (along with any changes made to it) is returned.
 
-  def user_is_a_user
-    return if context.user.is_a?(User)
+#### Kinds of Interactors
 
-    context.errors.add(:user, :invalid)
-  end
-end
+There are two kinds of interactors built into the Interactor library: basic interactors and organizers.
 
-context = MyInteractor.perform(last_name: 'Allen')
-#=> <#MyInteractor::Context last_name='Allen>
-context.failure? #=> true
-context.valid? #=> false
-context.errors[:first_name] #=> ['can not be blank']
+#### Interactors
+
+A basic interactor is a class that includes Interactor and defines `perform`.\
 
-context = MyInterator.perform(first_name: 'Aaron', email: 'hello@aaronmallen.me')
-#=> <#MyInteractor::Context first_name='Aaron', email='hello@aaronmallen.me'>
-context.success? #=> true
-context.valid? #=> true
-context.errors.empty? #=> true
+```ruby
+class AuthenticateUser < ActiveInteractor::Base
+  def perform
+    user = User.authenticate(context.email, context.password)
+    if user
+      context.user = user
+      context.token = user.secret_token
+    else
+      context.fail!
+    end
+  end
+end
 ```
 
-### Callbacks
+Basic interactors are the building blocks. They are your application's single-purpose units of work.
 
-`ActiveInteractor` uses [ActiveModel::Callbacks] and [ActiveModel::Validations::Callbacks]
-on context validation, `perform`, and `rollback`.  Callbacks can be defined with a `block`,
-`Proc`, or `Symbol` method name and take the same conditional arguments outlined
-in those two modules.
+#### Organizers
 
-**NOTE:** When using symbolized method names as arguments the context class
-will first attempt to invoke the method on itself, if it cannot find the defined
-method it will attempt to invoke it on the interactor.  Be concious of scope
-when defining these methods.
+An organizer is an important variation on the basic interactor. Its single purpose is to run other interactors.
 
-#### Validation Callbacks
+```ruby
+class CreateOrder < ActiveInteractor::Base
+  def perform
+    ...
+  end
+end
 
-We can do work before an interactor's context is validated with the `before_context_validation` method:
+class ChargeCard < ActiveInteractor::Base
+  def perform
+    ...
+  end
+end
 
-```ruby
-class MyInteractor < ActiveInteractor::Base
-  context_attributes :first_name, :last_name, :email, :user
-  context_validates :last_name, presence: true
-  before_context_validation { last_name ||= 'Unknown' }
+class SendThankYou < ActiveInteractor::Base
+  def perform
+    ...
+  end
 end
 
-context = MyInteractor.perform(first_name: 'Aaron', email: 'hello@aaronmallen.me')
-context.valid? #=> true
-context.last_name #=> 'Unknown'
+class PlaceOrder < ActiveInteractor::Organizer
+
+  organize :create_order, :charge_card, :send_thank_you
+end
 ```
 
-We can do work after an interactor's context is validated with the `after_context_validation` method:
+In the controller, you can run the `PlaceOrder` organizer just like you would any other interactor:
 
 ```ruby
-class MyInteractor < ActiveInteractor::Base
-  context_attributes :first_name, :last_name, :email, :user
-  context_validates :email, presence: true,
-                            format: { with: URI::MailTo::EMAIL_REGEXP }
-  after_context_validation :downcase_email!
+class OrdersController < ApplicationController
+  def create
+    result = PlaceOrder.perform(order_params: order_params)
+
+    if result.success?
+      redirect_to result.order
+    else
+      @order = result.order
+      render :new
+    end
+  end
 
   private
 
-  def downcase_email
-    context.email = context.email&.downcase!
+  def order_params
+    params.require(:order).permit!
   end
 end
+```
 
-context = MyInteractor.perform(first_name: 'Aaron', email: 'HELLO@aaronmallen.me')
-context.email #=> 'hello@aaronmallen.me'
+The organizer passes its context to the interactors that it organizes, one at a time and in order. Each interactor may
+change that context before it's passed along to the next interactor.
+
+#### Rollback
+
+If any one of the organized interactors fails its context, the organizer stops. If the `ChargeCard` interactor fails,
+`SendThankYou` is never called.
+
+In addition, any interactors that had already run are given the chance to undo themselves, in reverse order.
+Simply define the rollback method on your interactors:
+
+```ruby
+class CreateOrder < ActiveInteractor::Base
+  def perform
+    order = Order.create(order_params)
+
+    if order.persisted?
+      context.order = order
+    else
+      context.fail!
+    end
+  end
+
+  def rollback
+    context.order.destroy
+  end
+end
 ```
 
-We can prevent a context from failing when invalid by invoking the
-`allow_context_to_be_invalid` class method:
+#### Callbacks
+
+ActiveInteractor uses [ActiveModel::Callbacks] and [ActiveModel::Validations::Callbacks] on context validation, perform,
+and rollback. Callbacks can be defined with a `block`, `Proc`, or `Symbol` method name and take the same conditional arguments
+outlined in those two modules.
+
+##### Validation Callbacks
+
+We can do work before an interactor's context is validated with the `before_context_validation` method:
 
 ```ruby
+class MyInteractorContext < ActiveInteractor::Context::Base
+  attributes :first_name, :last_name, :email
+  validates :last_name, presence: true
+end
+
 class MyInteractor < ActiveInteractor::Base
-  allow_context_to_be_invalid
-  context_attributes :first_name, :last_name, :email, :user
-  context_validates :first_name, presence: true
+  before_context_validation { context.last_name ||= 'Unknown' }
 end
 
-context = MyInteractor.perform(email: 'HELLO@aaronmallen.me')
-context.valid? #=> false
-context.success? #=> true
+result = MyInteractor.perform(first_name: 'Aaron', email: 'hello@aaronmallen.me')
+result.valid? #=> true
+result.last_name #=> 'Unknown'
 ```
 
-#### Context Attribute Callbacks
-
-We can ensure only properties in the context's `attributes` are
-returned after `perform` is invoked with the `clean_context_on_completion`
-class method:
+We can do work after an interactor's context is validated with the `after_context_validation` method:
 
 ```ruby
-class MyInteractor < ActiveInteractor::Base
-  clean_context_on_completion
-  context_attributes :user
+class MyInteractorContext < ActiveInteractor::Context::Base
+  attributes :first_name, :last_name, :email
+  validates :email, presence: true,
+                    format: { with: URI::MailTo::EMAIL_REGEXP }
+end
 
-  def perform
-    context.user = User.create_with(
-      occupation: context.occupation
-    ).find_or_create_by(email: context.email)
-  end
+class MyInteractor < ActiveInteractor::Base
+  after_context_validation { context.email&.downcase! }
 end
 
-context = MyInteractor.perform(email: 'hello@aaronmallen.me', occupation: 'Software Dude')
-context.email #=> nil
-context.occupation #=> nil
-context.user #=> <#User email='hello@aaronmallen.me', occupation='Software Dude'>
+result = MyInteractor.perform(first_name: 'Aaron', last_name: 'Allen', email: 'HELLO@AARONMALLEN.ME')
+result.valid? #=> true
+result.email #=> 'hello@aaronmallen.me'
 ```
 
-#### Perform Callbacks
+##### Perform Callbacks
 
 We can do work before `perform` is invoked with the `before_perform` method:
 
@@ -373,17 +509,21 @@ class MyInteractor < ActiveInteractor::Base
   end
 end
 
-context = MyInteractor.perform
+MyInteractor.perform
 "Start"
 "Performing"
+#=> <#MyInteractor::Context...>
 ```
 
 We can do work around `perform` invokation with the `around_perform` method:
 
 ```ruby
 class MyInteractor < ActiveInteractor::Base
-  context_validates :first_name, presence: true
-  around_perform :track_time, if: :context_valid?
+  around_perform :track_time
+
+  def perform
+    sleep(1)
+  end
 
   private
 
@@ -394,14 +534,9 @@ class MyInteractor < ActiveInteractor::Base
   end
 end
 
-context = MyInteractor.perform(first_name: 'Aaron')
-context.start_time #=> 2019-01-01 00:00:00 UTC
-context.end_time #  #=> 2019-01-01 00:00:01 UTC
-
-context = MyInteractor.perform
-context.valid? #=> false
-context.start_time #=> nil
-context.end_time #  #=> nil
+result = MyInteractor.perform
+result.start_time #=> 2019-01-01 00:00:00 UTC
+result.end_time #=> 2019-01-01 00:00:01 UTC
 ```
 
 We can do work after `perform` is invoked with the `after_perform` method:
@@ -421,12 +556,13 @@ class MyInteractor < ActiveInteractor::Base
   end
 end
 
-context = MyInteractor.perform
+MyInteractor.perform
 "Performing"
 "Done"
+#=> <#MyInteractor::Context...>
 ```
 
-#### Rollback Callbacks
+##### Rollback Callbacks
 
 We can do work before `rollback` is invoked with the `before_rollback` method:
 
@@ -434,6 +570,10 @@ We can do work before `rollback` is invoked with the `before_rollback` method:
 class MyInteractor < ActiveInteractor::Base
   before_rollback :print_start
 
+  def perform
+    context.fail!
+  end
+
   def rollback
     puts 'Rolling Back'
   end
@@ -445,10 +585,10 @@ class MyInteractor < ActiveInteractor::Base
   end
 end
 
-context = MyInteractor.perform
-context.rollback!
+MyInteractor.perform
 "Start"
 "Rolling Back"
+#=> <#MyInteractor::Context...>
 ```
 
 We can do work around `rollback` invokation with the `around_rollback` method:
@@ -457,6 +597,14 @@ We can do work around `rollback` invokation with the `around_rollback` method:
 class MyInteractor < ActiveInteractor::Base
   around_rollback :track_time
 
+  def perform
+    context.fail!
+  end
+
+  def rollback
+    sleep(1)
+  end
+
   private
 
   def track_time
@@ -466,10 +614,9 @@ class MyInteractor < ActiveInteractor::Base
   end
 end
 
-context = MyInteractor.perform
-context.rollback!
-context.start_time #=> 2019-01-01 00:00:00 UTC
-context.end_time #  #=> 2019-01-01 00:00:01 UTC
+result = MyInteractor.perform
+result.start_time #=> 2019-01-01 00:00:00 UTC
+result.end_time #=> 2019-01-01 00:00:01 UTC
 ```
 
 We can do work after `rollback` is invoked with the `after_rollback` method:
@@ -478,6 +625,10 @@ We can do work after `rollback` is invoked with the `after_rollback` method:
 class MyInteractor < ActiveInteractor::Base
   after_rollback :print_done
 
+  def perform
+    context.fail!
+  end
+
   def rollback
     puts 'Rolling Back'
   end
@@ -489,29 +640,25 @@ class MyInteractor < ActiveInteractor::Base
   end
 end
 
-context = MyInteractor.perform
-context.rollback!
+MyInteractor.perform
 "Rolling Back"
 "Done"
+#=> <#MyInteractor::Context...>
 ```
 
-#### Organizer Callbacks
+##### Organizer Callbacks
 
-We can do worker before `perform` is invoked on each interactor in an [Organizer](#organizers)
-with the `before_each_perform` method:
+We can do worker before `perform` is invoked on each interactor in an [Organizer](#organizers) with the
+`before_each_perform` method:
 
 ```ruby
- class MyInteractor1 < ActiveInteractor::Base
-  before_perform :print_name
-
+class MyInteractor1 < ActiveInteractor::Base
   def perform
     puts 'MyInteractor1'
   end
 end
 
 class MyInteractor2 < ActiveInteractor::Base
-  before_perform :print_name
-
   def perform
     puts 'MyInteractor2'
   end
@@ -529,31 +676,29 @@ class MyOrganizer < ActiveInteractor::Organizer
   end
 end
 
-MyOrganizer.perform(name: 'Aaron')
+MyOrganizer.perform
 "Start"
 "MyInteractor1"
 "Start"
 "MyInteractor2"
-#=> <MyOrganizer::Context name='Aaron'>
+#=> <MyOrganizer::Context...>
 ```
 
-We can do worker around `perform` is invokation on each interactor in an [Organizer](#organizers)
-with the `around_each_perform` method:
+We can do worker around `perform` is invokation on each interactor in an [Organizer](#organizers) with the
+`around_each_perform` method:
 
 ```ruby
  class MyInteractor1 < ActiveInteractor::Base
-  before_perform :print_name
-
   def perform
     puts 'MyInteractor1'
+    sleep(1)
   end
 end
 
 class MyInteractor2 < ActiveInteractor::Base
-  before_perform :print_name
-
   def perform
     puts 'MyInteractor2'
+    sleep(1)
   end
 end
 
@@ -571,31 +716,27 @@ class MyOrganizer < ActiveInteractor::Organizer
   end
 end
 
-MyOrganizer.perform(name: 'Aaron')
-"2019-04-01 00:00:00 UTC"
+MyOrganizer.perform
+"2019-01-01 00:00:00 UTC"
 "MyInteractor1"
-"2019-04-01 00:00:01 UTC"
-"2019-04-01 00:00:02 UTC"
+"2019-01-01 00:00:01 UTC"
+"2019-01-01 00:00:01 UTC"
 "MyInteractor2"
-"2019-04-01 00:00:03 UTC"
-#=> <MyOrganizer::Context name='Aaron'>
+"2019-01-01 00:00:02 UTC"
+#=> <MyOrganizer::Context...>
 ```
 
-We can do worker after `perform` is invoked on each interactor in an [Organizer](#organizers)
-with the `after_each_perform` method:
+We can do worker after `perform` is invoked on each interactor in an [Organizer](#organizers) with the
+`after_each_perform` method:
 
 ```ruby
 class MyInteractor1 < ActiveInteractor::Base
-  before_perform :print_name
-
   def perform
     puts 'MyInteractor1'
   end
 end
 
 class MyInteractor2 < ActiveInteractor::Base
-  before_perform :print_name
-
   def perform
     puts 'MyInteractor2'
   end
@@ -609,182 +750,45 @@ class MyOrganizer < ActiveInteractor::Organizer
   private
 
   def print_done
-    puts "done"
+    puts "Done"
   end
 end
 
-MyOrganizer.perform(name: 'Aaron')
+MyOrganizer.perform
 "MyInteractor1"
 "Done"
 "MyInteractor2"
 "Done"
-#=> <MyOrganizer::Context name='Aaron'>
+#=> <MyOrganizer::Context...>
 ```
 
-### Using Interactors
-
-Most of the time, your application will use its interactors from its controllers. The following controller:
-
-```ruby
-class SessionsController < ApplicationController
-  def create
-    if user = User.authenticate(session_params[:email], session_params[:password])
-      session[:user_token] = user.secret_token
-      redirect_to user
-    else
-      flash.now[:message] = "Please try again."
-      render :new
-    end
-  end
+## Working With Rails
 
-  private
+If you're working with a rails project ActiveInteractor comes bundled with some useful generators
+to help speed up development.  You should first run the install generator with:
 
-  def session_params
-    params.require(:session).permit(:email, :password)
-  end
-end
-```
-
-can be refactored to:
-
-```ruby
-class SessionsController < ApplicationController
-  def create
-    result = AuthenticateUser.perform(session_params)
-
-    if result.success?
-      session[:user_token] = result.token
-      redirect_to result.user
-    else
-      flash.now[:message] = t(result.errors.full_messages)
-      render :new
-    end
-  end
-
-  private
-
-  def session_params
-    params.require(:session).permit(:email, :password)
-  end
-end
-```
-
-given the basic interactor:
-
-```ruby
-class AuthenticateUser < ActiveInteractor::Base
-  context_attributes :email, :password, :user, :token
-  context_validates :email, presence: true,
-                            format: { with: URI::MailTo::EMAIL_REGEXP }
-  context_validates :password, presence: true
-  context_validates :user, presence: true, on: :called
-
-  def perform
-    context.user = User.authenticate(
-      context.email,
-      context.password
-    )
-    context.token = context.user.secret_token
-  end
-end
+```bash
+rails generate active_interactor:install
 ```
 
-The `perform` class method is the proper way to invoke an interactor.
-The hash argument is converted to the interactor instance's context.
-The `preform` instance method is invoked along with any callbacks and validations
-that the interactor might define. Finally, the context (along with any changes made to it)
-is returned.
-
-### Kinds of Interactors
+This will create an initializer a some new classes `ApplicationInteractor`, `ApplicationOrganizer` and
+`ApplicationContext` in the `app/interactors` directory.
 
-There are two kinds of interactors built into the Interactor library: basic interactors and organizers.
-
-#### Interactors
+You can then automatically generate interactors, organizers, and contexts with:
 
-A basic interactor is a class that includes Interactor and defines call.
-
-```ruby
-class AuthenticateUser
-  include Interactor
-
-  def perform
-    if user = User.authenticate(context.email, context.password)
-      context.user = user
-      context.token = user.secret_token
-    else
-      context.fail!
-    end
-  end
-end
+```bash
+rails generate interactor MyInteractor
 ```
 
-Basic interactors are the building blocks. They are your application's single-purpose units of work.
-
-#### Organizers
-
-An organizer is an important variation on the basic interactor. Its single purpose is to run other interactors.
-
-```ruby
-class PlaceOrder
-  include Interactor::Organizer
-
-  organize CreateOrder, ChargeCard, SendThankYou
-end
+```bash
+rails generate interactor:organizer MyInteractor1 MyInteractor2
 ```
 
-In the controller, you can run the `PlaceOrder` organizer just like you would any other interactor:
-
-```ruby
-class OrdersController < ApplicationController
-  def create
-    result = PlaceOrder.call(order_params: order_params)
-
-    if result.success?
-      redirect_to result.order
-    else
-      @order = result.order
-      render :new
-    end
-  end
-
-  private
-
-  def order_params
-    params.require(:order).permit!
-  end
-end
+```bash
+rails generate interactor:context MyContext
 ```
 
-The organizer passes its context to the interactors that it organizes, one at a time and in order.
-Each interactor may change that context before it's passed along to the next interactor.
-
-#### Rollback
-
-If any one of the organized interactors fails its context, the organizer stops.
-If the `ChargeCard` interactor fails, `SendThankYou` is never called.
-
-In addition, any interactors that had already run are given the chance to undo themselves, in reverse order.
-Simply define the rollback method on your interactors:
-
-```ruby
-class CreateOrder
-  include Interactor
-
-  def perform
-    order = Order.create(order_params)
-
-    if order.persisted?
-      context.order = order
-    else
-      context.fail!
-    end
-  end
-
-  def rollback
-    context.order.destroy
-  end
-end
-```
+These generators will automatically create the approriate classes and matching spec or test files.
 
 ## Development
 
@@ -793,8 +797,6 @@ You can also run `bin/console` for an interactive prompt that will allow you to
 
 To install this gem onto your local machine, run `bundle exec rake install`.
 
-Additionally you can run tests in both rails 2.5 and rails 2.6 with `bin/test`.
-
 ## Contributing
 
 Read our guidelines for [Contributing](CONTRIBUTING.md).