activeinteractor 1.0.0.beta.7 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6fc8ba19ece1da4ceed9d40d07e248dd77294c23c0b90b4a4012f74bce2726f9
-  data.tar.gz: f785b96877bab8eaed1f7cc612aad65d75bfa723170221cd54d46270e820f152
+  metadata.gz: df118b852db85867fab87a6582604a59c89fd0a194843e569c663cb09b969abc
+  data.tar.gz: 281f4e6672238ccfac070bd0c17f6831f76b455c26444a49945388b85738153c
 SHA512:
-  metadata.gz: 589bd2fe219fc23e75eb2319242de9692ff17b157c09987495ee5931ee66137415b9c9d8291a6cd1dbcd8dc3bb7a8df8c206ecfec93c01249296c49ba590ccde
-  data.tar.gz: d699de2f8be391922a8d26ca96767ca654547760724f732a2396e367d3cf903fac8c6d6b4c6d3a704f928d94671c3beec6292747c202020507a92e96dadba8d5
+  metadata.gz: 19822562f299f87b863686d0449e4c66b31096696f9f73c47e2c226a62413cdd8a379150a9e5d35a7d3f5e35433300b787965111a0bf0f9a0e29bcf4628afa04
+  data.tar.gz: dee8cdf2ad05de200a09549fd3ad4f2c904e34da01374230d69a6a040d2ea9c0542e76cae81a80b0bbd259f81c413784934e21e8069dbfda1b16a1acc1247056

data/.yardopts

@@ -0,0 +1,12 @@
+--title ActiveInteractor
+--readme README.md
+--markup-provider redcarpet
+--markup markdown
+--exclude lib/rails
+--protected
+--no-private
+--embed-mixins
+lib/**/*.rb
+-
+CHANGELOG.md
+LICENSE

data/CHANGELOG.md

@@ -7,197 +7,123 @@ and this project adheres to [Semantic Versioning].
 
 ## [Unreleased]
 
-## [v1.0.0-beta.7] - 2020-01-21
+## [v1.0.0] - 2020-01-26
 
 ### Added
 
-- [#127] `ActiveInteractor::Rails::Models`
-
-### Fixed
-
-- [#127] #126 `act_as_context` not working
-
-### Removed
-
-- [#127] `ActiveInteractor::Rails::ActiveRecord`
-
-## [v1.0.0-beta.6] - 2020-01-21
-
-### Added
-
-- [#124] `ActiveInteractor::Context::Status`
-- [#124] `ActiveInteractor::Rails::ActiveRecord`
-
-### Changed
-
-- [#124] Abstracted status methods from `ActiveInteractor::Context::Base`
-  into `ActiveInteractor::Context::Status`
-
-## [v1.0.0-beta.5] - 2020-01-21
-
-### Added
-
-- [#122] `ActiveInteractor::Rails::Railtie`
-- [#122] `ActiveInteractor::Rails.config`
-- [#122] `ActiveInteractor::Rails.configure`
-
-### Removed
-
-- [#122] `ActiveInteractor::Railtie` use `ActiveInteractor::Rails::Railtie` instead
-- [#122] `ActiveInteractor::Config#rails` use `ActiveInteractor::Rails.configure` instead
-
-## [v1.0.0-beta.4] - 2020-01-14
-
-### Added
-
-- [#114] `ActiveInteractor::Organizer::InteractorInterface`
-- [#114] `ActiveInteractor::Organizer::InteractorInterfaceCollection`
-- [#115] `ActiveInteractor::Interactor#options`
-- [#115] `ActiveInteractor::Interactor#with_options`
-- [#115] `ActiveInteractor::Interactor::PerformOptions#skip_each_perform_callbacks`
-
-### Changed
-
-- [#115] `ActiveInteractor::Interactor::Worker#execute_perform` and `#execute_perform!` no longer accept arguments,
-   use `ActiveInteractor::Interactor#with_options` instead.
-- [#115] `ActiveInteractor::Organizer` can now skip `each_perform` callbacks with
-  the option `skip_each_perform_callbacks`
-
-### Removed
-
-- [#115] `ActiveInteractor::Interactor#execute_rollback`
-- [#115] `ActiveInteractor::Interactor::Worker#run_callbacks`
-
-## [v1.0.0-beta.3] - 2020-01-12
-
-### Added
-
-- [#109] `ActiveInteractor::Organizer.parallel`
-- [#109] `ActiveInteractor::Organizer.perform_in_parallel`
-- [#109] `ActiveInteractor::Context::Base#merge`
-- [#110] `ActiveInteractor::Interactor::PerformOptions`
-
-### Changed
-
-- [#110] `ActiveInteractor::Interactor.perform` now takes options
-
-## [v1.0.0-beta.2] - 2020-01-07
-
-### Added
-
-- [#102] `ActiveInteractor::Config`
-- [#102] `ActiveInteractor.config`
-- [#103] `ActiveInteractor::Rails`
-- [#103] `ActiveInteractor::Rails::Config`
-- [#102] `ActiveInteractor::Railtie`
-- [#105] interactor, organizer, and context generators now accept context_attributes
-  as arguments.
-
-### Changed
-
-- [#102] `ActiveInteractor.logger` is now part of `ActiveInteractor.config`
-- [#104] Interactor generators will no longer generate separate context classes for
-  interactors if `ActiveInteractor.config.rails.generate_context_classes` is set to `false`
-
-### Fixed
-
-- [#103] various generator fixes
-
-### Removed
-
-- [#102] `ActiveInteractor.logger=` use `ActiveInteractor.config.logger=` instead
-
-## [v1.0.0-beta.1] - 2020-01-06
-
-### Added
-
-- `ActiveInteractor.logger=`
-- `ActiveInteractor::Base#dup`
+- `ActiveInteractor::Config`
+- `ActiveInteractor::Configurable`
+- `ActiveInteractor::Context::Attributes#merge!`
+- `ActiveInteractor::Context::Base#merge`
 - `ActiveInteractor::Context::Loader`
+- `ActiveInteractor::Context::Status`
 - `ActiveInteractor::Error::InvalidContextClass`
+- `ActiveInteractor::Models`
+- `ActiveInteractor::Organizer::Callbacks`
+- `ActiveInteractor::Organizer::InteractorInterface`
+- `ActiveInteractor::Organizer::InteractorInterfaceCollection`
+- `ActiveInteractor::Organizer::Organize`
+- `ActiveInteractor::Organizer::Perform`
+- `ActiveInteractor::Interactor::Context.contextualize_with`
 - `ActiveInteractor::Interactor::Context#context_fail!`
 - `ActiveInteractor::Interactor::Context#context_rollback!`
-- `ActiveInteractor::Interactor::Context.contextualize_with`
 - `ActiveInteractor::Interactor::Context#finalize_context!`
+- `ActiveInteractor::Interactor::Perform`
+- `ActiveInteractor::Interactor::Perform::Options`
+- `ActiveInteractor::Rails`
+- `ActiveInteractor::Rails::Railtie`
 
 ### Changed
 
+- `ActiveInteractor::Base` now calls an `ActiveSupport.on_load` hook with `:active_interactor` and
+  `ActiveInteractor::Base`
 - `ActiveInteractor::Context::Attributes.attributes` now excepts arguments for attributes
-- `ActiveInteractor::Generators` various improvements to rails generators
+- `ActiveInteractor::Interactor.perform` now takes options
 - `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.
+- Moved `ActiveInteractor::Organizer` to `ActiveInteractor::Organizer::Base`
+- interactor, organizer, and context generators now accept `context_attributes`
+  as arguments.
+
+### Fixed
+
+- various rails generator fixes
 
 ### Removed
 
-- `ActiveInteractor::Configuration`
-- `ActiveInteractor::Context::Attributes.attributes=` in favor of `ActiveInteractor::Context#attributes`
+- `ActiveInteractor::Configuration` use `ActiveInteractor::Config`
+- `ActiveInteractor::Context::Attributes.attributes=` use `ActiveInteractor::Context#attributes`
 - `ActiveInteractor::Context::Attributes.attribute_aliases`
+- `ActiveInteractor::Context::Attributes.alias_attributes`
 - `ActiveInteractor::Context::Attributes#clean!`
 - `ActiveInteractor::Context::Attributes#keys`
 - `ActiveInteractor::Interactor#fail_on_invalid_context?`
+- `ActiveInteractor::Interactor#execute_rollback`
 - `ActiveInteractor::Interactor#should_clean_context?`
+- `ActiveInteractor::Interactor#skip_clean_context!`
+- `ActiveInteractor::Interactor::Callbacks.allow_context_to_be_invalid`
 - `ActiveInteractor::Interactor::Callbacks.clean_context_on_completion`
 - `ActiveInteractor::Interactor::Context.context_attribute_aliases`
 - `ActiveInteractor::Interactor::Execution`
+- `ActiveInteractor::Interactor::Worker#run_callbacks`
 
 ## [v0.1.7] - 2019-09-10
 
 ### Fixed
 
-- [#61] Ensure `Organizer` accurately reports context success
+- Ensure `Organizer` accurately reports context success
 
 ## [v0.1.6] - 2019-07-24
 
 ### Changed
 
-- [#45] Lowered method complexity and enforced single responsibility
+- Lowered method complexity and enforced single responsibility
 
 ### Security
 
-- [#48] Update simplecov: 0.16.1 → 0.17.0 (major)
-- [#51] Update rake: 12.3.2 → 12.3.3 (patch)
+- Update simplecov: 0.16.1 → 0.17.0 (major)
+- Update rake: 12.3.2 → 12.3.3 (patch)
 
 ## [v0.1.5] - 2019-06-30
 
 ### Added
 
-- [#39] `ActiveInteractor::Error` module
+- `ActiveInteractor::Error` module
 
 ### Deprecated
 
-- [#39] `ActiveInteractor::Context::Failure` in favor of `ActiveInteractor::Error::ContextFailure`
+- `ActiveInteractor::Context::Failure` in favor of `ActiveInteractor::Error::ContextFailure`
 
 ### Security
 
-- [#33], [#37] Update rubocop: 0.67.2 → 0.72.0 (major)
-- [#34] Various dependency updates
-- [#38] Update yard: 0.9.19 → 0.9.20 (minor)
+- Update rubocop: 0.67.2 → 0.72.0 (major)
+- Various dependency updates
+- Update yard: 0.9.19 → 0.9.20 (minor)
 
 ## [v0.1.4] - 2019-04-12
 
 ### Added
 
-- [#28] The ability to alias attributes on interactor contexts.
+- The ability to alias attributes on interactor contexts.
 
 ## [v0.1.3] - 2019-04-01
 
 ### Added
 
-- [#25] Implement `each_perform` callbacks on organizers
+- Implement `each_perform` callbacks on organizers
 
 ## [v0.1.2] - 2019-04-01
 
 ### Added
 
-- [#22] Allow the directory interactors are generated in to be configurable
+- Allow the directory interactors are generated in to be configurable
 
 ## [v0.1.1] - 2019-03-30
 
 ### Fixed
 
-- [#15] `NameError` (uninitialized constant `ActiveInteractor::Organizer`)
-- [#16] `NoMethodError` (undefined method `merge` for `ActiveInteractor::Context::Base`)
+- `NameError` (uninitialized constant `ActiveInteractor::Organizer`)
+- `NoMethodError` (undefined method `merge` for `ActiveInteractor::Context::Base`)
 
 ## v0.1.0 - 2019-03-30
 
@@ -208,14 +134,8 @@ and this project adheres to [Semantic Versioning].
 
 <!-- versions -->
 
-[Unreleased]: https://github.com/aaronmallen/activeinteractor/compare/v1.0.0-beta.7...HEAD
-[v1.0.0-beta.7]: https://github.com/aaronmallen/activeinteractor/compare/v1.0.0-beta.6...v1.0.0-beta.7
-[v1.0.0-beta.6]: https://github.com/aaronmallen/activeinteractor/compare/v1.0.0-beta.5...v1.0.0-beta.6
-[v1.0.0-beta.5]: https://github.com/aaronmallen/activeinteractor/compare/v1.0.0-beta.4...v1.0.0-beta.5
-[v1.0.0-beta.4]: https://github.com/aaronmallen/activeinteractor/compare/v1.0.0-beta.3...v1.0.0-beta.4
-[v1.0.0-beta.3]: https://github.com/aaronmallen/activeinteractor/compare/v1.0.0-beta.2...v1.0.0-beta.3
-[v1.0.0-beta.2]: https://github.com/aaronmallen/activeinteractor/compare/v1.0.0-beta.1...v1.0.0-beta.2
-[v1.0.0-beta.1]: https://github.com/aaronmallen/activeinteractor/compare/v0.1.7...v1.0.0-beta.1
+[Unreleased]: https://github.com/aaronmallen/activeinteractor/compare/v1.0.0...HEAD
+[v1.0.0]: https://github.com/aaronmallen/activeinteractor/compare/v0.1.7...v1.0.0
 [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
@@ -223,31 +143,3 @@ and this project adheres to [Semantic Versioning].
 [v0.1.3]: https://github.com/aaronmallen/activeinteractor/compare/v0.1.2...v0.1.3
 [v0.1.2]: https://github.com/aaronmallen/activeinteractor/compare/v0.1.1...v0.1.2
 [v0.1.1]: https://github.com/aaronmallen/activeinteractor/compare/v0.1.0...v0.1.1
-
-<!-- pull requests and issues -->
-
-[#15]: https://github.com/aaronmallen/activeinteractor/pull/15
-[#16]: https://github.com/aaronmallen/activeinteractor/pull/16
-[#22]: https://github.com/aaronmallen/activeinteractor/pull/22
-[#25]: https://github.com/aaronmallen/activeinteractor/pull/25
-[#28]: https://github.com/aaronmallen/activeinteractor/pull/28
-[#33]: https://github.com/aaronmallen/activeinteractor/pull/33
-[#34]: https://github.com/aaronmallen/activeinteractor/pull/34
-[#37]: https://github.com/aaronmallen/activeinteractor/pull/37
-[#38]: https://github.com/aaronmallen/activeinteractor/pull/38
-[#39]: https://github.com/aaronmallen/activeinteractor/pull/39
-[#45]: https://github.com/aaronmallen/activeinteractor/pull/45
-[#48]: https://github.com/aaronmallen/activeinteractor/pull/48
-[#51]: https://github.com/aaronmallen/activeinteractor/pull/51
-[#61]: https://github.com/aaronmallen/activeinteractor/pull/61
-[#102]: https://github.com/aaronmallen/activeinteractor/pull/102
-[#103]: https://github.com/aaronmallen/activeinteractor/pull/103
-[#104]: https://github.com/aaronmallen/activeinteractor/pull/104
-[#105]: https://github.com/aaronmallen/activeinteractor/pull/105
-[#109]: https://github.com/aaronmallen/activeinteractor/pull/109
-[#110]: https://github.com/aaronmallen/activeinteractor/pull/110
-[#114]: https://github.com/aaronmallen/activeinteractor/pull/114
-[#115]: https://github.com/aaronmallen/activeinteractor/pull/115
-[#122]: https://github.com/aaronmallen/activeinteractor/pull/122
-[#124]: https://github.com/aaronmallen/activeinteractor/pull/124
-[#127]: https://github.com/aaronmallen/activeinteractor/pull/127

data/README.md

@@ -8,50 +8,16 @@
 [![Code Quality](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://api.codacy.com/project/badge/Coverage/be92c4ecf12347da82d266f6a4368b6e)](https://www.codacy.com/manual/aaronmallen/activeinteractor?utm_source=github.com&utm_medium=referral&utm_content=aaronmallen/activeinteractor&utm_campaign=Badge_Coverage)
 
-Ruby interactors with [ActiveModel::Validations] based on the [interactor][collective_idea_interactors] gem.
-
-**ActiveInteractor v1.0.0 is currently in beta.  For documentation on the current stable version please
-see [v0.1.7](https://github.com/aaronmallen/activeinteractor/tree/0-1-stable)**
-
-<!-- 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)
-        * [Organizing Interactors Conditionally](#organizing-interactors-conditionally)
-        * [Running Interactors In Parallel](#running-interactors-in-parallel)
-    * [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)
-  * [Generators](#generators)
-  * [ActiveRecord Helper Methods](#activerecord-helper-methods)
-* [Development](#development)
-* [Contributing](#contributing)
-* [Acknowledgements](#acknowledgements)
-* [License](#license)
-
-<!-- TOC -->
+An implementation of the [command pattern] for Ruby with [ActiveModel::Validations] based on the
+[interactor][collective_idea_interactors] gem. Rich support for attributes, callbacks, and validations,
+and thread safe performance methods.
 
 ## Getting Started
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'activeinteractor', '~> 1.0.0.beta.7'
+gem 'activeinteractor'
 ```
 
 And then execute:
@@ -63,824 +29,14 @@ bundle
 Or install it yourself as:
 
 ```bash
-gem install activeinteractor --pre
+gem install activeinteractor
 ```
 
-## What is an Interactor
-
-An interactor is a simple, single-purpose service object.
-
-Interactors can be used to reduce the responsibility of your controllers,
-workers, and models and encapsulate your application's [business logic][business_logic_wikipedia].
-Each interactor represents one thing that your application does.
-
 ## Usage
 
-### Context
-
-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::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
-```
-
-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.
-
-```ruby
-class MyInteractor
-  def perform
-    context.user = User.create(...)
-  end
-end
-```
-
-#### Failing the Context
-
-When something goes wrong in your interactor, you can flag the context as failed.
-
-```ruby
-context.fail!
-```
-
-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.
-```
-
-```ruby
-context.fail!(user.errors)
-```
-
-You can ask a context if it's a failure:
-
-```ruby
-class MyInteractor
-  def perform
-    context.fail!
-  end
-end
-
-result = MyInteractor.perform
-result.failure? #=> true
-```
-
-or if it's a success:
-
-```ruby
-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 `perform`, then checks the `success?` method of the context.
-
-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 has basic attribute assignment methods. 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:
-
-```ruby
-class MyInteractorContext < ActiveInteractor::Context::Base
-  attributes :first_name, :last_name, :email, :user
-end
-
-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'>
-
-result.attributes #=> { first_name: 'Aaron', last_name: 'Allen', email: 'hello@aaronmallen.me' }
-result.occupation #=> 'Software Dude'
-```
-
-#### Validating the Context
-
-All context instances include [ActiveModel::Validations]; additionally 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.
-
-ActiveInteractor provides two validation callback steps:
+Be sure to read the [wiki] for detailed information on how to use ActiveInteractor.
 
-* `: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
-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
-
-  private
-
-  def user_is_a_user
-    return if user.is_a?(User)
-
-    errors.add(:user, :invalid)
-  end
-end
-
-class MyInteractor < 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)
-  end
-end
-
-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
-```
-
-### 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
-
-  private
-
-  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 and context:
-
-```ruby
-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.authenticate(
-      context.email,
-      context.password
-    )
-    context.token = context.user.secret_token
-  end
-end
-```
-
-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.
-
-#### Kinds of Interactors
-
-There are two kinds of interactors built into ActiveInteractor: basic interactors and organizers.
-
-##### Interactors
-
-A basic interactor is a class that inherits from `ActiveInteractor::Base` and defines `perform`.
-
-```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
-```
-
-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 CreateOrder < ActiveInteractor::Base
-  def perform
-    ...
-  end
-end
-
-class ChargeCard < ActiveInteractor::Base
-  def perform
-    ...
-  end
-end
-
-class SendThankYou < ActiveInteractor::Base
-  def perform
-    ...
-  end
-end
-
-class PlaceOrder < ActiveInteractor::Organizer
-
-  organize :create_order, :charge_card, :send_thank_you
-end
-```
-
-In the controller, you can run the `PlaceOrder` organizer just like you would any other interactor:
-
-```ruby
-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 order_params
-    params.require(:order).permit!
-  end
-end
-```
-
-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.
-
-###### Organizing Interactors Conditionally
-
-We can also add conditional statements to our organizer by passing a block to the `.organize` method:
-
-```ruby
-class PlaceOrder < ActiveInteractor::Organizer
-  organize do
-    add :create_order, if :user_registered?
-    add :charge_card, if: -> { context.order }
-    add :send_thank_you, if: -> { context.order }
-  end
-
-  private
-
-  def user_registered?
-    context.user&.registered?
-  end
-end
-```
-
-###### Running Interactors In Parallel
-
-Organizers can be told to run their interactors in parallel with the `.perform_in_parallel` class method.  This
-will run each interactor in parallel with one and other only passing the original context to each interactor.
-This means each interactor must be able to perform without dependencies on prior interactor invokations.
-
-```ruby
-class CreateNewUser < ActiveInteractor::Base
-  def perform
-    context.user = User.create(
-      first_name: context.first_name,
-      last_name: context.last_name
-    )
-  end
-end
-
-class LogNewUserCreation < ActiveInteractor::Base
-  def perform
-    context.log = Log.create(
-      event: 'new user created',
-      first_name: context.first_name,
-      last_name: context.last_name
-    )
-  end
-end
-
-class CreateUser < ActiveInteractor::Organizer
-  perform_in_parallel
-  organize :create_new_user, :log_new_user_creation
-end
-
-CreateUser.perform(first_name: 'Aaron', last_name: 'Allen')
-#=> <#CreateUser::Context first_name='Aaron' last_name='Allen' user=>#<User ...> log=<#Log ...>>
-```
-
-#### 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
-```
-
-#### 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
-  before_context_validation { context.last_name ||= 'Unknown' }
-end
-
-result = MyInteractor.perform(first_name: 'Aaron', email: 'hello@aaronmallen.me')
-result.valid? #=> true
-result.last_name #=> 'Unknown'
-```
-
-We can do work after an interactor's context is validated with the `.after_context_validation` method:
-
-```ruby
-class MyInteractorContext < ActiveInteractor::Context::Base
-  attributes :first_name, :last_name, :email
-  validates :email, presence: true,
-                    format: { with: URI::MailTo::EMAIL_REGEXP }
-end
-
-class MyInteractor < ActiveInteractor::Base
-  after_context_validation { context.email&.downcase! }
-end
-
-result = MyInteractor.perform(first_name: 'Aaron', last_name: 'Allen', email: 'HELLO@AARONMALLEN.ME')
-result.valid? #=> true
-result.email #=> 'hello@aaronmallen.me'
-```
-
-##### Perform Callbacks
-
-We can do work before `#perform` is invoked with the `.before_perform` method:
-
-```ruby
-class MyInteractor < ActiveInteractor::Base
-  before_perform :print_start
-
-  def perform
-    puts 'Performing'
-  end
-
-  private
-
-  def print_start
-    puts 'Start'
-  end
-end
-
-MyInteractor.perform
-"Start"
-"Performing"
-#=> <#MyInteractor::Context...>
-```
-
-We can do work around `#perform` invokation with the `.around_perform` method:
-
-```ruby
-class MyInteractor < ActiveInteractor::Base
-  around_perform :track_time
-
-  def perform
-    sleep(1)
-  end
-
-  private
-
-  def track_time
-    context.start_time = Time.now.utc
-    yield
-    context.end_time = Time.now.utc
-  end
-end
-
-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:
-
-```ruby
-class MyInteractor < ActiveInteractor::Base
-  after_perform :print_done
-
-  def perform
-    puts 'Performing'
-  end
-
-  private
-
-  def print_done
-    puts 'Done'
-  end
-end
-
-MyInteractor.perform
-"Performing"
-"Done"
-#=> <#MyInteractor::Context...>
-```
-
-##### Rollback Callbacks
-
-We can do work before `#rollback` is invoked with the `.before_rollback` method:
-
-```ruby
-class MyInteractor < ActiveInteractor::Base
-  before_rollback :print_start
-
-  def perform
-    context.fail!
-  end
-
-  def rollback
-    puts 'Rolling Back'
-  end
-
-  private
-
-  def print_start
-    puts 'Start'
-  end
-end
-
-MyInteractor.perform
-"Start"
-"Rolling Back"
-#=> <#MyInteractor::Context...>
-```
-
-We can do work around `#rollback` invokation with the `.around_rollback` method:
-
-```ruby
-class MyInteractor < ActiveInteractor::Base
-  around_rollback :track_time
-
-  def perform
-    context.fail!
-  end
-
-  def rollback
-    sleep(1)
-  end
-
-  private
-
-  def track_time
-    context.start_time = Time.now.utc
-    yield
-    context.end_time = Time.now.utc
-  end
-end
-
-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:
-
-```ruby
-class MyInteractor < ActiveInteractor::Base
-  after_rollback :print_done
-
-  def perform
-    context.fail!
-  end
-
-  def rollback
-    puts 'Rolling Back'
-  end
-
-  private
-
-  def print_done
-    puts 'Done'
-  end
-end
-
-MyInteractor.perform
-"Rolling Back"
-"Done"
-#=> <#MyInteractor::Context...>
-```
-
-##### Organizer Callbacks
-
-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
-  def perform
-    puts 'MyInteractor1'
-  end
-end
-
-class MyInteractor2 < ActiveInteractor::Base
-  def perform
-    puts 'MyInteractor2'
-  end
-end
-
-class MyOrganizer < ActiveInteractor::Organizer
-  before_each_perform :print_start
-
-  organized MyInteractor1, MyInteractor2
-
-  private
-
-  def print_start
-    puts "Start"
-  end
-end
-
-MyOrganizer.perform
-"Start"
-"MyInteractor1"
-"Start"
-"MyInteractor2"
-#=> <MyOrganizer::Context...>
-```
-
-We can do worker around `#perform` invokation on each interactor in an [Organizer](#organizers) with the
-`.around_each_perform` method:
-
-```ruby
- class MyInteractor1 < ActiveInteractor::Base
-  def perform
-    puts 'MyInteractor1'
-    sleep(1)
-  end
-end
-
-class MyInteractor2 < ActiveInteractor::Base
-  def perform
-    puts 'MyInteractor2'
-    sleep(1)
-  end
-end
-
-class MyOrganizer < ActiveInteractor::Organizer
-  around_each_perform :print_time
-
-  organized MyInteractor1, MyInteractor2
-
-  private
-
-  def print_time
-    puts Time.now.utc
-    yield
-    puts Time.now.utc
-  end
-end
-
-MyOrganizer.perform
-"2019-01-01 00:00:00 UTC"
-"MyInteractor1"
-"2019-01-01 00:00:01 UTC"
-"2019-01-01 00:00:01 UTC"
-"MyInteractor2"
-"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:
-
-```ruby
-class MyInteractor1 < ActiveInteractor::Base
-  def perform
-    puts 'MyInteractor1'
-  end
-end
-
-class MyInteractor2 < ActiveInteractor::Base
-  def perform
-    puts 'MyInteractor2'
-  end
-end
-
-class MyOrganizer < ActiveInteractor::Organizer
-  after_each_perform :print_done
-
-  organized MyInteractor1, MyInteractor2
-
-  private
-
-  def print_done
-    puts "Done"
-  end
-end
-
-MyOrganizer.perform
-"MyInteractor1"
-"Done"
-"MyInteractor2"
-"Done"
-#=> <MyOrganizer::Context...>
-```
-
-## Working With Rails
-
-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:
-
-```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 a some new classes `ApplicationInteractor`, `ApplicationOrganizer` and
-`ApplicationContext` in the `app/<directory>` directory.
-
-### Generators
-
-ActiveInteractor comes bundled with some rails generators to automatically generate interactors,
-organizers, and contexts with:
-
-```bash
-rails generate interactor MyInteractor
-```
-
-```bash
-rails generate interactor:organizer MyInteractor1 MyInteractor2
-```
-
-```bash
-rails generate interactor:context MyContext
-```
-
-These generators will automatically create the approriate classes and matching spec or test files.
-
-### ActiveRecord Helper Methods
-
-In some instances you may want to use an `ActiveRecord` model as a context for an interactor.  You can
-do this by calling the `acts_as_context` method on any `ActiveRecord` model, and then simply call the
-`contextualize_with` method on your interactor or organizer to point it to the approriate class.
-
-```ruby
-# app/models/user
-class User < ApplicationRecord
-  acts_as_context
-end
-
-# app/interactors/create_user
-class CreateUser < ApplicationInteractor
-  contextualize_with :user
-
-  def perform
-    context.email&.downcase!
-    context.save
-  end
-end
-
-CreateUser.perform(email: 'HELLO@AARONMALLEN.ME')
-#=> <#User id=1 email='hello@aaronmallen.me'>
-```
+For technical documentation please see the gem's [ruby docs].
 
 ## Development
 
@@ -904,13 +60,14 @@ Read our guidelines for [Contributing](CONTRIBUTING.md).
 
 The gem is available as open source under the terms of the [MIT License][mit_license].
 
-[ActiveModel::Callbacks]: https://api.rubyonrails.org/classes/ActiveModel/Callbacks.html
-[ActiveModel::Validations]: https://api.rubyonrails.org/classes/ActiveModel/Validations.html
-[ActiveModel::Validations::Callbacks]: https://api.rubyonrails.org/classes/ActiveModel/Validations/Callbacks.html
-[collective_idea_interactors]: https://github.com/collectiveidea/interactor
-[business_logic_wikipedia]: https://en.wikipedia.org/wiki/Business_logic
 [@collectiveidea]: https://github.com/collectiveidea
 [@rails]: https://github.com/rails
 [active_model_git]: https://github.com/rails/rails/tree/master/activemodel
 [active_support_git]: https://github.com/rails/rails/tree/master/activesupport
+[ActiveModel::Validations]: https://api.rubyonrails.org/classes/ActiveModel/Validations.html
+[business_logic_wikipedia]: https://en.wikipedia.org/wiki/Business_logic
+[collective_idea_interactors]: https://github.com/collectiveidea/interactor
+[command pattern]: https://en.wikipedia.org/wiki/Command_pattern
 [mit_license]: https://opensource.org/licenses/MIT
+[ruby docs]: https://www.rubydoc.info/gems/activeinteractor
+[wiki]: https://github.com/aaronmallen/activeinteractor/wiki