subroutine 3.0.2 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a69ecebbd8549a3067d41ac4d8981d51c175614f4e052b296226cdce3ad15b30
-  data.tar.gz: e375bae8ee9f1e73ff3eb3128373d50e4cd20af0cf68eaeef16af28688ca2d36
+  metadata.gz: 5b099aef955fc06d44e4a9c628f261e15300fe1dca247c4f8ee042be538037a8
+  data.tar.gz: 3879046fc03f34b01c243f8a1cc1630c30075f6c186593509935b4ae1b62d6a9
 SHA512:
-  metadata.gz: bc51e2794c9a41589aec6d47097cc13644f6e9683b5d5e99ce13310dcf07184d23896dd493ab00ddf54dfa648d7b6236a45968318194b8da53ac66663ae28fc7
-  data.tar.gz: ef4e70f7bf48e180485082f1107b84a9ffbc02037dcc100432435d07d6a634d427ce58546f3010f24723f7e9fbdac52067944fba1294c71078ce11cf30e66488
+  metadata.gz: 60327bcf9acf93b74b5ff94b45d18c7765830f2c2456481585274b75348b316dca245597f332fe95c54b47d6a91f21de7876c96bdcfb3418d213a38d45f1fbdb
+  data.tar.gz: aa61977d8dec95499096f58d9590a059796d0cfe211f604237cb53ab69bc72ad634515c621ad76b128dea11bfba6acb1d6c82b607c22c8fe3fae74364353a3cc

data/CHANGELOG.MD

@@ -1,7 +1,34 @@
+## Subroutine 4.1.0
+
+A field can no opt out of the natural assignment behavior of ActiveSupport::HashWithIndifferentAccess. Top level param groups are still accessible via indifferent access but if a field sets the `bypass_indifferent_assignment` option to `true` the HashWithIndifferentAccess assignment behavior will be bypassed in favor of direct Hash-like assignment.
+
+```ruby
+class MyOp < Subroutine::Op
+
+  object :some_hash
+  object :some_other_hash, bypass_indifferent_assignment: true
+
+end
+```
+
+## Subroutine 4.0.1
+
+Association fields can now use `find_by()` instead of `find_by!()` by passing a `raise_on_miss: false` option. This places the responsibility on the op to manage nil cases rather than handling RecordNotFound errors.
+
+## Subroutine 4.0
+
+The `Subroutine::Fields` module now contains a class_attribute that allows the altering of param accessor behaviors. `include_defaults_in_params` is now available to opt into including the default values in usage of the `all_params (alias params)` method. Backwards compatibility is preserved by defaulting the value to `false`. If switched to true, when an input is omitted and the field is configured with a default value, it will be included in the `all_params` object.
+
+Removed all usage of `ungrouped` params and refactored the storage of grouped params. Params are now stored in either the provided group or the defaults group and accessed via provided_params, params, default_params, and params_with_defaults. Grouped params are accessed the same way but with the group name prefixed eg. `my_private_default_params`.
+
 ## Subroutine 3.0
 
 Add support for Rails 6.1. Drop support for Rails 6.0 and lower.
 
+## Subroutine 2.3
+
+Support dynamic types for foreign keys on association fields. The class type is used at runtime to determine the casting behavior of the foreign key field.
+
 ## Subroutine 2.2
 
 Add `type` validation for Output.

data/lib/subroutine/association_fields/configuration.rb

@@ -30,6 +30,10 @@ module Subroutine
         !!config[:polymorphic]
       end
 
+      def raise_on_miss?
+        config[:raise_on_miss] != false
+      end
+
       def as
         config[:as] || field_name
       end

data/lib/subroutine/association_fields.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "delegate"
-require "active_support/concern"
 require "subroutine/association_fields/configuration"
 require "subroutine/association_fields/association_type_mismatch_error"
 
@@ -72,8 +70,7 @@ module Subroutine
             field config.foreign_type_method, config.build_foreign_type_field
           else
             class_eval <<-EV, __FILE__, __LINE__ + 1
-              try(:silence_redefinition_of_method, :#{config.foreign_type_method})
-              def #{config.foreign_type_method}
+              silence_redefinition_of_method def #{config.foreign_type_method}
                 #{config.inferred_foreign_type.inspect}
               end
             EV
@@ -113,20 +110,20 @@ module Subroutine
       out
     end
 
-    def set_field_with_association(field_name, value, opts = {})
+    def set_field_with_association(field_name, value, **opts)
       config = get_field_config(field_name)
 
       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&.send(config.find_by), opts)
+        set_field(config.foreign_type_method, value&.class&.name, **opts) if config.polymorphic?
+        set_field(config.foreign_key_method, value&.send(config.find_by), **opts)
         association_cache[config.field_name] = value
       else
         if config&.behavior == :association_component
           clear_field_without_association(config.association_name)
         end
 
-        set_field_without_association(field_name, value, opts)
+        set_field_without_association(field_name, value, **opts)
       end
     end
 
@@ -180,7 +177,7 @@ module Subroutine
           get_field(config.foreign_type_method)
         end
 
-      klass = klass.classify.constantize if klass.is_a?(String)
+      klass = klass.camelize.constantize if klass.is_a?(String)
       return nil unless klass
 
       foreign_key = config.foreign_key_method
@@ -190,7 +187,11 @@ module Subroutine
       scope = klass.all
       scope = scope.unscoped if config.unscoped?
 
-      scope.find_by!(config.find_by => value)
+      if config.raise_on_miss?
+        scope.find_by!(config.find_by => value)
+      else
+        scope.find_by(config.find_by => value)
+      end
     end
 
     def maybe_raise_on_association_type_mismatch!(config, record)

data/lib/subroutine/fields/configuration.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "delegate"
-
 module Subroutine
   module Fields
     class Configuration < ::SimpleDelegator
@@ -78,6 +76,10 @@ module Subroutine
         config[:field_reader] != false
       end
 
+      def bypass_indifferent_assignment?
+        config[:bypass_indifferent_assignment] == true
+      end
+
       def groups
         config[:groups] || NO_GROUPS
       end

data/lib/subroutine/fields.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/concern"
-require "active_support/core_ext/object/duplicable"
-require "active_support/core_ext/hash/indifferent_access"
-require "active_support/core_ext/object/deep_dup"
-
 require "subroutine/type_caster"
 require "subroutine/fields/configuration"
 require "subroutine/fields/mass_assignment_error"
@@ -27,11 +22,9 @@ module Subroutine
     end
 
     included do
-      class_attribute :field_configurations
-      self.field_configurations = {}
-
-      class_attribute :field_groups
-      self.field_groups = Set.new
+      class_attribute :include_defaults_in_params, instance_accessor: false, instance_predicate: false
+      class_attribute :field_configurations, default: {}
+      class_attribute :fields_by_group, default: Hash.new { |h, k| h[k] = Set.new }
     end
 
     module ClassMethods
@@ -44,8 +37,15 @@ module Subroutine
 
         ensure_field_accessors(config)
 
-        config.groups.each do |group_name|
-          ensure_group_accessors(group_name)
+        if config.groups.any?
+          new_fields_by_group = self.fields_by_group.deep_dup
+
+          config.groups.each do |group_name|
+            new_fields_by_group[group_name] << config.field_name
+            ensure_group_accessors(group_name)
+          end
+
+          self.fields_by_group = new_fields_by_group
         end
 
         config
@@ -75,18 +75,16 @@ module Subroutine
       end
       alias inputs_from fields_from
 
-      def fields_in_group(group_name)
-        field_configurations.each_with_object({}) do |(field_name, config), h|
-          next unless config.in_group?(group_name)
-
-          h[field_name] = config
-        end
-      end
-
       def get_field_config(field_name)
         field_configurations[field_name.to_sym]
       end
 
+      def include_defaults_in_params?
+        return include_defaults_in_params unless include_defaults_in_params.nil?
+
+        Subroutine.include_defaults_in_params?
+      end
+
       def respond_to_missing?(method_name, *args, &block)
         ::Subroutine::TypeCaster.casters.key?(method_name.to_sym) || super
       end
@@ -106,29 +104,33 @@ module Subroutine
       protected
 
       def ensure_group_accessors(group_name)
-        group_name = group_name.to_sym
-        return if field_groups.include?(group_name)
+        class_eval <<-EV, __FILE__, __LINE__ + 1
+          silence_redefinition_of_method def #{group_name}_params
+            return #{group_name}_params_with_defaults if include_defaults_in_params?
 
-        self.field_groups |= [group_name]
+            #{group_name}_provided_params
+          end
 
-        class_eval <<-EV, __FILE__, __LINE__ + 1
-          def #{group_name}_params
-            param_groups[:#{group_name}]
+          silence_redefinition_of_method def #{group_name}_provided_params
+            get_param_group(:#{group_name}_provided)
           end
 
-          def #{group_name}_default_params
-            group_field_names = fields_in_group(:#{group_name}).keys
-            all_default_params.slice(*group_field_names)
+          silence_redefinition_of_method def #{group_name}_default_params
+            get_param_group(:#{group_name}_default)
           end
           alias #{group_name}_defaults #{group_name}_default_params
 
-          def #{group_name}_params_with_default_params
-            #{group_name}_default_params.merge(param_groups[:#{group_name}])
+          silence_redefinition_of_method def #{group_name}_params_with_default_params
+            param_cache[:#{group_name}_provided_and_default] ||= begin
+              #{group_name}_default_params.merge(#{group_name}_provided_params)
+            end
           end
           alias #{group_name}_params_with_defaults #{group_name}_params_with_default_params
 
-          def without_#{group_name}_params
-            all_params.except(*#{group_name}_params.keys)
+          silence_redefinition_of_method def without_#{group_name}_params
+            param_cache[:without_#{group_name}] ||= begin
+              all_params.except(*#{group_name}_params.keys)
+            end
           end
         EV
       end
@@ -136,17 +138,15 @@ module Subroutine
       def ensure_field_accessors(config)
         if config.field_writer?
           class_eval <<-EV, __FILE__, __LINE__ + 1
-            try(:silence_redefinition_of_method, :#{config.field_name}=)
-            def #{config.field_name}=(v)
-              set_field(:#{config.field_name}, v)
+            silence_redefinition_of_method def #{config.field_name}=(v)
+              set_field(:#{config.field_name}, v, group_type: :provided)
             end
           EV
         end
 
         if config.field_reader?
           class_eval <<-EV, __FILE__, __LINE__ + 1
-            try(:silence_redefinition_of_method, :#{config.field_name})
-            def #{config.field_name}
+            silence_redefinition_of_method def #{config.field_name}
               get_field(:#{config.field_name})
             end
           EV
@@ -159,88 +159,108 @@ module Subroutine
       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
+      inputs.each_pair do |k, v|
+        set_param_group_value(:original, k, v)
+      end
       mass_assign_initial_params
     end
 
+    def include_defaults_in_params?
+      self.class.include_defaults_in_params?
+    end
+
+    def param_cache
+      @param_cache ||= {}
+    end
+
     def param_groups
       @param_groups ||= Hash.new { |h, k| h[k] = {}.with_indifferent_access }
     end
 
     def get_param_group(name)
-      param_groups[name.to_sym]
+      name = name.to_sym
+      return param_groups[name] if param_groups.key?(name)
+
+      param_groups[name] = yield if block_given?
+      param_groups[name]
     end
 
-    def original_params
-      get_param_group(:original)
+    def set_param_group_value(name, key, value)
+      config = get_field_config(key)
+      group = get_param_group(name)
+
+      if config&.bypass_indifferent_assignment?
+        group.regular_writer(group.send(:convert_key, key), value)
+      else
+        group[key.to_sym] = value
+      end
     end
 
-    def ungrouped_params
-      get_param_group(:ungrouped)
+    def original_params
+      get_param_group(:original)
     end
 
-    def all_params
-      get_param_group(:all)
+    def all_provided_params
+      get_param_group(:provided)
     end
-    alias params all_params
+    alias provided_params all_provided_params
 
     def all_default_params
       get_param_group(:default)
     end
     alias defaults all_default_params
+    alias default_params all_default_params
 
-    def all_params_with_defaults
-      all_default_params.merge(all_params)
-    end
-    alias params_with_defaults all_params_with_defaults
+    def all_params
+      return all_params_with_default_params if include_defaults_in_params?
 
-    def ungrouped_defaults
-      default_params.slice(*ungrouped_fields.keys)
+      all_provided_params
     end
+    alias params all_params
 
-    def ungrouped_params_with_defaults
-      ungrouped_defaults.merge(ungrouped_params)
+    def all_params_with_default_params
+      param_cache[:provided_and_default] ||= all_default_params.merge(all_provided_params)
     end
+    alias all_params_with_defaults all_params_with_default_params
+    alias params_with_defaults all_params_with_defaults
+
 
     def get_field_config(field_name)
       self.class.get_field_config(field_name)
     end
 
-    # check if a specific field was provided
     def field_provided?(key)
-      !!@provided_fields[key]
+      all_provided_params.key?(key)
     end
 
     def get_field(name)
-      field_provided?(name) ? all_params[name] : all_default_params[name]
+      all_params_with_default_params[name]
     end
 
-    def set_field(name, value, opts = {})
+    def set_field(name, value, group_type: :provided)
       config = get_field_config(name)
-      @provided_fields[name] = true unless opts[:track_provided] == false
       value = attempt_cast(value, config) do |e|
         "Error during assignment of field `#{name}`: #{e}"
       end
-      each_param_group_for_field(name) do |h|
-        h[name] = value
+
+      set_param_group_value(group_type, config.field_name, value)
+
+      config.groups.each do |group_name|
+        set_param_group_value(:"#{group_name}_#{group_type}", config.field_name, value)
       end
+
+      param_cache.clear
+
       value
     end
 
     def clear_field(name)
-      each_param_group_for_field(name) do |h|
-        h.delete(name)
-      end
-    end
-
-    def fields_in_group(group_name)
-      self.class.fields_in_group(group_name)
-    end
+      param_cache.clear
+      param_groups.each_pair do |key, group|
+        next if key == :original
+        next if key == :default
 
-    def ungrouped_fields
-      fields.select { |f| f.groups.empty? }.each_with_object({}) do |f, h|
-        h[f.name] = f
+        group.delete(name)
       end
     end
 
@@ -253,16 +273,12 @@ module Subroutine
         end
 
         if original_params.key?(field_name)
-          set_field(field_name, original_params[field_name])
+          set_field(field_name, original_params[field_name], group_type: :provided)
         end
 
         next unless config.has_default?
 
-        value = attempt_cast(config.get_default, config) do |e|
-          "Error for default `#{field}`: #{e}"
-        end
-
-        param_groups[:default][field_name] = value
+        set_field(field_name, config.get_default, group_type: :default)
       end
     end
 
@@ -273,18 +289,5 @@ module Subroutine
       raise ::Subroutine::TypeCaster::TypeCastError, message, e.backtrace
     end
 
-    def each_param_group_for_field(name)
-      config = get_field_config(name)
-      yield all_params
-
-      if config.groups.empty?
-        yield ungrouped_params
-      else
-        config.groups.each do |group_name|
-          yield param_groups[group_name]
-        end
-      end
-    end
-
   end
 end

data/lib/subroutine/op.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "active_model"
-
 require "subroutine/failure"
 require "subroutine/fields"
 require "subroutine/outputs"
@@ -48,6 +46,17 @@ module Subroutine
       yield self if block_given?
     end
 
+    def inspect
+      values = provided_params.map do |(key, value)|
+        "#{key}: #{value.inspect}"
+      end
+      values.sort!
+      values = values.join(", ")
+
+      oid = format('%x', (object_id << 1))
+      "#<#{self.class}:0x#{oid} #{values}>"
+    end
+
     def submit!
       begin
         observe_submission do

data/lib/subroutine/outputs/configuration.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "delegate"
-
 module Subroutine
   module Outputs
     class Configuration < ::SimpleDelegator

data/lib/subroutine/outputs.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/concern"
 require "subroutine/outputs/configuration"
 require "subroutine/outputs/output_not_set_error"
 require "subroutine/outputs/unknown_output_error"

data/lib/subroutine/version.rb

@@ -2,9 +2,9 @@
 
 module Subroutine
 
-  MAJOR = 3
-  MINOR = 0
-  PATCH = 2
+  MAJOR = 4
+  MINOR = 1
+  PATCH = 0
   PRE   = nil
 
   VERSION = [MAJOR, MINOR, PATCH, PRE].compact.join(".")

data/lib/subroutine.rb

@@ -1,5 +1,28 @@
 # frozen_string_literal: true
 
+require "active_model"
+require "active_support/concern"
+require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/module/redefine_method"
+require "active_support/core_ext/object/deep_dup"
+require "active_support/core_ext/object/duplicable"
+require "active_support/core_ext/string/inflections"
+require "delegate"
+
 require "subroutine/version"
 require "subroutine/fields"
 require "subroutine/op"
+
+module Subroutine
+
+  def self.include_defaults_in_params=(bool)
+    @include_defaults_in_params = !!bool
+  end
+
+  def self.include_defaults_in_params?
+    return !!@include_defaults_in_params if defined?(@instance_defaults_in_params)
+
+    false
+  end
+
+end

data/test/subroutine/association_test.rb

@@ -335,5 +335,15 @@ module Subroutine
       assert_equal({}, op.without_info_params)
     end
 
+    def test_find_by_is_used_if_raise_on_miss_is_false
+      all_mock = mock
+
+      ::User.expects(:all).returns(all_mock)
+      all_mock.expects(:find_by).with(id: 1).returns(nil)
+
+      op = SafeAssociationOp.new user_type: "User", user_id: 1
+      assert_nil op.user
+    end
+
   end
 end

data/test/subroutine/base_test.rb

@@ -318,5 +318,11 @@ module Subroutine
       assert_equal raw_params, op.params
     end
 
+    def test_inspect_is_pretty
+      op = SignupOp.new({ email: "foo@bar.com", password: "password123!" })
+      oid = format('%x', (op.object_id << 1))
+      assert_equal "#<SignupOp:0x#{oid} email: \"foo@bar.com\", password: \"password123!\">", op.inspect
+    end
+
   end
 end

data/test/subroutine/fields_test.rb

@@ -25,6 +25,25 @@ module Subroutine
 
     end
 
+    class WhateverWithDefaultsIncluded < Whatever
+      self.include_defaults_in_params = true
+    end
+
+    class MutationBase
+      include Subroutine::Fields
+
+      field :foo, group: :three_letter
+      field :bar, group: :three_letter
+
+    end
+
+    class MutationChild < MutationBase
+
+      field :qux, group: :three_letter
+      field :food, group: :four_letter
+
+    end
+
     def test_fields_are_configured
       assert_equal 6, Whatever.field_configurations.size
       assert_equal :string, Whatever.field_configurations[:foo][:type]
@@ -75,17 +94,45 @@ module Subroutine
 
     def test_params_does_not_include_defaults
       instance = Whatever.new(foo: "abc")
+      assert_equal({ "foo" => "abc" }, instance.provided_params)
       assert_equal({ "foo" => "foo", "bar" => 3, "qux" => "qux" }, instance.defaults)
       assert_equal({ "foo" => "abc" }, instance.params)
       assert_equal({ "foo" => "abc", "bar" => 3, "qux" => "qux" }, instance.params_with_defaults)
     end
 
-    def test_named_params_do_not_include_defaults_unlesss_asked_for
+    def test_params_include_defaults_if_globally_configured
+      Subroutine.stubs(:include_defaults_in_params?).returns(true)
       instance = Whatever.new(foo: "abc")
+      assert Whatever.include_defaults_in_params?
+      assert_equal({ "foo" => "abc" }, instance.provided_params)
+      assert_equal({ "foo" => "foo", "bar" => 3, "qux" => "qux" }, instance.defaults)
+      assert_equal({ "foo" => "abc", "bar" => 3, "qux" => "qux" }, instance.params)
+      assert_equal({ "foo" => "abc", "bar" => 3, "qux" => "qux" }, instance.params_with_defaults)
+    end
+
+    def test_params_includes_defaults_if_opted_into
+      refute Subroutine.include_defaults_in_params?
+      instance = WhateverWithDefaultsIncluded.new(foo: "abc")
+      assert_equal({ "foo" => "abc" }, instance.provided_params)
+      assert_equal({ "foo" => "foo", "bar" => 3, "qux" => "qux" }, instance.defaults)
+      assert_equal({ "foo" => "abc", "bar" => 3, "qux" => "qux" }, instance.params)
+      assert_equal({ "foo" => "abc", "bar" => 3, "qux" => "qux" }, instance.params_with_defaults)
+    end
+
+    def test_named_params_do_not_include_defaults_unless_asked_for
+      instance = Whatever.new(foo: "abc")
+      assert_equal({}, instance.sekret_provided_params)
       assert_equal({}, instance.sekret_params)
       assert_equal({ "bar" => 3 }, instance.sekret_params_with_defaults)
     end
 
+    def test_named_params_include_defaults_if_configured
+      instance = WhateverWithDefaultsIncluded.new(foo: "abc")
+      assert_equal({}, instance.sekret_provided_params)
+      assert_equal({ "bar" => 3 }, instance.sekret_params)
+      assert_equal({ "bar" => 3 }, instance.sekret_params_with_defaults)
+    end
+
     def test_fields_can_opt_out_of_mass_assignment
       assert_raises Subroutine::Fields::MassAssignmentError do
         Whatever.new(foo: "abc", protekted: "foo")
@@ -113,18 +160,28 @@ module Subroutine
       assert_equal "bar", instance.foo
     end
 
+    def test_set_field_adds_to_provided_params
+      instance = Whatever.new
+      instance.set_field(:foo, "bar")
+      assert_equal true, instance.provided_params.key?(:foo)
+    end
+
+    def test_set_field_can_add_to_the_default_params
+      instance = Whatever.new
+      instance.set_field(:foo, "bar", group_type: :default)
+      assert_equal false, instance.provided_params.key?(:foo)
+      assert_equal "bar", instance.default_params[:foo]
+    end
+
     def test_group_fields_are_accessible_at_the_class
-      results = Whatever.fields_in_group(:sekret)
-      assert_equal true, results.key?(:protekted_group_input)
-      assert_equal true, results.key?(:bar)
-      assert_equal false, results.key?(:protekted)
+      fields = Whatever.fields_by_group[:sekret].sort
+      assert_equal %i[bar protekted_group_input], fields
     end
 
     def test_groups_fields_are_accessible
       op = Whatever.new(foo: "bar", protekted_group_input: "pgi", bar: 8)
       assert_equal({ protekted_group_input: "pgi", bar: 8 }.with_indifferent_access, op.sekret_params)
       assert_equal({ protekted_group_input: "pgi", foo: "bar", bar: 8 }.with_indifferent_access, op.params)
-      assert_equal({ foo: "bar" }.with_indifferent_access, op.ungrouped_params)
     end
 
     def test_fields_from_allows_merging_of_config
@@ -143,5 +200,19 @@ module Subroutine
       assert_equal(%i[amount_cents credit_cents], OuterInheritanceOp.field_configurations.keys.sort)
     end
 
+    def test_field_definitions_are_not_mutated_by_subclasses
+      assert_equal(%i[bar foo], MutationBase.field_configurations.keys.sort)
+      assert_equal(%i[bar foo food qux], MutationChild.field_configurations.keys.sort)
+    end
+
+    def test_group_fields_are_not_mutated_by_subclasses
+      assert_equal(%i[three_letter], MutationBase.fields_by_group.keys.sort)
+      assert_equal(%i[four_letter three_letter], MutationChild.fields_by_group.keys.sort)
+
+      assert_equal(%i[bar foo], MutationBase.fields_by_group[:three_letter].sort)
+      assert_equal(%i[bar foo qux], MutationChild.fields_by_group[:three_letter].sort)
+      assert_equal(%i[food], MutationChild.fields_by_group[:four_letter].sort)
+    end
+
   end
 end

data/test/subroutine/type_caster_test.rb

@@ -175,6 +175,34 @@ module Subroutine
 
       op.object_input = { 'foo' => { 'bar' => :baz } }
       assert_equal({ 'foo' => { 'bar' => :baz } }, op.object_input)
+
+      op.object_input = { foo: "bar" }
+      assert op.object_input.is_a?(ActiveSupport::HashWithIndifferentAccess)
+    end
+
+    def test_hash_inputs_can_opt_out_of_indifferent_access_behavior
+      op.no_indifferent_object_input = nil
+      assert_nil op.no_indifferent_object_input
+
+      op.no_indifferent_object_input = ''
+      assert_equal({}, op.no_indifferent_object_input)
+
+      op.no_indifferent_object_input = [[:a, :b]]
+      assert_equal({ a: :b }, op.no_indifferent_object_input)
+
+      op.no_indifferent_object_input = { foo: "bar" }
+      assert_equal({ foo: "bar" }, op.no_indifferent_object_input)
+      assert op.no_indifferent_object_input.key?(:foo)
+      refute op.no_indifferent_object_input.key?("foo")
+      refute op.no_indifferent_object_input.is_a?(ActiveSupport::HashWithIndifferentAccess)
+      assert op.no_indifferent_object_input.is_a?(Hash)
+
+      op.no_indifferent_object_input = { "foo" => "bar" }
+      assert_equal({ "foo" => "bar" }, op.no_indifferent_object_input)
+      assert op.no_indifferent_object_input.key?("foo")
+      refute op.no_indifferent_object_input.key?(:foo)
+      refute op.no_indifferent_object_input.is_a?(ActiveSupport::HashWithIndifferentAccess)
+      assert op.no_indifferent_object_input.is_a?(Hash)
     end
 
     def test_array_inputs

data/test/support/ops.rb

@@ -27,10 +27,6 @@ class User
     new(params)
   end
 
-  def self.find_by!(params)
-    find_by(params) || raise
-  end
-
   def self.type_for_attribute(attribute)
     case attribute
     when :id
@@ -180,6 +176,7 @@ class TypeCastOp < ::Subroutine::Op
   iso_date :iso_date_input
   iso_time :iso_time_input
   object :object_input
+  object :no_indifferent_object_input, bypass_indifferent_assignment: true
   array :array_input, default: "foo"
   array :type_array_input, of: :integer
   file :file_input
@@ -342,6 +339,12 @@ class SimpleAssociationOp < ::OpWithAssociation
 
 end
 
+class SafeAssociationOp < ::OpWithAssociation
+
+  association :user, raise_on_miss: false
+
+end
+
 class SimpleAssociationWithStringIdOp < ::OpWithAssociation
 
   association :string_id_user

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: subroutine
 version: !ruby/object:Gem::Version
-  version: 3.0.2
+  version: 4.1.0
 platform: ruby
 authors:
 - Mike Nelson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-03 00:00:00.000000000 Z
+date: 2024-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel