subroutine 1.0.1 → 2.0.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8871d701ab81402f275e38e7bf632c629bffc4320d31040119d99b12db05caf
-  data.tar.gz: edba79a803523a74e4e53d5e9cf62bf0dbdb2087592e7503b7b2d18395e5a8a6
+  metadata.gz: d0ade77ec5abb9601e1dce7bc53e34baac35c978a41aef3268b57ee5b9def6e5
+  data.tar.gz: c450947886efc34b26b202b52202909f44735a2d5f26a3c1af51fdf93be509c6
 SHA512:
-  metadata.gz: 9953dd7a8ac11f4c842773c88a338e255c254bbf38f50a3437f204406a8136eca15544cd87aa9641395faf933ca9a00ddf9b3951a2a76326302e677988240143
-  data.tar.gz: 900b42b891947630463f3700a5df207d5e689a91dbe2e1970987f41b565fac7889083161d9d39bfd36082a7d0f4d1667d9b8bd549e7804371c58ad2987d238a0
+  metadata.gz: c171a9bb82076ed4f5e407375d19e423a5e6bba0211192109d300e3b7372d537a0bac3d67ef5c480ef9af34ddd2a849a07fef79459f5597ea97e195cad239fe7
+  data.tar.gz: 52502e8dd504de2d59faa4665ab7c755c9ff6ba8b951e79acaa264c4d257f09a20da58977f1565e8d121023d6a2f5291cd4528eca143d697252b2f6a27d4197b

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
@@ -119,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
@@ -137,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)
@@ -175,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/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
@@ -34,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
@@ -54,8 +55,12 @@ module Subroutine
         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)
       end
 
       def build_foreign_type_field

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)
@@ -100,6 +100,7 @@ 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
       end
 

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/version.rb

@@ -2,10 +2,10 @@
 
 module Subroutine
 
-  MAJOR = 1
+  MAJOR = 2
   MINOR = 0
-  PATCH = 1
-  PRE   = nil
+  PATCH = 0
+  PRE   = "beta"
 
   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,60 @@ 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: "foobarbaz").returns(doug)
+
+      op = ::AssociationWithForeignKeyOp.new(user_identifier: "foobarbaz")
+      assert_equal doug, op.user
+      assert_equal "user_identifier", 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: doug.email_address).returns(doug)
+
+      op = ::AssociationWithFindByAndForeignKeyOp.new(email_address: doug.email_address)
+      assert_equal doug, op.user
+      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.user_identifier
+    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 +147,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 +159,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

@@ -127,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!
@@ -139,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/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
@@ -304,6 +312,24 @@ class AssociationWithClassOp < ::OpWithAssociation
 
 end
 
+class AssociationWithForeignKeyOp < ::OpWithAssociation
+
+  association :user, foreign_key: "user_identifier"
+
+end
+
+class AssociationWithFindByKeyOp < ::OpWithAssociation
+
+  association :user, find_by: "email_address"
+
+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]
@@ -447,3 +473,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.1
+  version: 2.0.0.beta
 platform: ruby
 authors:
 - Mike Nelson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-21 00:00:00.000000000 Z
+date: 2021-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -214,9 +214,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.0.6
 signing_key: