subroutine 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ab045b5fde4a639699ed15240b6549dd909454da
+  data.tar.gz: 56ac432123c26d31a5265c304fce0c6268dab892
+SHA512:
+  metadata.gz: bebe659c3d84427adbacbe3bc0bffecfcfef2155cd6c4497a530f820d0198c43e2f899933b32c82ec21f678d2d021f1a0fd4f50524ef1faf9793247185f2253a
+  data.tar.gz: 6e561078a1f08f1159f25ee590ad5cdeff1d185aba711f36ec0ef4ac0263f8ae79715e557d84b7ee3ebe318cc74f93de65676ac82986913d11fb738a9092113d

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,28 @@
+language: ruby
+sudo: false
+
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.1
+  - jruby
+
+gemfile:
+  - gemfiles/am40.gemfile
+  - gemfiles/am41.gemfile
+  - gemfiles/am42.gemfile
+
+matrix:
+  exclude:
+    - rvm: 1.8.7
+      gemfile: gemfiles/am40.gemfile
+    - rvm: 1.8.7
+      gemfile: gemfiles/am41.gemfile
+    - rvm: 1.8.7
+      gemfile: gemfiles/am42.gemfile
+    - rvm: 1.9.2
+      gemfile: gemfiles/am40.gemfile
+    - rvm: 1.9.2
+      gemfile: gemfiles/am41.gemfile
+    - rvm: 1.9.2
+      gemfile: gemfiles/am42.gemfile

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in subroutine.gemspec
+gemspec
+
+gem 'activemodel', '~> 4.2.0'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Mike Nelson
+
+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,354 @@
+# Subroutine
+
+A gem that provides an interface for creating feature-driven operations. It loosly implements the command pattern if you're interested in nerding out a bit. See the examples below, it'll be more clear.
+
+## Examples
+
+So you need to sign up a user? or maybe update one's account? or change a password? or maybe you need to sign up a business along with a user, associate them, send an email, and queue a worker in a single request? Not a problem, create an op for any of these use cases. Here's the signup example.
+
+```ruby
+class SignupOp < ::Subroutine::Op
+
+  field :name
+  field :email
+  field :password
+
+  validates :name, presence: true
+  validates :email, presence: true
+  validates :password, presence: true
+
+  attr_reader :signed_up_user
+
+  protected
+
+  def perform
+    u = build_user
+    u.save!
+
+    deliver_welcome_email!(u)
+
+    @signed_up_user = u
+    true
+  end
+
+  def build_user
+    User.new(filtered_params)
+  end
+
+  def deliver_welcome_email!(u)
+    UserMailer.welcome(u.id).deliver_later
+  end
+end
+```
+
+So why is this needed?
+
+1. No insane cluttering of controllers with strong parameters, etc.
+2. No insane cluttering of models with validations, callbacks, and random methods that don't relate to integrity or access of model data.
+3. Insanely testable.
+4. Insanely easy to read and maintain.
+5. Multi-model operations become insanely easy.
+6. Your sanity.
+
+### Connecting it all
+
+```txt
+app/
+  |
+  |- controllers/
+  |  |- users_controller.rb
+  |
+  |- models/
+  |  |- user.rb
+  |
+  |- ops/
+     |- signup_op.rb
+
+```
+
+#### Route
+```ruby
+  resources :users, only: [] do
+    collection do
+      post :signup
+    end
+  end
+```
+
+#### Model
+```ruby
+# When ops are around, the point of the model is to ensure the data entering the db is 100% valid.
+# So most of your models are a series of validations and common accessors, queries, etc.
+class User
+  validates :name, presence: true
+  validates :email, email: true
+
+  has_secure_password
+end
+```
+
+#### Controller(s)
+```ruby
+# I've found that a great way to handle errors with ops is to allow you top level controller to appropriately
+# render errors in a consisent way. This is exceptionally easy for api-driven apps.
+class Api::Controller < ApplicationController
+  rescue_from ::Subroutine::Failure, with: :render_op_failure
+
+  def render_op_failure(e)
+    # however you want to do this, `e` will be similar to an ActiveRecord::RecordInvalid error
+    # e.record.errors, etc
+  end
+end
+
+# With ops, your controllers are essentially just connections between routes, operations, and templates.
+class UsersController < ::Api::Controller
+  def sign_up
+    # If the op fails, a ::Subroutine::Failure will be raised.
+    op = SignupOp.submit!(params)
+
+    # If the op succeeds, it will be returned so you can access it's information.
+    render json: op.signed_up_user
+  end
+end
+```
+
+## Usage
+
+Both the `Subroutine::Op` class and it's instances provide `submit` and `submit!` methods with identical signatures. Here are ways to invoke an op:
+
+#### Via the class' `submit` method
+
+```ruby
+op = MyOp.submit({foo: 'bar'})
+# if the op succeeds it will be returned, otherwise it false will be returned.
+```
+
+#### Via the class' `submit!` method
+
+```ruby
+op = MyOp.submit!({foo: 'bar'})
+# if the op succeeds it will be returned, otherwise a ::Subroutine::Failure will be raised.
+```
+
+#### Via the instance's `submit` method
+
+```ruby
+op = MyOp.new({foo: 'bar'})
+val = op.submit
+# if the op succeeds, val will be true, otherwise false
+```
+
+#### Via the instance's `submit!` method
+
+```ruby
+op = MyOp.new({foo: 'bar'})
+op.submit!
+# if the op succeeds nothing will be raised, otherwise a ::Subroutine::Failure will be raised.
+```
+
+#### Fluff
+
+Ops have some fluff. Let's see if we can cover it all with one example. I'll pretend I'm using ActiveRecord:
+
+```ruby
+class ActivateOp < ::Subroutine::Op
+
+  # This will inherit all fields, error mappings, and default values from the SignupOp class.
+  # It currently does not inherit validations
+  inputs_from ::SignupOp
+
+  # This defines new inputs for this op.
+  field :invitation_token
+  field :thank_you_message
+
+  # This maps any "inherited" errors to the op's input.
+  # So if one of our objects that we inherit errors from has an email_address error, it will end up on our errors as "email".
+  error_map email_address: :email
+
+  # If you wanted default values, they can be declared a couple different ways:
+  # default thank_you_message: "Thanks so much"
+  # field thank_you_message: "Thanks so much"
+  # field :thank_you_message, default: "Thanks so much"
+
+  # If your default values need to be evaluated at runtime, simply wrap them in a proc:
+  # default thank_you_message: -> { I18n.t('thank_you') }
+
+  # Validations are declared just like any other ActiveModel
+  validates :token, presence: true
+  validate :validate_invitation_available
+
+  protected
+
+  # This is where the actual operation takes place.
+  def perform
+    user = nil
+
+    # Jump into a transaction to make sure any failure rolls back all changes.
+    ActiveRecord::Base.transaction do
+      user = create_user!
+      associate_invitation!(user)
+    end
+
+    # Set our "success" accessors.
+    @activated_user = user
+
+    # Return a truthy value to declare success.
+    true
+  end
+
+  # Use an existing op! OMG SO DRY
+  # You have access to the original inputs via original_params
+  def create_user!
+    op = ::SignupOp.submit!(original_params)
+    op.signed_up_user
+  end
+
+  # Deal with our invitation after our user is saved.
+  def associate_invitation!(user)
+    _invitation.user_id = user.id
+    _invitation.thank_you_message = defaulted_thank_you_message
+    _invitation.convert!
+  end
+
+  # Build a default value if the user didn't provide one.
+  def defaulted_thank_you_message
+    # You can check to see if a specific field was provided via field_provided?()
+    return thank_you_message if field_provided?(:thank_you_message)
+    thank_you_message.presence || I18n.t('thanks')
+  end
+
+  # Fetch the invitation via the provided token.
+  def _invitation
+    return @_invitation if defined?(@_invitation)
+    @_invitation = token ? ::Invitation.find_by(token: token) : nil
+  end
+
+  # Verbosely validate the existence of the invitation.
+  # In most cases, these validations can be written simpler.
+  # The true/false return value is a style I like but not required.
+  def validate_invitation_available
+
+    # The other validation has already added a message for a blank token.
+    return true if token.blank?
+
+    # Ensure we found an invitation matching the token.
+    # We could have used find_by!() in `_invitation` as well.
+    unless _invitation.present?
+      errors.add(:token, :not_found)
+      return false
+    end
+
+    # Ensure the token is valid.
+    unless _invitation.can_be_converted?
+      errors.add(:token, :not_convertable)
+      return false
+    end
+
+    true
+  end
+
+end
+```
+
+### Extending Subroutine::Op
+
+Great, so you're sold on using ops. Let's talk about how I usually standardize their usage in my apps. The most common thing needed is `current_user`. For this reason I usually follow the rails convention of declaring an "Application" op which declares all of my common needs. I hate writing `ApplicationOp` all the time so I usually call it `BaseOp`.
+
+```ruby
+class BaseOp < ::Subroutine::Op
+
+  attr_reader :current_user
+
+  def initialize(*args)
+    params = args.extract_options!
+    @current_user = args[0]
+    super(params)
+  end
+
+end
+```
+
+Great, so now I can pass the current user as my first argument to any op constructor. The next most common case is permissions. In a common role-based system things become pretty easy. I usually just add a class method which declares the minimum required role.
+
+```ruby
+class SendInvitationOp < BaseOp
+  require_role :admin
+end
+```
+
+In the case of a more complex permission system, I'll usually utilize pundit but still standardize the check as a validation.
+
+```ruby
+class BaseOp < ::Subroutine::Op
+
+  validate :validate_permissions
+
+  protected
+
+  # default implementation is to allow access.
+  def validate_permissions
+    true
+  end
+
+  def not_authorized!
+    errors.add(:current_user, :not_authorized)
+    false
+  end
+end
+
+class SendInvitationOp < BaseOp
+
+  protected
+
+  def validate_permissions
+    unless UserPolicy.new(current_user).send_invitations?
+      return not_authorized!
+    end
+
+    true
+  end
+
+end
+```
+
+Clearly there are a ton of ways this could be implemented but that should be a good jumping-off point.
+
+Performance monitoring is also important to me so I've added a few hooks to observe what's going on during an op's submission. I'm primarily using Skylight at the moment.
+
+```ruby
+class BaseOp < ::Subroutine::Op
+
+  protected
+
+  def observe_submission
+    Skylight.instrument category: 'op.submission', title: "#{self.class.name}#submit" do
+      yield
+    end
+  end
+
+  def observe_validation
+    Skylight.instrument category: 'op.validation', title: "#{self.class.name}#valid?" do
+      yield
+    end
+  end
+
+  def observe_perform
+    Skylight.instrument category: 'op.perform', title: "#{self.class.name}#perform" do
+      yield
+    end
+  end
+end
+```
+
+## Todo
+
+1. Enable ActiveModel 3.0-3.2 users by removing the ActiveModel::Model dependency.
+2. Demo app?
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/subroutine/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = "test/**/*_test.rb"
+end
+
+task :default => [:test]
+

data/gemfiles/am30.gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec :path => '../'
+
+gem 'activemodel', '~> 3.0.20'

data/gemfiles/am31.gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec :path => '../'
+
+gem 'activemodel', '~> 3.1.12'

data/gemfiles/am32.gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec :path => '../'
+
+gem 'activemodel', '~> 3.2.21'

data/gemfiles/am40.gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec :path => '../'
+
+gem 'activemodel', '~> 4.0.13'

data/gemfiles/am41.gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec :path => '../'
+
+gem 'activemodel', '~> 4.1.9'

data/gemfiles/am42.gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec :path => '../'
+
+gem 'activemodel', '~> 4.2.0'

data/lib/subroutine/version.rb

@@ -0,0 +1,10 @@
+module Subroutine
+
+  MAJOR = 0
+  MINOR = 0
+  PATCH = 1
+  PRE   = nil
+
+  VERSION = [MAJOR, MINOR, PATCH, PRE].compact.join('.')
+
+end

data/lib/subroutine.rb

@@ -0,0 +1,243 @@
+require "subroutine/version"
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_model'
+
+module Subroutine
+
+  class Failure < StandardError
+    attr_reader :record
+    def initialize(record)
+      @record = record
+      errors = @record.errors.full_messages.join(", ")
+      super(errors)
+    end
+  end
+
+  class Op
+
+    include ::ActiveModel::Model
+    include ::ActiveModel::Validations::Callbacks
+
+    class << self
+
+      # fields can be provided in the following way:
+      # field :field1, :field2
+      # field :field3, :field4, default: 'my default'
+      # field field5: 'field5 default', field6: 'field6 default'
+      def field(*fields)
+        last_hash = fields.extract_options!
+        options   = last_hash.slice(:default, :scope)
+
+        fields << last_hash.except(:default, :scope)
+
+        fields.each do |f|
+
+          if f.is_a?(Hash)
+            f.each do |k,v|
+              field(k, options.merge(:default => v))
+            end
+          else
+
+            _field(f, options)
+          end
+        end
+
+      end
+      alias_method :fields, :field
+
+
+      def inputs_from(*ops)
+        ops.each do |op|
+          field(*op._fields)
+          defaults(op._defaults)
+          error_map(op._error_map)
+        end
+      end
+
+
+      def default(pairs)
+        self._defaults.merge!(pairs.stringify_keys)
+      end
+      alias_method :defaults, :default
+
+
+      def error_map(map)
+        self._error_map.merge!(map)
+      end
+      alias_method :error_maps, :error_map
+
+
+      def inherited(child)
+        super
+
+        child._fields     = []
+        child._defaults   = {}
+        child._error_map  = {}
+
+        child._fields      |= self._fields
+        child._defaults.merge!(self._defaults)
+        child._error_map.merge!(self._error_map)
+      end
+
+
+      def submit!(*args)
+        op = new(*args)
+        op.submit!
+
+        op
+      end
+
+      def submit(*args)
+        op = new(*args)
+        op.submit
+        op
+      end
+
+      protected
+
+      def _field(field_name, options = {})
+        field = [options[:scope], field_name].compact.join('_')
+        self._fields += [field]
+
+        attr_accessor field
+
+        default(field => options[:default]) if options[:default]
+      end
+
+    end
+
+
+    class_attribute :_fields
+    self._fields = []
+    class_attribute :_defaults
+    self._defaults = {}
+    class_attribute :_error_map
+    self._error_map = {}
+
+    attr_reader :original_params
+    attr_reader :params
+
+
+    def initialize(inputs = {})
+      @original_params  = inputs.with_indifferent_access
+      @params           = {}
+
+      self.class._defaults.each do |k,v|
+        self.send("#{k}=", v.respond_to?(:call) ? v.call : v)
+      end
+    end
+
+
+    def submit!
+      unless submit
+        raise ::Subroutine::Failure.new(self)
+      end
+      true
+    end
+
+    # the action which should be invoked upon form submission (from the controller)
+    def submit
+      observe_submission do
+        @params = filter_params(@original_params)
+
+        set_accessors(@params)
+
+        validate_and_perform
+      end
+
+    rescue Exception => e
+      if e.respond_to?(:record)
+        inherit_errors_from(e.record) unless e.record == self
+        false
+      else
+        raise e
+      end
+    end
+
+    protected
+
+    # these enable you to 1) add log output or 2) add performance monitoring such as skylight.
+    def observe_submission
+      yield
+    end
+
+    def observe_validation
+      yield
+    end
+
+    def observe_perform
+      yield
+    end
+
+
+    def validate_and_perform
+      bool = observe_validation do
+        valid?
+      end
+      return false unless bool
+
+      observe_perform do
+        perform
+      end
+    end
+
+    # implement this in your concrete class.
+    def perform
+      raise NotImplementedError
+    end
+
+    def field_provided?(key)
+      @params.has_key?(key)
+    end
+
+
+    # applies the errors to the form object from the child object, optionally at the namespace provided
+    def inherit_errors_from(object, namespace = nil)
+      inherit_errors(object.errors, namespace)
+    end
+
+
+    # applies the errors in error_object to self, optionally at the namespace provided
+    # returns false so failure cases can end with this invocation
+    def inherit_errors(error_object, namespace = nil)
+      error_object.each do |k,v|
+
+        keys  = [k, [namespace, k].compact.join('_')].map(&:to_sym).uniq
+        keys  = keys.map{|key| _error_map[key] || key }
+
+        match = keys.detect{|key| self.respond_to?(key) || @original_params.try(:has_key?, key) }
+
+        if match
+          errors.add(match, v)
+        else
+          errors.add(:base, error_object.full_message(k, v))
+        end
+
+      end
+
+      false
+    end
+
+
+    # if you want to use strong parameters or something in your form object you can do so here.
+    def filter_params(inputs)
+      inputs.slice(*_fields)
+    end
+
+
+    def set_accessors(inputs, namespace = nil)
+      inputs.each do |key, value|
+
+        setter = [namespace, key].compact.join('_')
+
+        if respond_to?("#{setter}=") && _fields.include?(setter)
+          send("#{setter}=", value)
+        elsif value.is_a?(Hash)
+          set_accessors(value, setter)
+        end
+      end
+    end
+
+  end
+
+end

data/subroutine.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'subroutine/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "subroutine"
+  spec.version       = Subroutine::VERSION
+  spec.authors       = ["Mike Nelson"]
+  spec.email         = ["mike@mnelson.io"]
+  spec.summary       = %q{Feature-driven operation objects.}
+  spec.description   = %q{An interface for creating feature-driven operations.}
+  spec.homepage      = "https://github.com/mnelson/subroutine"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(gemfiles|test)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activemodel", ">= 4.0.0"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "minitest-reporters"
+end

data/test/subroutine/base_test.rb

@@ -0,0 +1,149 @@
+require 'test_helper'
+
+module Subroutine
+  class OpTest < TestCase
+
+    def test_simple_fields_definition
+      op = ::SignupOp.new
+      assert_equal ['email', 'password'], op._fields
+    end
+
+    def test_inherited_fields
+      op = ::AdminSignupOp.new
+      assert_equal ['email', 'password', 'priveleges'], op._fields
+    end
+
+    def test_class_attribute_usage
+      assert ::AdminSignupOp < ::SignupOp
+
+      sid = ::SignupOp._fields.object_id
+      bid = ::AdminSignupOp._fields.object_id
+
+      refute_equal sid, bid
+
+      sid = ::SignupOp._defaults.object_id
+      bid = ::AdminSignupOp._defaults.object_id
+
+      refute_equal sid, bid
+
+      sid = ::SignupOp._error_map.object_id
+      bid = ::AdminSignupOp._error_map.object_id
+
+      refute_equal sid, bid
+
+    end
+
+    def test_inputs_from_inherited_fields_without_inheriting_from_the_class
+      refute ::BusinessSignupOp < ::SignupOp
+
+      ::SignupOp._fields.each do |field|
+        assert_includes ::BusinessSignupOp._fields, field
+      end
+
+      ::SignupOp._defaults.each_pair do |k,v|
+        assert_equal v, ::BusinessSignupOp._defaults[k]
+      end
+
+      ::SignupOp._error_map.each_pair do |k,v|
+        assert_equal v, ::BusinessSignupOp._error_map[k]
+      end
+    end
+
+    def test_defaults_declaration_options
+      assert_equal ::DefaultsOp._defaults, {
+        'foo' => 'foo',
+        'baz' => 'baz',
+        'bar' => 'bar'
+      }
+    end
+
+    def test_inherited_defaults_override_correctly
+      assert_equal 'barstool', ::InheritedDefaultsOp._defaults['bar']
+    end
+
+    def test_accessors_are_created
+      op = ::SignupOp.new
+
+      assert_respond_to op, :email
+      assert_respond_to op, :email=
+
+      assert_respond_to op, :password
+      assert_respond_to op, :password=
+
+      refute_respond_to ::SignupOp, :email
+      refute_respond_to ::SignupOp, :email=
+      refute_respond_to ::SignupOp, :password
+      refute_respond_to ::SignupOp, :password=
+    end
+
+    def test_defaults_are_applied_to_new_instances
+      op = ::SignupOp.new
+
+      assert_nil op.email
+      assert_nil op.password
+
+      op = ::AdminSignupOp.new
+
+      assert_nil op.email
+      assert_nil op.password
+      assert_equal 'min', op.priveleges
+    end
+
+    def test_validations_are_evaluated_before_perform_is_invoked
+      op = ::SignupOp.new
+
+      refute op.submit
+
+      refute op.perform_called
+
+      assert_equal ["can't be blank"], op.errors[:email]
+    end
+
+    def test_validation_errors_can_be_inherited_and_transformed
+      op = ::AdminSignupOp.new(:email => 'foo@bar.com', :password => 'password123')
+
+      refute op.submit
+
+      assert op.perform_called
+      refute op.perform_finished
+
+      assert_equal ["has gotta be @admin.com"], op.errors[:email]
+    end
+
+    def test_when_valid_perform_completes_it_returns_control
+      op = ::SignupOp.new(:email => 'foo@bar.com', :password => 'password123')
+      op.submit!
+
+      assert op.perform_called
+      assert op.perform_finished
+
+      u = op.created_user
+
+      assert_equal 'foo@bar.com', u.email_address
+    end
+
+    def test_it_raises_an_error_when_used_with_a_bang_and_performing_or_validation_fails
+      op = ::SignupOp.new(:email => 'foo@bar.com')
+
+      err = assert_raises ::Subroutine::Failure do
+        op.submit!
+      end
+
+      assert_equal "Password can't be blank", err.message
+    end
+
+    def test_it_allows_submission_from_the_class
+      op = SignupOp.submit
+      assert_equal ["can't be blank"], op.errors[:email]
+
+      assert_raises ::Subroutine::Failure do
+        SignupOp.submit!
+      end
+
+      op = SignupOp.submit! :email => 'foo@bar.com', :password => 'password123'
+      assert_equal 'foo@bar.com', op.created_user.email_address
+
+    end
+
+  end
+end

data/test/support/ops.rb

@@ -0,0 +1,97 @@
+## Models ##
+
+class User
+  include ::ActiveModel::Model
+
+  attr_accessor :email_address
+  attr_accessor :password
+
+  validates :email_address, :presence => true
+end
+
+class AdminUser < ::User
+  validates :email_address, :format => {:with => /@admin\.com/, :message => 'has gotta be @admin.com'}
+end
+
+
+## Ops ##
+
+class SignupOp < ::Subroutine::Op
+
+  field :email
+  field :password
+
+  validates :email, :presence => true
+  validates :password, :presence => true
+
+  error_map :email_address => :email
+
+  attr_reader :perform_called
+  attr_reader :perform_finished
+
+  attr_reader :created_user
+
+  protected
+
+  def perform
+    @perform_called = true
+    u = build_user
+
+    unless u.valid?
+      inherit_errors_from(u)
+      return false
+    end
+
+    @perform_finished = true
+    @created_user = u
+
+    true
+  end
+
+  def build_user
+    u = user_class.new
+    u.email_address = email
+    u.password = password
+    u
+  end
+
+  def user_class
+    ::User
+  end
+end
+
+class AdminSignupOp < ::SignupOp
+
+  field :priveleges, :default => 'min'
+
+  protected
+
+  def user_class
+    ::AdminUser
+  end
+
+end
+
+class BusinessSignupOp < ::Subroutine::Op
+
+  field :business_name
+  inputs_from ::SignupOp
+
+end
+
+class DefaultsOp < ::Subroutine::Op
+
+  field :foo, :default => 'foo'
+
+  field baz: 'baz'
+
+  field :bar
+  default :bar => 'bar'
+
+end
+
+class InheritedDefaultsOp < ::DefaultsOp
+
+  default :bar => 'barstool'
+
+end

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+require 'subroutine'
+require 'minitest/autorun'
+require 'minitest/unit'
+
+require 'minitest/reporters'
+
+Minitest::Reporters.use!([Minitest::Reporters::DefaultReporter.new])
+
+class TestCase < (MiniTest::Unit::TestCase rescue ::MiniTest::Test); end
+
+require_relative 'support/ops'
+
+

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: subroutine
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Mike Nelson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An interface for creating feature-driven operations.
+email:
+- mike@mnelson.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- gemfiles/am30.gemfile
+- gemfiles/am31.gemfile
+- gemfiles/am32.gemfile
+- gemfiles/am40.gemfile
+- gemfiles/am41.gemfile
+- gemfiles/am42.gemfile
+- lib/subroutine.rb
+- lib/subroutine/version.rb
+- subroutine.gemspec
+- test/subroutine/base_test.rb
+- test/support/ops.rb
+- test/test_helper.rb
+homepage: https://github.com/mnelson/subroutine
+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.4.6
+signing_key: 
+specification_version: 4
+summary: Feature-driven operation objects.
+test_files:
+- gemfiles/am30.gemfile
+- gemfiles/am31.gemfile
+- gemfiles/am32.gemfile
+- gemfiles/am40.gemfile
+- gemfiles/am41.gemfile
+- gemfiles/am42.gemfile
+- test/subroutine/base_test.rb
+- test/support/ops.rb
+- test/test_helper.rb