interactor 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6832397e4ab11a93ded8ded31c4e47519be8fe34
+  data.tar.gz: 3ffdfed6582a46b97745356133e5b34a2c3d3b0c
+SHA512:
+  metadata.gz: e744650c5033bab652b44d122fc7a1b785d7ab8d22e9afc654a2b1f2e1071f8fdf1846e7c3c68e3163cdd2892ea1ad8d98c37ef9bf8b75c8351b21f13d04215f
+  data.tar.gz: 81ba3295b6dc2cf3991919708b46cb7e83d1f964799f9b6262e46bfbc78733c337f823bc4401c3fec6822154ddf7ccc0abdc63167cc15865ca5f01453f5381df

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,8 @@
+branches:
+  only:
+    - master
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+script: rspec

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :test do
+  gem "coveralls", "~> 0.6.7", require: false
+  gem "rspec", "~> 2.14"
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Collective Idea
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,280 @@
+# Interactor
+
+[![Gem Version](https://badge.fury.io/rb/interactor.png)](http://badge.fury.io/rb/interactor)
+[![Build Status](https://travis-ci.org/collectiveidea/interactor.png?branch=master)](https://travis-ci.org/collectiveidea/interactor)
+[![Code Climate](https://codeclimate.com/github/collectiveidea/interactor.png)](https://codeclimate.com/github/collectiveidea/interactor)
+[![Coverage Status](https://coveralls.io/repos/collectiveidea/interactor/badge.png?branch=master)](https://coveralls.io/r/collectiveidea/interactor?branch=master)
+[![Dependency Status](https://gemnasium.com/collectiveidea/interactor.png)](https://gemnasium.com/collectiveidea/interactor)
+
+Interactor provides a common interface for performing complex interactions in a single request.
+
+## Problems
+
+If you're like us at [Collective Idea](http://collectiveidea.com), you've noticed that there seems to be a layer missing between the Controller and the Model.
+
+### Fat Models
+
+We've been told time after time to keep our controllers "skinny" but this usually comes at the expense of our models becoming pretty flabby. Oftentimes, much of the excess weight doesn't belong on the model. We're sending emails, making calls to external services and more, all from the model. It's not right.
+
+*The purpose of the model layer is to be a gatekeeper to the application's data.*
+
+Consider the following model:
+
+```ruby
+class User < ActiveRecord::Base
+  validates :name, :email, presence: true
+
+  after_create :send_welcome_email
+
+  private
+
+  def send_welcome_email
+    Notifier.welcome(self).deliver
+  end
+end
+```
+
+We see this pattern all too often. The problem is that *any* time we want to add a user to the application, the welcome email will be sent. That includes creating users in development and in your tests. Is that really what we want?
+
+Sending a welcome email is business logic. It has nothing to do with the integrity of the application's data, so it belongs somewhere else.
+
+### Fat Controllers
+
+Usually, the alternative to fat models is fat controllers.
+
+While business logic may be more at home in a controller, controllers are typically intermingled with the concept of a request. HTTP requests are complex and that fact makes testing your business logic more difficult than it should be.
+
+*Your business logic should be unaware of your delivery mechanism.*
+
+So what if we encapsulated all of our business logic in dead-simple Ruby. One glance at a directory like `app/interactors` could go a long way in answering the question, "What does this app do?".
+
+```
+▸ app/
+  ▾ interactors/
+    add_product_to_cart.rb
+    authenticate_user.rb
+    place_order.rb
+    register_user.rb
+    remove_product_from_cart.rb
+```
+
+## Interactors
+
+An interactor is an object with a simple interface and a singular purpose.
+
+Interactors are given a context from the controller and do one thing: perform. When an interactor performs, it may act on models, send emails, make calls to external services and more. The interactor may also modify the given context.
+
+A simple interactor may look like:
+
+```ruby
+class AuthenticateUser
+  include Interactor
+
+  def perform
+    if user = User.authenticate(context[:email], context[:password])
+      context[:user] = user
+    else
+      context.fail!
+    end
+  end
+end
+```
+
+There are a few important things to note about this interactor:
+
+1. It's simple.
+2. It's just Ruby.
+3. It's easily testable.
+
+It's feasible that a collection of small interactors such as these could encapsulate *all* of your business logic.
+
+Interactors free up your controllers to simply accept requests and build responses. They free up your models to acts as the gatekeepers to your data.
+
+## Organizers
+
+An organizer is just an interactor that's in charge of other interactors. When an organizer is asked to perform, it just asks its interactors to perform, in order.
+
+Organizers are great for complex interactions. For example, placing an order might involve:
+
+* checking inventory
+* calculating tax
+* charging a credit card
+* writing an order to the database
+* sending email notifications
+* scheduling a follow-up email
+
+Each of these actions can (and should) have its own interactor and one organizer can perform them all. That organizer may look like:
+
+```ruby
+class PlaceOrder
+  include Interactor::Organizer
+
+  organize [
+    CheckInventory,
+    CalculateTax,
+    ChargeCard,
+    CreateOrder,
+    DeliverThankYou,
+    DeliverOrderNotification,
+    ScheduleFollowUp
+  ]
+end
+```
+
+Breaking your interactors into bite-sized pieces also gives you the benefit or reusability. In our example above, there may be several scenarios where you may want to check inventory. Encapsulating that logic in one interactor enables you to reuse that interactor, reducing duplication.
+
+## Examples
+
+### Interactors
+
+Take the simple case of authenticating a user.
+
+Using an interactor, the controller stays very clean, making it very readable and easily testable.
+
+```ruby
+class SessionsController < ApplicationController
+  def create
+    result = AuthenticateUser.perform(session_params)
+
+    if result.success?
+      redirect_to result.user
+    else
+      render :new
+    end
+  end
+
+  private
+
+  def session_params
+    params.require(:session).permit(:email, :password)
+  end
+end
+```
+
+The `result` above is an instance of the `AuthenticateUser` interactor that has been performed. The magic happens in the interactor, after receiving a *context* from the controller. A context is just a glorified hash that the interactor manipulates.
+
+```ruby
+class AuthenticateUser
+  include Interactor
+
+  def perform
+    if user = User.authenticate(context[:email], context[:password])
+      context[:user] = user
+    else
+      context.fail!
+    end
+  end
+end
+```
+
+The interactor also has convenience methods for dealing with its context. Anything added to the context is available via getter method on the interactor instance. The following is equivalent:
+
+```ruby
+class AuthenticateUser
+  include Interactor
+
+  def perform
+    if user = User.authenticate(email, password)
+      context[:user] = user
+    else
+      fail!
+    end
+  end
+end
+```
+
+An interactor can fail with an optional hash that is merged into the context.
+
+```ruby
+fail!(message: "Uh oh!")
+```
+
+Interactors are successful until explicitly failed. Instances respond to `success?` and `failure?`.
+
+### Organizers
+
+In the example above, one could argue that the interactor is simple enough that it could be excluded altogether. While that's probably true, in [our](http://collectiveidea.com) experience, these interactions don't stay simple for long. When they get more complex, the `AuthenticateUser` interactor can be converted to an organizer.
+
+```ruby
+class AuthenticateUser
+  include Interactor::Organizer
+
+  organize FindUserByEmailAndPassword, SendWelcomeEmail
+end
+```
+
+And your controller doesn't change a bit!
+
+The `AuthenticateUser` organizer receives its context from the controller and passes it to the interactors, which each manipulate it in turn.
+
+```ruby
+class FindUserByEmailAndPassword
+  include Interactor
+
+  def perform
+    if user = User.authenticate(email, password)
+      context[:user] = user
+    else
+      fail!
+    end
+  end
+end
+```
+
+```ruby
+class SendWelcomeEmail
+  include Interactor
+
+  def perform
+    if user.newly_created?
+      Notifier.welcome(user).deliver
+      context[:new_user] = true
+    end
+  end
+end
+```
+
+#### Inception
+
+Because interactors and organizers adhere to the same interface, it's trivial for an organizer to organize… organizers!
+
+#### Rollback
+
+If an organizer has three interactors and the second one fails, the third one is never called.
+
+In addition to halting the chain, an organizer will also *rollback* through the interactors that it has performed so that each interactor has the opportunity to undo itself. Just define a `rollback` method. It has all the same access to the context as `perform` does.
+
+## Conventions
+
+We love Rails, and we use Interactor with Rails. We put our interactors in `app/interactors` and we name them as verbs:
+
+* `AddProductToCart`
+* `AuthenticateUser`
+* `PlaceOrder`
+* `RegisterUser`
+* `RemoveProductFromCart`
+
+See [Interactor Rails](https://github.com/collectiveidea/interactor-rails)
+
+## Contributions
+
+Interactor is open source and contributions from the community are encouraged! No contribution is too small. Please consider:
+
+* adding an awesome feature
+* fixing a terrible bug
+* updating documentation
+* fixing a not-so-bad bug
+* fixing typos
+
+For the best chance of having your changes merged, please:
+
+1. Ask us! We'd love to hear what you're up to.
+2. Fork the project.
+3. Commit your changes and tests (if applicable (they're applicable)).
+4. Submit a pull request with a thorough explanation and at least one animated GIF.
+
+## Thanks
+
+A very special thank you to [Attila Domokos](https://github.com/adomokos) for his fantastic work on [LightService](https://github.com/adomokos/light-service). Interactor is inspired heavily by the concepts put to code by Attila.
+
+Interactor was born from a desire for a slightly different (in our minds, simplified) interface. We understand that this is a matter of personal preference, so please take a look at LightService as well!

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/interactor.gemspec

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+Gem::Specification.new do |spec|
+  spec.name    = "interactor"
+  spec.version = "1.0.0"
+
+  spec.author      = "Collective Idea"
+  spec.email       = "info@collectiveidea.com"
+  spec.description = "Interactor provides a common interface for performing complex interactions in a single request."
+  spec.summary     = "Simple interactor implementation"
+  spec.homepage    = "https://github.com/collectiveidea/interactor"
+  spec.license     = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.test_files    = spec.files.grep(/^spec/)
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 10.1"
+end

data/lib/interactor.rb

@@ -0,0 +1,59 @@
+require "interactor/context"
+require "interactor/organizer"
+
+module Interactor
+  def self.included(base)
+    base.class_eval do
+      extend ClassMethods
+      include InstanceMethods
+
+      attr_reader :context
+    end
+  end
+
+  module ClassMethods
+    def perform(context = {})
+      new(context).tap(&:perform)
+    end
+
+    def rollback(context = {})
+      new(context).tap(&:rollback)
+    end
+  end
+
+  module InstanceMethods
+    def initialize(context = {})
+      @context = Context.build(context)
+      setup
+    end
+
+    def setup
+    end
+
+    def perform
+    end
+
+    def rollback
+    end
+
+    def success?
+      context.success?
+    end
+
+    def failure?
+      context.failure?
+    end
+
+    def fail!(*args)
+      context.fail!(*args)
+    end
+
+    def method_missing(method, *)
+      context.fetch(method) { super }
+    end
+
+    def respond_to_missing?(method, *)
+      context.key?(method) || super
+    end
+  end
+end

data/lib/interactor/context.rb

@@ -0,0 +1,20 @@
+module Interactor
+  class Context < ::Hash
+    def self.build(context = {})
+      self === context ? context : new.replace(context)
+    end
+
+    def success?
+      !failure?
+    end
+
+    def failure?
+      @failure || false
+    end
+
+    def fail!(context = {})
+      update(context)
+      @failure = true
+    end
+  end
+end

data/lib/interactor/organizer.rb

@@ -0,0 +1,46 @@
+module Interactor
+  module Organizer
+    def self.included(base)
+      base.class_eval do
+        include Interactor
+
+        extend ClassMethods
+        include InstanceMethods
+      end
+    end
+
+    module ClassMethods
+      def interactors
+        @interactors ||= []
+      end
+
+      def organize(*interactors)
+        @interactors = interactors.flatten
+      end
+    end
+
+    module InstanceMethods
+      def interactors
+        self.class.interactors
+      end
+
+      def perform
+        interactors.each do |interactor|
+          performed << interactor
+          interactor.perform(context)
+          rollback && break if context.failure?
+        end
+      end
+
+      def rollback
+        performed.reverse_each do |interactor|
+          interactor.rollback(context)
+        end
+      end
+
+      def performed
+        @performed ||= []
+      end
+    end
+  end
+end

data/spec/interactor/context_spec.rb

@@ -0,0 +1,95 @@
+require "spec_helper"
+
+module Interactor
+  describe Context do
+    describe ".build" do
+      it "converts the given hash to a context" do
+        context = Context.build(foo: "bar")
+
+        expect(context).to be_a(Context)
+        expect(context).to eq(foo: "bar")
+      end
+
+      it "builds an empty context if no hash is given" do
+        context = Context.build
+
+        expect(context).to be_a(Context)
+        expect(context).to eq({})
+      end
+
+      it "preserves an already built context" do
+        context1 = Context.build(foo: "bar")
+        context2 = Context.build(context1)
+
+        expect(context2).to be_a(Context)
+        expect {
+          context2[:foo] = "baz"
+        }.to change {
+          context1[:foo]
+        }.from("bar").to("baz")
+      end
+    end
+
+    describe "#success?" do
+      let(:context) { Context.build }
+
+      it "is true by default" do
+        expect(context.success?).to eq(true)
+      end
+    end
+
+    describe "#failure?" do
+      let(:context) { Context.build }
+
+      it "is false by default" do
+        expect(context.failure?).to eq(false)
+      end
+    end
+
+    describe "#fail!" do
+      let(:context) { Context.build(foo: "bar") }
+
+      it "sets success to false" do
+        expect {
+          context.fail!
+        }.to change {
+          context.success?
+        }.from(true).to(false)
+      end
+
+      it "sets failure to true" do
+        expect {
+          context.fail!
+        }.to change {
+          context.failure?
+        }.from(false).to(true)
+      end
+
+      it "preserves failure" do
+        context.fail!
+
+        expect {
+          context.fail!
+        }.not_to change {
+          context.failure?
+        }
+      end
+
+      it "preserves the context" do
+        expect {
+          context.fail!
+        }.not_to change {
+          context[:foo]
+        }
+      end
+
+      it "updates the context" do
+        expect {
+          context.fail!(foo: "baz")
+        }.to change {
+          context[:foo]
+        }.from("bar").to("baz")
+      end
+    end
+  end
+end

data/spec/interactor/organizer_spec.rb

@@ -0,0 +1,132 @@
+require "spec_helper"
+
+module Interactor
+  describe Organizer do
+    include_examples :lint
+
+    let(:interactor) { Class.new.send(:include, Organizer) }
+
+    describe ".interactors" do
+      it "is empty by default" do
+        expect(interactor.interactors).to eq([])
+      end
+    end
+
+    describe ".organize" do
+      let(:interactor2) { double(:interactor2) }
+      let(:interactor3) { double(:interactor3) }
+
+      it "sets interactors given class arguments" do
+        expect {
+          interactor.organize(interactor2, interactor3)
+        }.to change {
+          interactor.interactors
+        }.from([]).to([interactor2, interactor3])
+      end
+
+      it "sets interactors given an array of classes" do
+        expect {
+          interactor.organize([interactor2, interactor3])
+        }.to change {
+          interactor.interactors
+        }.from([]).to([interactor2, interactor3])
+      end
+    end
+
+    describe "#interactors" do
+      let(:interactors) { double(:interactors) }
+      let(:instance) { interactor.new }
+
+      before do
+        interactor.stub(:interactors) { interactors }
+      end
+
+      it "defers to the class" do
+        expect(instance.interactors).to eq(interactors)
+      end
+    end
+
+    describe "#perform" do
+      let(:interactor2) { double(:interactor2) }
+      let(:interactor3) { double(:interactor3) }
+      let(:interactor4) { double(:interactor4) }
+      let(:instance) { interactor.new }
+      let(:context) { instance.context }
+
+      before do
+        interactor.stub(:interactors) { [interactor2, interactor3, interactor4] }
+      end
+
+      it "performs each interactor in order with the context" do
+        expect(interactor2).to receive(:perform).once.with(context).ordered
+        expect(interactor3).to receive(:perform).once.with(context).ordered
+        expect(interactor4).to receive(:perform).once.with(context).ordered
+
+        expect(instance).not_to receive(:rollback)
+
+        instance.perform
+      end
+
+      it "builds up the performed interactors" do
+        interactor2.stub(:perform) do
+          expect(instance.performed).to eq([interactor2])
+        end
+
+        interactor3.stub(:perform) do
+          expect(instance.performed).to eq([interactor2, interactor3])
+        end
+
+        interactor4.stub(:perform) do
+          expect(instance.performed).to eq([interactor2, interactor3, interactor4])
+        end
+
+        expect {
+          instance.perform
+        }.to change {
+          instance.performed
+        }.from([]).to([interactor2, interactor3, interactor4])
+      end
+
+      it "aborts and rolls back on failure" do
+        expect(interactor2).to receive(:perform).once.with(context).ordered
+        expect(interactor3).to receive(:perform).once.with(context).ordered { context.fail! }
+        expect(interactor4).not_to receive(:perform)
+
+        expect(instance).to receive(:rollback).once.ordered do
+          expect(instance.performed).to eq([interactor2, interactor3])
+        end
+
+        instance.perform
+      end
+    end
+
+    describe "#rollback" do
+      let(:interactor2) { double(:interactor2) }
+      let(:interactor3) { double(:interactor3) }
+      let(:interactor4) { double(:interactor4) }
+      let(:instance) { interactor.new }
+      let(:context) { instance.context }
+
+      before do
+        interactor.stub(:interactors) { [interactor2, interactor3, interactor4] }
+        instance.stub(:performed) { [interactor2, interactor3] }
+      end
+
+      it "rolls back each performed interactor in reverse" do
+        expect(interactor4).not_to receive(:rollback)
+        expect(interactor3).to receive(:rollback).once.with(context).ordered
+        expect(interactor2).to receive(:rollback).once.with(context).ordered
+
+        instance.rollback
+      end
+    end
+
+    describe "#performed" do
+      let(:instance) { interactor.new }
+
+      it "is empty by default" do
+        expect(instance.performed).to eq([])
+      end
+    end
+  end
+end

data/spec/interactor_spec.rb

@@ -0,0 +1,5 @@
+require "spec_helper"
+
+describe Interactor do
+  include_examples :lint
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require "coveralls"
+Coveralls.wear!
+
+require "interactor"
+
+Dir[File.expand_path("../support/*.rb", __FILE__)].each { |f| require f }

data/spec/support/expect.rb

@@ -0,0 +1,3 @@
+RSpec.configure do |config|
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
+end

data/spec/support/lint.rb

@@ -0,0 +1,162 @@
+shared_examples :lint do
+  let(:interactor) { Class.new.send(:include, described_class) }
+
+  describe ".perform" do
+    let(:instance) { double(:instance) }
+
+    it "performs an instance with the given context" do
+      expect(interactor).to receive(:new).once.with(foo: "bar") { instance }
+      expect(instance).to receive(:perform).once.with(no_args)
+
+      expect(interactor.perform(foo: "bar")).to eq(instance)
+    end
+
+    it "provides a blank context if none is given" do
+      expect(interactor).to receive(:new).once.with({}) { instance }
+      expect(instance).to receive(:perform).once.with(no_args)
+
+      expect(interactor.perform).to eq(instance)
+    end
+  end
+
+  describe ".rollback" do
+    let(:instance) { double(:instance) }
+
+    it "rolls back an instance with the given context" do
+      expect(interactor).to receive(:new).once.with(foo: "bar") { instance }
+      expect(instance).to receive(:rollback).once.with(no_args)
+
+      expect(interactor.rollback(foo: "bar")).to eq(instance)
+    end
+
+    it "provides a blank context if none is given" do
+      expect(interactor).to receive(:new).once.with({}) { instance }
+      expect(instance).to receive(:rollback).once.with(no_args)
+
+      expect(interactor.rollback).to eq(instance)
+    end
+  end
+
+  describe ".new" do
+    let(:context) { double(:context) }
+
+    it "initializes a context" do
+      expect(Interactor::Context).to receive(:build).once.with(foo: "bar") { context }
+
+      instance = interactor.new(foo: "bar")
+
+      expect(instance).to be_a(interactor)
+      expect(instance.context).to eq(context)
+    end
+
+    it "initializes a blank context if none is given" do
+      expect(Interactor::Context).to receive(:build).once.with({}) { context }
+
+      instance = interactor.new
+
+      expect(instance).to be_a(interactor)
+      expect(instance.context).to eq(context)
+    end
+
+    it "calls setup" do
+      interactor.class_eval do
+        def setup
+          context[:foo] = bar
+        end
+      end
+
+      instance = interactor.new(bar: "baz")
+
+      expect(instance.context[:foo]).to eq("baz")
+    end
+  end
+
+  describe "#setup" do
+    let(:instance) { interactor.new }
+
+    it "exists" do
+      expect(instance).to respond_to(:setup)
+      expect { instance.setup }.not_to raise_error
+      expect { instance.method(:setup) }.not_to raise_error
+    end
+  end
+
+  describe "#perform" do
+    let(:instance) { interactor.new }
+
+    it "exists" do
+      expect(instance).to respond_to(:perform)
+      expect { instance.perform }.not_to raise_error
+      expect { instance.method(:perform) }.not_to raise_error
+    end
+  end
+
+  describe "#rollback" do
+    let(:instance) { interactor.new }
+
+    it "exists" do
+      expect(instance).to respond_to(:rollback)
+      expect { instance.rollback }.not_to raise_error
+      expect { instance.method(:rollback) }.not_to raise_error
+    end
+  end
+
+  describe "#success?" do
+    let(:instance) { interactor.new }
+    let(:context) { instance.context }
+
+    it "defers to the context" do
+      context.stub(success?: true)
+      expect(instance.success?).to eq(true)
+
+      context.stub(success?: false)
+      expect(instance.success?).to eq(false)
+    end
+  end
+
+  describe "#failure?" do
+    let(:instance) { interactor.new }
+    let(:context) { instance.context }
+
+    it "defers to the context" do
+      context.stub(failure?: true)
+      expect(instance.failure?).to eq(true)
+
+      context.stub(failure?: false)
+      expect(instance.failure?).to eq(false)
+    end
+  end
+
+  describe "#fail!" do
+    let(:instance) { interactor.new }
+    let(:context) { instance.context }
+
+    it "defers to the context" do
+      expect(context).to receive(:fail!).once.with(no_args)
+
+      instance.fail!
+    end
+
+    it "passes updates to the context" do
+      expect(context).to receive(:fail!).once.with(foo: "bar")
+
+      instance.fail!(foo: "bar")
+    end
+  end
+
+  describe "context deferral" do
+    let(:instance) { interactor.new(foo: "bar") }
+
+    it "defers to keys that exist in the context" do
+      expect(instance).to respond_to(:foo)
+      expect(instance.foo).to eq("bar")
+      expect { instance.method(:foo) }.not_to raise_error
+    end
+
+    it "bombs if the key does not exist in the context" do
+      expect(instance).not_to respond_to(:baz)
+      expect { instance.baz }.to raise_error(NoMethodError)
+      expect { instance.method(:baz) }.to raise_error(NameError)
+    end
+  end
+end

data/spec/support/random.rb

@@ -0,0 +1,3 @@
+RSpec.configure do |config|
+  config.order = "random"
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: interactor
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Collective Idea
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+description: Interactor provides a common interface for performing complex interactions
+  in a single request.
+email: info@collectiveidea.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- interactor.gemspec
+- lib/interactor.rb
+- lib/interactor/context.rb
+- lib/interactor/organizer.rb
+- spec/interactor/context_spec.rb
+- spec/interactor/organizer_spec.rb
+- spec/interactor_spec.rb
+- spec/spec_helper.rb
+- spec/support/expect.rb
+- spec/support/lint.rb
+- spec/support/random.rb
+homepage: https://github.com/collectiveidea/interactor
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.5
+signing_key: 
+specification_version: 4
+summary: Simple interactor implementation
+test_files:
+- spec/interactor/context_spec.rb
+- spec/interactor/organizer_spec.rb
+- spec/interactor_spec.rb
+- spec/spec_helper.rb
+- spec/support/expect.rb
+- spec/support/lint.rb
+- spec/support/random.rb