subroutine 1.0.0.rc4 → 2.0.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6bd9cb93ba6c09a520b8db4d79b6aa2e5eefee2046b5b8d768976864dd4a7c89
-  data.tar.gz: d5d0be02650acb97a25b3663f2722ace66f38ad2cb5457208da7ad1e3a2a9e0d
+  metadata.gz: bc8eb530552fea8e2bacd033372826e11c57734d9695973ebca956c76aa2ed93
+  data.tar.gz: 908764a3fc127881b4c719c2c5523ae280771683e765ea8f47ddda52bed76a33
 SHA512:
-  metadata.gz: f4eaa685e8fff642d134ba9f97b0050c1eee01639b4429ebe2d4a522ff88de544f58a4080372af3f91f210f656efbf9c37c8a6fbdea1f36468067408e5615913
-  data.tar.gz: e6b4c7fbadbaf6a1b8b8d765d962aed0acb7ba8c8f661b5b5c70da6b20d49458013d0f31ab34e0c4a7519452a568f8f9e51ee85f18be0a119ba62af1e24b1d94
+  metadata.gz: 4de2ad64fede40a510afe5b0af073eb6fae1800a61e2f9387337c1d46475ec439c1c35cb393ecececb3a5954b7c9e1b32be10e6be963dc7ce3fb840d40a3b368
+  data.tar.gz: 9ec24f1a6ce47edb502bded197096dec4d1ff444c4d3b0fda64291111aa7a29e67e7bd4f8e01a018c72795117c40e16fa3c68131b64db346e3c1073611c8134e

data/.ruby-version

@@ -1 +1 @@
-2.5.1
+2.5.7

data/CHANGELOG.MD

@@ -0,0 +1,111 @@
+## Subroutine 1.0
+
+A massive refactor took place between 0.9 and 1.0, including breaking changes. The goal was to reduce complexity, simplify backtraces, and increase the overall safety and reliability of the library.
+
+### Subroutine::Fields
+
+`Subroutine::Fields` was completely refactored to manage field declaration, configuration, and access in a more systematic and safer way.
+
+`Op._fields` was removed in favor of `Op.field_configurations`. `field_configurations` is a hash with keys of the field name and values of `FieldConfiguration` objects. FieldConfiguration objects are SimpleDelegates to the underlying option hashes. They answer questions and provide a mechanism for validating the configuration of a field.
+
+Fields can be accessed via helpers and accessors can be managed by the field declration. Helpers include `get_field`, `set_field`, and `clear_field`.
+
+```ruby
+class SomeOp < ::Subroutine::Op
+  string :foo, read_accessor: field_reader: false, field_writer: true
+
+  def perform
+    self.foo = "bar"
+    self.foo # NoMethodError
+    self.get_field(:foo) # => "bar"
+  end
+end
+```
+
+Fields can be omitted from mass assignment, meaning they would not be respected via constructor signatures.
+
+```ruby
+class SomeOp < ::Subroutine::Op
+  string :foo, mass_assignable: false
+  def perform
+    puts foo
+  end
+end
+
+SomeOp.submit!(foo: "Hello World!") # raises ::Subroutine::Fields::MassAssignmentError
+SomeOp.new{|op| op.foo = "Hello World!" }.submit! # prints "Hello World!"
+```
+
+This is especially useful when dealing with user input and potentially unsafe attributes.
+
+```ruby
+class UserUpdateOp < ::Op
+  association :user
+  string :first_name
+  string :last_name
+  integer :credit_balance_cents, mass_assignable: false
+
+  def perform
+    user.update(params)
+  end
+end
+
+# some_controller.rb
+def update
+  UserUpdateOp.submit!(params.merge(user: current_user))
+end
+```
+
+Field groups were added as well, allowing you to access subsets of the fields easily.
+
+```ruby
+class AccountUpdateOp < ::Op
+  association :account
+
+  with_options group: :user do
+    string :first_name
+    string :last_name
+    date :dob
+  end
+
+  with_options group: :business do
+    string :company_name
+    string :ein
+  end
+
+  def perform
+    account.user.update(user_params)
+    account.business.update(business_params)
+  end
+
+end
+```
+
+ActionController::Parameters from Rails 5+ are now transformed to a hash in `Subroutine::Fields` by default. This means strong parameters are essentially unused when passing `Subroutine::Fields`.
+
+Read more about field management and access in https://github.com/guideline-tech/subroutine/wiki/Param-Usage
+
+### Subroutine::Association
+
+The `Subroutine::Association` module has been moved to `Subroutine::AssociationFields`.
+
+Only native types are stored in params now. The objects loaded from associations are stored in an `association_cache`. This ensures access to fields are consistent regardless of the inputs.
+
+```ruby
+class SomeOp < ::Subroutine::Op
+  association :user
+  association :resource, polymorphic: true
+end
+
+user = User.find(4)
+
+op = SomeOp.new(user: user, resource: user)
+op.params #=> { user_id: 4, resource_type: "User", resource_id: 4 }
+op.params_with_association #=> { user: <User:103204 @id=4>, resource: <User:103204 @id=4> }
+
+op = SomeOp.new(user_id: user.id, resource_type: "User", resource_id: user.id)
+op.params #=> { user_id: 4, resource_type: "User", resource_id: 4 }
+op.params_with_association #=> { user: <User:290053 @id=4>, resource: <User:29042 @id=4> }
+```
+
+Assignment of associations now validates the type. If an association is not polymorphic, the type will be validated against the expected type.

data/Gemfile

@@ -5,4 +5,4 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in subroutine.gemspec
 gemspec
 
-gem "activemodel", "~> 4.2.11"
+eval_gemfile "gemfiles/am60.gemfile"

data/README.md

@@ -13,26 +13,37 @@ class SignupOp < ::Subroutine::Op
   string :email
   string :password
 
+  string :company_name
+
   validates :name, presence: true
   validates :email, presence: true
   validates :password, presence: true
+  validates :company_name, presence: true
 
-  outputs :signed_up_user
+  outputs :user
+  outputs :business
 
   protected
 
   def perform
     u = create_user!
-    deliver_welcome_email!(u)
+    b = create_business!(u)
+
+    deliver_welcome_email(u)
 
-    output :signed_up_user, u
+    output :user, u
+    output :business, b
   end
 
   def create_user!
-    User.create!(params)
+    User.create!(name: name, email: email, password: password)
   end
 
-  def deliver_welcome_email!(u)
+  def create_business!(owner)
+    Business.create!(company_name: company_name, owner: owner)
+   end
+
+  def deliver_welcome_email(u)
     UserMailer.welcome(u.id).deliver_later
   end
 end
@@ -45,7 +56,9 @@ end
 - Clear and concise intention in a single file
 - Multi-model operations become simple
 
-[Implementing an Op](https://github.com/guideline-tech/subroutine/wiki/Implementing-an-Op)
-[Using an Op](https://github.com/guideline-tech/subroutine/wiki/Using-an-Op)
-[Errors](https://github.com/guideline-tech/subroutine/wiki/Errors)
-[Basic Usage in Rails](https://github.com/guideline-tech/subroutine/wiki/Rails-Usage)
+## Continue Reading
+
+- [Implementing an Op](https://github.com/guideline-tech/subroutine/wiki/Implementing-an-Op)
+- [Using an Op](https://github.com/guideline-tech/subroutine/wiki/Using-an-Op)
+- [Errors](https://github.com/guideline-tech/subroutine/wiki/Errors)
+- [Basic Usage in Rails](https://github.com/guideline-tech/subroutine/wiki/Rails-Usage)

data/gemfiles/am41.gemfile

@@ -2,4 +2,6 @@ source 'https://rubygems.org'
 
 gemspec :path => '../'
 
-gem 'activemodel', '~> 4.1.9'
+gem 'rack'
+gem 'activemodel', '~> 4.1.0'
+gem 'actionpack', '~> 4.1.0'

data/gemfiles/am42.gemfile

@@ -2,4 +2,6 @@ source 'https://rubygems.org'
 
 gemspec :path => '../'
 
+gem 'rack'
 gem 'activemodel', '~> 4.2.0'
+gem 'actionpack', '~> 4.2.0'

data/gemfiles/am50.gemfile

@@ -2,4 +2,5 @@ source 'https://rubygems.org'
 
 gemspec :path => '../'
 
-gem 'activemodel', '~> 5.0.7.2'
+gem 'activemodel', '~> 5.0.0'
+gem 'actionpack', '~> 5.0.0'

data/gemfiles/am51.gemfile

@@ -2,4 +2,5 @@ source 'https://rubygems.org'
 
 gemspec :path => '../'
 
-gem 'activemodel', '~> 5.1.7'
+gem 'activemodel', '~> 5.1.0'
+gem 'actionpack', '~> 5.1.0'

data/gemfiles/am52.gemfile

@@ -2,4 +2,5 @@ source 'https://rubygems.org'
 
 gemspec :path => '../'
 
-gem 'activemodel', '~> 5.2.3'
+gem 'activemodel', '~> 5.2.0'
+gem 'actionpack', '~> 5.2.0'

data/gemfiles/am60.gemfile

@@ -2,4 +2,5 @@ source 'https://rubygems.org'
 
 gemspec :path => '../'
 
-gem 'activemodel', '~> 6.0.0.rc1'
+gem 'activemodel', '~> 6.0.0'
+gem 'actionpack', '~> 6.0.0'

data/lib/subroutine/association_fields/configuration.rb

@@ -10,7 +10,7 @@ module Subroutine
       def validate!
         super
 
-        if as && foreign_key
+        if config[:as] && foreign_key
           raise ArgumentError, ":as and :foreign_key options should not be provided together to an association invocation"
         end
       end
@@ -19,6 +19,13 @@ module Subroutine
         super + [::Subroutine::AssociationFields]
       end
 
+      def related_field_names
+        out = super
+        out << foreign_key_method
+        out << foreign_type_method if polymorphic?
+        out
+      end
+
       def polymorphic?
         !!config[:polymorphic]
       end
@@ -27,12 +34,13 @@ module Subroutine
         config[:as] || field_name
       end
 
-      def class_name
-        config[:class_name]&.to_s
+      def foreign_type
+        (config[:foreign_type] || config[:class_name])&.to_s
       end
+      alias class_name foreign_type
 
-      def inferred_class_name
-        class_name || as.to_s.camelize
+      def inferred_foreign_type
+        foreign_type || as.to_s.camelize
       end
 
       def foreign_key
@@ -40,15 +48,19 @@ module Subroutine
       end
 
       def foreign_key_method
-        foreign_key || "#{field_name}_id"
+        (foreign_key || "#{field_name}_id").to_sym
       end
 
       def foreign_type_method
-        foreign_key_method.gsub(/_id$/, "_type")
+        foreign_key_method.to_s.gsub(/_id$/, "_type").to_sym
+      end
+
+      def find_by
+        (config[:find_by] || :id).to_sym
       end
 
       def build_foreign_key_field
-        build_child_field(foreign_key_method, type: :integer)
+        build_child_field(foreign_key_method, type: :foreign_key, foreign_key_type: config[:foreign_key_type])
       end
 
       def build_foreign_type_field
@@ -66,7 +78,10 @@ module Subroutine
       protected
 
       def build_child_field(name, opts = {})
-        ComponentConfiguration.new(name, inheritable_options.merge(opts).merge(association_name: as))
+        child_opts = inheritable_options
+        child_opts.merge!(opts)
+        child_opts[:association_name] = as
+        ComponentConfiguration.new(name, child_opts)
       end
 
     end

data/lib/subroutine/association_fields.rb

@@ -74,7 +74,7 @@ module Subroutine
             class_eval <<-EV, __FILE__, __LINE__ + 1
               try(:silence_redefinition_of_method, :#{config.foreign_type_method})
               def #{config.foreign_type_method}
-                #{config.inferred_class_name.inspect}
+                #{config.inferred_foreign_type.inspect}
               end
             EV
           end
@@ -100,8 +100,7 @@ module Subroutine
 
       excepts = []
       association_fields.each_pair do |_name, config|
-        excepts << config.foreign_key_method
-        excepts << config.foreign_type_method if config.polymorphic?
+        excepts |= config.related_field_names
       end
 
       out = params.except(*excepts)
@@ -120,7 +119,7 @@ module Subroutine
       if config&.behavior == :association
         maybe_raise_on_association_type_mismatch!(config, value)
         set_field(config.foreign_type_method, value&.class&.name, opts) if config.polymorphic?
-        set_field(config.foreign_key_method, value&.id, opts)
+        set_field(config.foreign_key_method, value&.send(config.find_by), opts)
         association_cache[config.field_name] = value
       else
         if config&.behavior == :association_component
@@ -138,10 +137,7 @@ module Subroutine
         stored_result = association_cache[config.field_name]
         return stored_result unless stored_result.nil?
 
-        fk = config.field_reader? ? send(config.foreign_key_method) : get_field(config.foreign_id_method)
-        type = config.field_reader? || !config.polymorphic? ? send(config.foreign_type_method) : get_field(config.foreign_type_method)
-
-        result = fetch_association_instance(type, fk, config.unscoped?)
+        result = fetch_association_instance(config)
         association_cache[config.field_name] = result
       else
         get_field_without_association(field_name)
@@ -176,25 +172,32 @@ module Subroutine
       end
     end
 
-    def fetch_association_instance(_type, _fk, _unscoped = false)
-      return nil unless _type && _fk
+    def fetch_association_instance(config)
+      klass =
+        if config.field_reader?
+          config.polymorphic? ? send(config.foreign_type_method) : config.inferred_foreign_type
+        else
+          get_field(config.foreign_type_method)
+        end
 
-      klass = _type
       klass = klass.classify.constantize if klass.is_a?(String)
-
       return nil unless klass
 
+      foreign_key = config.foreign_key_method
+      value = send(foreign_key)
+      return nil unless value
+
       scope = klass.all
-      scope = scope.unscoped if _unscoped
+      scope = scope.unscoped if config.unscoped?
 
-      scope.find(_fk)
+      scope.find_by!(config.find_by => value)
     end
 
     def maybe_raise_on_association_type_mismatch!(config, record)
       return if config.polymorphic?
       return if record.nil?
 
-      klass = config.inferred_class_name.constantize
+      klass = config.inferred_foreign_type.constantize
 
       return if record.class <= klass || record.class >= klass
 

data/lib/subroutine/auth.rb

@@ -85,17 +85,24 @@ module Subroutine
     def initialize(*args, &block)
       raise Subroutine::Auth::AuthorizationNotDeclaredError unless self.class.authorization_declared
 
-      super(args.extract_options!, &block)
-
       @skip_auth_checks = false
 
+      inputs = case args.last
+      when *::Subroutine::Fields.allowed_input_classes
+        args.pop
+      else
+        {}
+      end
+
+      super(inputs, &block)
+
       user = args.shift
 
-      if self.class.supported_user_class_names.include?(user.class.name)
-        @current_user = user
-      else
+      unless self.class.supported_user_class_names.include?(user.class.name)
         raise ArgumentError, "current_user must be one of the following types {#{self.class.supported_user_class_names.join(",")}} but was #{user.class.name}"
       end
+
+      @current_user = user
     end
 
     def skip_auth_checks!

data/lib/subroutine/fields/configuration.rb

@@ -7,7 +7,7 @@ module Subroutine
     class Configuration < ::SimpleDelegator
 
       PROTECTED_GROUP_IDENTIFIERS = %i[all original default].freeze
-      INHERITABLE_OPTIONS = %i[mass_assignable field_reader field_writer groups].freeze
+      INHERITABLE_OPTIONS = %i[mass_assignable field_reader field_writer groups aka].freeze
       NO_GROUPS = [].freeze
 
       def self.from(field_name, options)
@@ -22,7 +22,7 @@ module Subroutine
       attr_reader :field_name
 
       def initialize(field_name, options)
-        @field_name = field_name
+        @field_name = field_name.to_sym
         config = sanitize_options(options)
         super(config)
         validate!
@@ -38,6 +38,10 @@ module Subroutine
         []
       end
 
+      def related_field_names
+        [field_name]
+      end
+
       def behavior
         nil
       end
@@ -96,6 +100,8 @@ module Subroutine
         groups = nil if groups == false
         opts[:groups] = Array(groups).map(&:to_sym).presence
         opts.delete(:group)
+        opts[:aka] = opts[:aka].to_sym if opts[:aka]
+        opts[:name] = field_name
         opts
       end
 

data/lib/subroutine/fields.rb

@@ -14,6 +14,18 @@ module Subroutine
 
     extend ActiveSupport::Concern
 
+    def self.allowed_input_classes
+      @allowed_input_classes ||= begin
+        out = [Hash]
+        out << ActionController::Parameters if action_controller_params_loaded?
+        out
+      end
+    end
+
+    def self.action_controller_params_loaded?
+      defined?(::ActionController::Parameters)
+    end
+
     included do
       class_attribute :field_configurations
       self.field_configurations = {}
@@ -46,9 +58,12 @@ module Subroutine
         onlys = options.key?(:only) ? Array(options.delete(:only)) : nil
 
         things.each do |thing|
+          local_excepts = excepts.map { |field| thing.get_field_config(field)&.related_field_names }.flatten.compact.uniq if excepts
+          local_onlys = onlys.map { |field| thing.get_field_config(field)&.related_field_names }.flatten.compact.uniq if onlys
+
           thing.field_configurations.each_pair do |field_name, config|
-            next if excepts&.include?(field_name)
-            next if onlys && !onlys.include?(field_name)
+            next if local_excepts&.include?(field_name)
+            next if local_onlys && !local_onlys.include?(field_name)
 
             config.required_modules.each do |mod|
               include mod unless included_modules.include?(mod)
@@ -141,6 +156,9 @@ module Subroutine
     end
 
     def setup_fields(inputs = {})
+      if ::Subroutine::Fields.action_controller_params_loaded? && inputs.is_a?(::ActionController::Parameters)
+        inputs = inputs.to_unsafe_h if inputs.respond_to?(:to_unsafe_h)
+      end
       @provided_fields = {}.with_indifferent_access
       param_groups[:original] = inputs.with_indifferent_access
       mass_assign_initial_params

data/lib/subroutine/op.rb

@@ -37,28 +37,11 @@ module Subroutine
         op
       end
 
-      protected
-
-      def field(field_name, options = {})
-        result = super(field_name, options)
-
-        if options[:aka]
-          Array(options[:aka]).each do |as|
-            self._error_map = _error_map.merge(as.to_sym => field_name.to_sym)
-          end
-        end
-
-        result
-      end
-
     end
 
     class_attribute :_failure_class
     self._failure_class = Subroutine::Failure
 
-    class_attribute :_error_map
-    self._error_map = {}
-
     def initialize(inputs = {})
       setup_fields(inputs)
       setup_outputs
@@ -82,7 +65,7 @@ module Subroutine
 
       if errors.empty?
         validate_outputs!
-        true
+        self
       else
         raise _failure_class, self
       end
@@ -91,6 +74,7 @@ module Subroutine
     # the action which should be invoked upon form submission (from the controller)
     def submit
       submit!
+      true
     rescue Exception => e
       if e.respond_to?(:record)
         inherit_errors(e.record) unless e.record == self
@@ -127,18 +111,23 @@ module Subroutine
       raise NotImplementedError
     end
 
-    # applies the errors in error_object to self
-    # returns false so failure cases can end with this invocation
-    def inherit_errors(error_object)
+    def inherit_errors(error_object, prefix: nil)
       error_object = error_object.errors if error_object.respond_to?(:errors)
 
-      error_object.each do |k, v|
-        if respond_to?(k)
-          errors.add(k, v)
-        elsif _error_map[k.to_sym]
-          errors.add(_error_map[k.to_sym], v)
+      error_object.each do |field_name, error|
+        field_name = "#{prefix}#{field_name}" if prefix
+        field_name = field_name.to_sym
+
+        field_config = get_field_config(field_name)
+        field_config ||= begin
+          kv = field_configurations.find { |_k, config| config[:aka] == field_name }
+          kv ? kv.last : nil
+        end
+
+        if field_config
+          errors.add(field_config.field_name, error)
         else
-          errors.add(:base, error_object.full_message(k, v))
+          errors.add(:base, error_object.full_message(field_name, error))
         end
       end
 

data/lib/subroutine/type_caster.rb

@@ -63,6 +63,15 @@ end
   String(value)
 end
 
+::Subroutine::TypeCaster.register :foreign_key do |value, options = {}|
+  next nil if value.blank?
+
+  next ::Subroutine::TypeCaster.cast(value, type: options[:foreign_key_type]) if options[:foreign_key_type]
+  next ::Subroutine::TypeCaster.cast(value, type: :integer) if options[:name] && options[:name].to_s.end_with?("_id")
+
+  value
+end
+
 ::Subroutine::TypeCaster.register :boolean, :bool do |value, _options = {}|
   !!(String(value) =~ /^(yes|true|1|ok)$/)
 end

data/lib/subroutine/version.rb

@@ -2,10 +2,10 @@
 
 module Subroutine
 
-  MAJOR = 1
+  MAJOR = 2
   MINOR = 0
   PATCH = 0
-  PRE   = "rc4"
+  PRE   = "beta2"
 
   VERSION = [MAJOR, MINOR, PATCH, PRE].compact.join(".")
 

data/subroutine.gemspec

@@ -1,15 +1,16 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'subroutine/version'
+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.summary       = "Feature-driven operation objects."
+  spec.description   = "An interface for creating feature-driven operations."
   spec.homepage      = "https://github.com/mnelson/subroutine"
   spec.license       = "MIT"
 
@@ -19,12 +20,14 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "activemodel", ">= 4.0.0"
+  spec.add_dependency "activesupport", ">= 4.0.0"
 
+  spec.add_development_dependency "actionpack", ">= 4.0"
   spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake"
+  spec.add_development_dependency "byebug"
   spec.add_development_dependency "m"
   spec.add_development_dependency "minitest"
   spec.add_development_dependency "minitest-reporters"
   spec.add_development_dependency "mocha"
-  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "rake"
 end

data/test/subroutine/association_test.rb

@@ -23,11 +23,21 @@ module Subroutine
       assert_equal doug.id, op.user_id
     end
 
+    def test_it_can_be_nil
+      op = SimpleAssociationOp.new user: nil
+      assert_nil op.user
+      assert_nil op.user_id
+
+      op = SimpleAssociationOp.new
+      assert_nil op.user
+      assert_nil op.user_id
+    end
+
     def test_it_looks_up_an_association
       all_mock = mock
 
       ::User.expects(:all).returns(all_mock)
-      all_mock.expects(:find).with(1).returns(doug)
+      all_mock.expects(:find_by!).with(id: 1).returns(doug)
 
       op = SimpleAssociationOp.new user_type: "User", user_id: doug.id
       assert_equal doug, op.user
@@ -37,7 +47,7 @@ module Subroutine
       all_mock = mock
 
       ::User.expects(:all).returns(all_mock)
-      all_mock.expects(:find).with(1).returns(doug)
+      all_mock.expects(:find_by!).with(id: 1).returns(doug)
 
       op = SimpleAssociationOp.new user_id: doug.id
       assert_equal doug, op.user
@@ -49,7 +59,7 @@ module Subroutine
 
       ::User.expects(:all).returns(all_mock)
       all_mock.expects(:unscoped).returns(unscoped_mock)
-      unscoped_mock.expects(:find).with(1).returns(doug)
+      unscoped_mock.expects(:find_by!).with(id: 1).returns(doug)
 
       op = UnscopedSimpleAssociationOp.new user_id: doug.id
       assert_equal doug, op.user
@@ -59,7 +69,7 @@ module Subroutine
       all_mock = mock
       ::User.expects(:all).never
       ::AdminUser.expects(:all).returns(all_mock)
-      all_mock.expects(:find).with(1).returns(doug)
+      all_mock.expects(:find_by!).with(id: 1).returns(doug)
 
       op = PolymorphicAssociationOp.new(admin_type: "AdminUser", admin_id: doug.id)
       assert_equal doug, op.admin
@@ -70,11 +80,72 @@ module Subroutine
       assert_equal "AdminUser", op.admin_type
     end
 
+    def test_it_allows_foreign_key_to_be_set
+      all_mock = mock
+      ::User.expects(:all).returns(all_mock)
+      all_mock.expects(:find_by!).with(id: 10).returns(doug)
+
+      op = ::AssociationWithForeignKeyOp.new(owner_id: 10)
+      assert_equal doug, op.user
+      assert_equal "owner_id", op.field_configurations[:user][:foreign_key]
+    end
+
+    def test_the_foreign_key_is_cast
+      all_mock = mock
+      ::User.expects(:all).returns(all_mock)
+      all_mock.expects(:find_by!).with(id: 10).returns(doug)
+
+      op = ::AssociationWithForeignKeyOp.new(owner_id: "10")
+      assert_equal doug, op.user
+      assert_equal 10, op.owner_id
+      assert_equal "owner_id", op.field_configurations[:user][:foreign_key]
+    end
+
+    def test_it_allows_a_foreign_key_and_find_by_to_be_set
+      all_mock = mock
+      ::User.expects(:all).returns(all_mock)
+      all_mock.expects(:find_by!).with(email_address: "foo@bar.com").returns(doug)
+
+      op = ::AssociationWithFindByAndForeignKeyOp.new(email_address: "foo@bar.com")
+      assert_equal doug, op.user
+      assert_equal "foo@bar.com", op.email_address
+      assert_equal "email_address", op.field_configurations[:user][:find_by]
+    end
+
+    def test_it_allows_a_find_by_to_be_set
+      all_mock = mock
+      ::User.expects(:all).returns(all_mock)
+      all_mock.expects(:find_by!).with(email_address: doug.email_address).returns(doug)
+
+      op = ::AssociationWithFindByKeyOp.new(user_id: doug.email_address)
+      assert_equal doug, op.user
+      assert_equal "email_address", op.field_configurations[:user][:find_by]
+    end
+
+    def test_values_are_correct_for_find_by_usage
+      op = ::AssociationWithFindByKeyOp.new(user: doug)
+      assert_equal doug, op.user
+      assert_equal doug.email_address, op.user_id
+    end
+
+    def test_values_are_correct_for_foreign_key_usage
+      op = ::AssociationWithForeignKeyOp.new(user: doug)
+      assert_equal doug, op.user
+      assert_equal doug.id, op.owner_id
+    end
+
+    def test_values_are_correct_for_both_foreign_key_and_find_by_usage
+      op = ::AssociationWithFindByAndForeignKeyOp.new(user: doug)
+      assert_equal doug, op.user
+      assert_equal doug.email_address, op.email_address
+      assert_equal false, op.respond_to?(:user_id)
+    end
+
     def test_it_inherits_associations_via_fields_from
       all_mock = mock
 
       ::User.expects(:all).returns(all_mock)
-      all_mock.expects(:find).with(1).returns(doug)
+      all_mock.expects(:find_by!).with(id: 1).returns(doug)
 
       op = ::InheritedSimpleAssociation.new(user_type: "User", user_id: doug.id)
       assert_equal doug, op.user
@@ -88,7 +159,7 @@ module Subroutine
 
       ::User.expects(:all).returns(all_mock)
       all_mock.expects(:unscoped).returns(unscoped_mock)
-      unscoped_mock.expects(:find).with(1).returns(doug)
+      unscoped_mock.expects(:find_by!).with(id: 1).returns(doug)
 
       op = ::InheritedUnscopedAssociation.new(user_type: "User", user_id: doug.id)
       assert_equal doug, op.user
@@ -100,7 +171,7 @@ module Subroutine
       all_mock = mock
       ::User.expects(:all).never
       ::AdminUser.expects(:all).returns(all_mock)
-      all_mock.expects(:find).with(1).returns(doug)
+      all_mock.expects(:find_by!).with(id: 1).returns(doug)
 
       op = ::InheritedPolymorphicAssociationOp.new(admin_type: "AdminUser", admin_id: doug.id)
       assert_equal doug, op.admin

data/test/subroutine/auth_test.rb

@@ -118,5 +118,17 @@ module Subroutine
       RequireUserOp.new(user.id)
     end
 
+    def test_actioncontroller_parameters_can_be_provided
+      raw_params = { some_input: "foobarbaz" }.with_indifferent_access
+      params = ::ActionController::Parameters.new(raw_params)
+      op = RequireUserOp.new(user, params)
+      op.submit!
+
+      assert_equal "foobarbaz", op.some_input
+
+      assert_equal raw_params, op.params
+      assert_equal user, op.current_user
+    end
+
   end
 end

data/test/subroutine/base_test.rb

@@ -42,6 +42,13 @@ module Subroutine
       assert_equal [:baz], op.field_configurations.keys.sort
     end
 
+    def test_fields_from_ignores_except_association_fields
+      op = ::ExceptAssociationOp.new
+      refute op.field_configurations.key?(:admin)
+      refute op.field_configurations.key?(:admin_id)
+      refute op.field_configurations.key?(:admin_type)
+    end
+
     def test_fields_from_only_fields
       op = ::OnlyFooBarOp.new
       assert op.field_configurations.key?(:foo)
@@ -49,6 +56,13 @@ module Subroutine
       refute_equal [:baz], op.field_configurations.keys.sort
     end
 
+    def test_fields_from_only_association_fields
+      op = ::OnlyAssociationOp.new
+      assert op.field_configurations.key?(:admin)
+      assert op.field_configurations.key?(:admin_type)
+      assert op.field_configurations.key?(:admin_id)
+    end
+
     def test_defaults_declaration_options
       op = ::DefaultsOp.new
       assert_equal "foo", op.foo
@@ -113,6 +127,13 @@ module Subroutine
       assert_equal ["has gotta be @admin.com"], op.errors[:email]
     end
 
+    def test_validation_errors_can_be_inherited_and_prefixed
+      op = PrefixedInputsOp.new(user_email_address: "foo@bar.com")
+      refute op.submit
+
+      assert_equal ["has gotta be @admin.com"], op.errors[:user_email_address]
+    end
+
     def test_when_valid_perform_completes_it_returns_control
       op = ::SignupOp.new(email: "foo@bar.com", password: "password123")
       op.submit!
@@ -125,6 +146,11 @@ module Subroutine
       assert_equal "foo@bar.com", u.email_address
     end
 
+    def test_instance_and_class_submit_bang_return_instance
+      assert ::SignupOp.new(email: "foo@bar.com", password: "password123").submit!.is_a?(::SignupOp)
+      assert ::SignupOp.submit!(email: "foo@bar.com", password: "password123").is_a?(::SignupOp)
+    end
+
     def test_it_raises_an_error_when_used_with_a_bang_and_performing_or_validation_fails
       op = ::SignupOp.new(email: "foo@bar.com")
 
@@ -304,5 +330,17 @@ module Subroutine
       end
     end
 
+    def test_actioncontroller_parameters_can_be_provided
+      raw_params = { email: "foo@bar.com", password: "password123!" }.with_indifferent_access
+      params = ::ActionController::Parameters.new(raw_params)
+      op = SignupOp.new(params)
+      op.submit!
+
+      assert_equal "foo@bar.com", op.email
+      assert_equal "password123!", op.password
+
+      assert_equal raw_params, op.params
+    end
+
   end
 end

data/test/subroutine/type_caster_test.rb

@@ -261,5 +261,28 @@ module Subroutine
         op.date_input = "2015-13-01"
       end
     end
+
+    def test_foreign_key_inputs
+      op.fk_input_owner_id = nil
+      assert_nil op.fk_input_owner_id
+
+      op.fk_input_owner_id = ""
+      assert_nil op.fk_input_owner_id
+
+      op.fk_input_owner_id = "19402"
+      assert_equal 19402, op.fk_input_owner_id
+
+      op.fk_input_owner_id = "19402.0"
+      assert_equal 19402, op.fk_input_owner_id
+
+      op.fk_input_email_address = nil
+      assert_nil op.fk_input_email_address
+
+      op.fk_input_email_address = ""
+      assert_nil op.fk_input_email_address
+
+      op.fk_input_email_address = "foo@bar.com"
+      assert_equal "foo@bar.com", op.fk_input_email_address
+    end
   end
 end

data/test/support/ops.rb

@@ -23,6 +23,14 @@ class User
     new(id: id)
   end
 
+  def self.find_by(params)
+    new(params)
+  end
+
+  def self.find_by!(params)
+    find_by(params) || raise
+  end
+
 end
 
 class AdminUser < ::User
@@ -158,6 +166,8 @@ class TypeCastOp < ::Subroutine::Op
   array :array_input, default: "foo"
   array :type_array_input, of: :integer
   file :file_input
+  foreign_key :fk_input_owner_id
+  foreign_key :fk_input_email_address, foreign_key_type: :string
 
 end
 
@@ -177,6 +187,8 @@ class RequireUserOp < OpWithAuth
 
   require_user!
 
+  string :some_input
+
 end
 
 class RequireNoUserOp < OpWithAuth
@@ -206,7 +218,7 @@ class CustomAuthorizeOp < OpWithAuth
   protected
 
   def authorize_user_is_correct
-    unauthorized! unless current_user.email_address.to_s =~ /example\.com$/
+    unauthorized! unless current_user.email_address.to_s =~ /example\.com$/ # rubocop:disable Performance/RegexpMatch
   end
 
 end
@@ -302,6 +314,36 @@ class AssociationWithClassOp < ::OpWithAssociation
 
 end
 
+class AssociationWithForeignKeyOp < ::OpWithAssociation
+
+  association :user, foreign_key: "owner_id"
+
+end
+
+class AssociationWithFindByKeyOp < ::OpWithAssociation
+
+  association :user, find_by: "email_address", foreign_key_type: :string
+
+end
+
+class AssociationWithFindByAndForeignKeyOp < ::OpWithAssociation
+
+  association :user, foreign_key: "email_address", find_by: "email_address"
+
+end
+
+class ExceptAssociationOp < ::Subroutine::Op
+
+  fields_from ::PolymorphicAssociationOp, except: %i[admin]
+
+end
+
+class OnlyAssociationOp < ::Subroutine::Op
+
+  fields_from ::PolymorphicAssociationOp, only: %i[admin]
+
+end
+
 class InheritedSimpleAssociation < ::Subroutine::Op
 
   fields_from SimpleAssociationOp
@@ -433,3 +475,15 @@ class CustomFailureClassOp < ::Subroutine::Op
   end
 
 end
+
+class PrefixedInputsOp < ::Subroutine::Op
+
+  string :user_email_address
+
+  def perform
+    u = AdminUser.new(email_address: user_email_address)
+    u.valid?
+    inherit_errors(u, prefix: :user_)
+  end
+
+end

data/test/test_helper.rb

@@ -1,16 +1,17 @@
 # frozen_string_literal: true
 
-require 'subroutine'
-require 'minitest/autorun'
-require 'minitest/unit'
+require "subroutine"
+require "minitest/autorun"
+require "minitest/unit"
 
-require 'minitest/reporters'
-require 'mocha/minitest'
+require "minitest/reporters"
+require "mocha/minitest"
 
 require "byebug"
+require "action_controller"
 
 Minitest::Reporters.use!([Minitest::Reporters::DefaultReporter.new])
 
 class TestCase < ::Minitest::Test; end
 
-require_relative 'support/ops'
+require_relative "support/ops"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: subroutine
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc4
+  version: 2.0.0.beta2
 platform: ruby
 authors:
 - Mike Nelson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-31 00:00:00.000000000 Z
+date: 2022-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -24,6 +24,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -39,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -109,7 +137,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: byebug
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -133,6 +161,7 @@ files:
 - ".ruby-gemset"
 - ".ruby-version"
 - ".travis.yml"
+- CHANGELOG.MD
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -189,7 +218,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: Feature-driven operation objects.