subroutine 1.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25c11b61b2c6af19a7be888c2ba66284cb799cf72131e9f7a7893ccf188babd6
-  data.tar.gz: b22a8fec39573b99429fb27ad07340c1e0fa3133562a5190b8d6d088eeb9dbab
+  metadata.gz: 9fbd9c97951c8e07f3f84fe1f9826d4fff45a7f0fe99045d375e34d530fb0934
+  data.tar.gz: db76eef88d0afd766a7a906d0cf5a202286d90da3f6ec113e798b6709f3c96e4
 SHA512:
-  metadata.gz: 559745dc62dde51e43bde01b4b5fd2598a40edf6b02945abc2f7d71a0b948e5c76d259ac8239ba91fe8aadd4f23db4569feeaf01320287744b25dd9b168b4c29
-  data.tar.gz: b8bb15b169ddd8fe7a8e64bb4dcd8f6815b458fda0dc6f035310c2e2ea483a92196357f4893945f982ed661e1dd01ca4d51a43a9250e4b96fd5eeda1459ff22f
+  metadata.gz: 2310334da4ebf40292d6868c1ab59b028d790fd01db3ef55825d4f680810e157ffd35c9d6a19e6b1e58816aad8eb87f01b1ae9e9395914350d23b80a84b4874b
+  data.tar.gz: 4b426d21e7e91f27405daf3a7438f4a049f4a5a7ee13002488259e5599989a867d2fbf9c31f56cff7c8be452708175ba786700729ab88b2f186c4ed4159fcecb

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/README.md

@@ -12,7 +12,7 @@ class SignupOp < ::Subroutine::Op
   string :name
   string :email
   string :password
-  
+
   string :company_name
 
   validates :name, presence: true
@@ -28,7 +28,7 @@ class SignupOp < ::Subroutine::Op
   def perform
     u = create_user!
     b = create_business!(u)
-    
+
     deliver_welcome_email(u)
 
     output :user, u
@@ -38,7 +38,7 @@ class SignupOp < ::Subroutine::Op
   def create_user!
     User.create!(name: name, email: email, password: password)
   end
-  
+
   def create_business!(owner)
     Business.create!(company_name: company_name, owner: owner)
    end
@@ -56,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/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/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

@@ -58,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)

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,9 +2,9 @@
 
 module Subroutine
 
-  MAJOR = 1
+  MAJOR = 2
   MINOR = 0
-  PATCH = 0
+  PATCH = 1
   PRE   = nil
 
   VERSION = [MAJOR, MINOR, PATCH, PRE].compact.join(".")

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/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")
 

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
 
@@ -208,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
@@ -304,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
@@ -435,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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: subroutine
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Mike Nelson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-19 00:00:00.000000000 Z
+date: 2022-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -161,6 +161,7 @@ files:
 - ".ruby-gemset"
 - ".ruby-version"
 - ".travis.yml"
+- CHANGELOG.MD
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -217,7 +218,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: Feature-driven operation objects.