RubyGems - activeinteractor - Versions diffs - 1.0.0.beta.7 → 1.0.0 - Mend

activeinteractor 1.0.0.beta.7 → 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (102) hide show

checksums.yaml CHANGED Viewed

@@ -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 ADDED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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&amp;utm_medium=referral&amp;utm_content=aaronmallen/activeinteractor&amp;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