subroutine 0.10.0.beta → 0.10.0.beta2

data/lib/subroutine/fields.rb

@@ -6,7 +6,8 @@ require "active_support/core_ext/hash/indifferent_access"
 require "active_support/core_ext/object/deep_dup"
 
 require "subroutine/type_caster"
-require "subroutine/association"
+require "subroutine/fields/configuration"
+require "subroutine/fields/mass_assignment_error"
 
 module Subroutine
   module Fields
@@ -14,24 +15,41 @@ module Subroutine
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :_fields
-      self._fields = {}
-      attr_reader :original_params
-      attr_reader :params, :defaults
+      class_attribute :field_configurations
+      self.field_configurations = {}
     end
 
     module ClassMethods
-      # fields can be provided in the following way:
-      # field :field1, :field2
-      # field :field3, :field4, default: 'my default'
-      def field(*fields)
-        options = fields.extract_options!
-
-        fields.each do |f|
-          _field(f, options)
+
+      def field(field_name, options = {})
+        config = ::Subroutine::Fields::Configuration.from(field_name, options)
+        config.validate!
+
+        config.groups.each do |group_name|
+          _group(group_name)
+        end
+
+        self.field_configurations = field_configurations.merge(field_name.to_sym => config)
+
+        if config.field_writer?
+          class_eval <<-EV, __FILE__, __LINE__ + 1
+            try(:silence_redefinition_of_method, :#{field_name}=)
+            def #{field_name}=(v)
+              set_field(:#{field_name}, v)
+            end
+          EV
+        end
+
+        if config.field_reader?
+          class_eval <<-EV, __FILE__, __LINE__ + 1
+            try(:silence_redefinition_of_method, :#{field_name})
+            def #{field_name}
+              get_field(:#{field_name})
+            end
+          EV
         end
       end
-      alias_method :fields, :field
+      alias input field
 
       def inputs_from(*things)
         options = things.extract_options!
@@ -39,20 +57,31 @@ module Subroutine
         onlys = options.key?(:only) ? Array(options.delete(:only)) : nil
 
         things.each do |thing|
-          thing._fields.each_pair do |field_name, opts|
-            next if excepts && excepts.include?(field_name)
+          thing.field_configurations.each_pair do |field_name, config|
+            next if excepts&.include?(field_name)
             next if onlys && !onlys.include?(field_name)
 
-            if opts[:association]
-              include ::Subroutine::Association unless included_modules.include?(::Subroutine::Association)
-              association(field_name, opts)
-            else
-              field(field_name, opts)
+            config.required_modules.each do |mod|
+              include mod unless included_modules.include?(mod)
             end
+
+            field(field_name, config)
           end
         end
       end
-      alias_method :fields_from, :inputs_from
+      alias fields_from inputs_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 respond_to_missing?(method_name, *args, &block)
         ::Subroutine::TypeCaster.casters.key?(method_name.to_sym) || super
@@ -61,10 +90,10 @@ module Subroutine
       def method_missing(method_name, *args, &block)
         caster = ::Subroutine::TypeCaster.casters[method_name.to_sym]
         if caster
-          options = args.extract_options!
+          field_name, options = args
+          options ||= {}
           options[:type] = method_name.to_sym
-          args.push(options)
-          field(*args, &block)
+          field(field_name, options)
         else
           super
         end
@@ -72,84 +101,106 @@ module Subroutine
 
       protected
 
-      def _field(field_name, field_writer: true, field_reader: true, **options)
-        self._fields = _fields.merge(field_name.to_sym => options)
-
-        if field_writer
-          class_eval <<-EV, __FILE__, __LINE__ + 1
-            try(:silence_redefinition_of_method, :#{field_name}=)
-            def #{field_name}=(v)
-              config = #{field_name}_config
-              @fields_provided["#{field_name}"] = true
-              @params["#{field_name}"] = attempt_cast(v, config) do |e|
-                "Error during assignment of field `#{field_name}`: \#{e}"
-              end
-            end
-          EV
-        end
-
-        if field_reader
-          class_eval <<-EV, __FILE__, __LINE__ + 1
-            try(:silence_redefinition_of_method, :#{field_name})
-            def #{field_name}
-              @params["#{field_name}"]
-            end
-          EV
-        end
-
+      def _group(group_name)
         class_eval <<-EV, __FILE__, __LINE__ + 1
-          try(:silence_redefinition_of_method, :#{field_name}_config)
-          def #{field_name}_config
-            _fields[:#{field_name}]
+          try(:silence_redefinition_of_method, :#{group_name}_params)
+          def #{group_name}_params
+            param_groups[:#{group_name}]
+          end
+
+          try(:silence_redefinition_of_method, :without_#{group_name}_params)
+          def without_#{group_name}_params
+            all_params.except(*#{group_name}_params.keys)
           end
         EV
       end
+
     end
 
     def setup_fields(inputs = {})
-      @original_params = inputs.with_indifferent_access
-      @defaults = build_defaults
-      @fields_provided = {}.with_indifferent_access
-      @params = build_params(@original_params, @defaults)
+      @provided_fields = {}.with_indifferent_access
+      param_groups[:original] = inputs.with_indifferent_access
+      param_groups[:default] = build_defaults
+      mass_assign_initial_params
+    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]
+    end
+
+    def original_params
+      get_param_group(:original)
+    end
+
+    def ungrouped_params
+      get_param_group(:ungrouped)
+    end
+    alias params ungrouped_params
+
+    def all_params
+      get_param_group(:all)
+    end
+
+    def defaults
+      get_param_group(:default)
+    end
+    alias default_params 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)
-      return send(:"#{key}_field_provided?") if respond_to?(:"#{key}_field_provided?", true)
+      !!@provided_fields[key]
+    end
 
-      !!@fields_provided[key]
+    def get_field(name)
+      all_params[name]
     end
 
-    # if you want to use strong parameters or something in your form object you can do so here.
-    # by default we just slice the inputs to the defined fields
-    def build_params(inputs, defaults)
-      out = {}.with_indifferent_access
+    def set_field(name, value, track_provided: true)
+      config = get_field_config(name)
+      @provided_fields[name] = true if track_provided
+      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
+      end
+      value
+    end
 
-      _fields.each_pair do |field, config|
+    def clear_field(name)
+      each_param_group_for_field(name) do |h|
+        h.delete(name)
+      end
+    end
+
+    protected
 
-        if config[:mass_assignable] == false && inputs.key?(field)
-          raise ArgumentError, "`#{field}` is not mass assignable"
+    def mass_assign_initial_params
+      field_configurations.each_pair do |field_name, config|
+        if !config.mass_assignable? && original_params.key?(field_name)
+          raise ::Subroutine::Fields::MassAssignmentError, field_name
         end
 
-        if inputs.key?(field)
-          @fields_provided[field] = true
-          out[field] = attempt_cast(inputs[field], config) do |e|
-            "Error for field `#{field}`: #{e}"
-          end
-        elsif defaults.key?(field)
-          out[field] =  defaults[field]
-        else
-          next
+        if original_params.key?(field_name)
+          set_field(field_name, original_params[field_name])
+        elsif defaults.key?(field_name)
+          set_field(field_name, defaults[field_name], track_provided: false)
         end
       end
-
-      out
     end
 
     def build_defaults
-      @defaults = {}.with_indifferent_access
+      out = {}.with_indifferent_access
 
-      _fields.each_pair do |field, config|
+      field_configurations.each_pair do |field, config|
         next unless config.key?(:default)
 
         deflt = config[:default]
@@ -161,20 +212,33 @@ module Subroutine
           deflt = deflt.deep_dup # from active_support
         end
 
-        @defaults[field.to_s] = attempt_cast(deflt, config) do |e|
+        out[field.to_s] = attempt_cast(deflt, config) do |e|
           "Error for default `#{field}`: #{e}"
         end
       end
 
-      @defaults
+      out
     end
 
     def attempt_cast(value, config)
       ::Subroutine::TypeCaster.cast(value, config)
-      rescue ::Subroutine::TypeCaster::TypeCastError => e
+    rescue ::Subroutine::TypeCaster::TypeCastError => e
       message = block_given? ? yield(e) : e.to_s
       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

@@ -2,10 +2,9 @@
 
 require "active_model"
 
-require "subroutine/fields"
 require "subroutine/failure"
-require "subroutine/output_not_set_error"
-require "subroutine/unknown_output_error"
+require "subroutine/fields"
+require "subroutine/outputs"
 
 module Subroutine
   class Op
@@ -13,28 +12,17 @@ module Subroutine
     include ::ActiveModel::Validations
     include ::ActiveModel::Validations::Callbacks
     include ::Subroutine::Fields
-
-    DEFAULT_OUTPUT_OPTIONS = {
-      required: true,
-    }.freeze
+    include ::Subroutine::Outputs
 
     class << self
 
-      def outputs(*names)
-        options = names.extract_options!
-        names.each do |name|
-          self._outputs = _outputs.merge(name.to_sym => DEFAULT_OUTPUT_OPTIONS.merge(options))
-
-          class_eval <<-EV, __FILE__, __LINE__ + 1
-            def #{name}
-              @outputs[:#{name}]
-            end
-          EV
-        end
+      def failure_class(klass)
+        self._failure_class = klass
       end
 
       def submit!(*args)
         raise ArgumentError, "Blocks cannot be provided to `submit!`" if block_given?
+
         op = new(*args)
         op.submit!
 
@@ -43,6 +31,7 @@ module Subroutine
 
       def submit(*args)
         raise ArgumentError, "Blocks cannot be provided to `submit`." if block_given?
+
         op = new(*args)
         op.submit
         op
@@ -50,7 +39,7 @@ module Subroutine
 
       protected
 
-      def _field(field_name, options = {})
+      def field(field_name, options = {})
         result = super(field_name, options)
 
         if options[:aka]
@@ -64,26 +53,18 @@ module Subroutine
 
     end
 
-    class_attribute :_outputs
-    self._outputs = {}
+    class_attribute :_failure_class
+    self._failure_class = Subroutine::Failure
 
     class_attribute :_error_map
     self._error_map = {}
 
     def initialize(inputs = {})
       setup_fields(inputs)
-      @outputs = {}
+      setup_outputs
       yield self if block_given?
     end
 
-    def output(name, value)
-      unless _outputs.key?(name.to_sym)
-        raise ::Subroutine::UnknownOutputError, name
-      end
-
-      @outputs[name.to_sym] = value
-    end
-
     def submit!
       begin
         observe_submission do
@@ -92,7 +73,7 @@ module Subroutine
       rescue Exception => e
         if e.respond_to?(:record)
           inherit_errors(e.record) unless e.record == self
-          new_e = ::Subroutine::Failure.new(self)
+          new_e = _failure_class.new(self)
           raise new_e, new_e.message, e.backtrace
         else
           raise
@@ -100,15 +81,10 @@ module Subroutine
       end
 
       if errors.empty?
-        _outputs.each_pair do |name, config|
-          if config[:required] && !@outputs.key?(name)
-            raise ::Subroutine::OutputNotSetError, name
-          end
-        end
-
+        validate_outputs!
         true
       else
-        raise ::Subroutine::Failure, self
+        raise _failure_class, self
       end
     end
 

data/lib/subroutine/outputs/configuration.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module Subroutine
+  module Outputs
+    class Configuration < ::SimpleDelegator
+
+      def self.from(field_name, options)
+        case options
+        when Subroutine::Outputs::Configuration
+          options.class.new(field_name, options)
+        else
+          new(field_name, options)
+        end
+      end
+
+      DEFAULT_OPTIONS = { required: true }.freeze
+
+      attr_reader :output_name
+
+      def initialize(output_name, config)
+        @output_name = output_name
+        super(DEFAULT_OPTIONS.merge(config))
+      end
+
+      alias config __getobj__
+
+      def required?
+        !!config[:required]
+      end
+
+      def inspect
+        "#<#{self.class}:#{object_id} name=#{output_name} config=#{config.inspect}>"
+      end
+
+    end
+  end
+end

data/lib/subroutine/outputs/output_not_set_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Subroutine
+  module Outputs
+    class OutputNotSetError < StandardError
+
+      def initialize(name)
+        super("Expected output '#{name}' to be set upon completion of perform but was not.")
+      end
+
+    end
+  end
+end

data/lib/subroutine/outputs/unknown_output_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Subroutine
+  module Outputs
+    class UnknownOutputError < StandardError
+
+      def initialize(name)
+        super("Unknown output '#{name}'")
+      end
+
+    end
+  end
+end

data/lib/subroutine/outputs.rb

@@ -0,0 +1,66 @@
+# 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"
+
+module Subroutine
+  module Outputs
+
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :output_configurations
+      self.output_configurations = {}
+
+      attr_reader :outputs
+    end
+
+    module ClassMethods
+
+      def outputs(*names)
+        options = names.extract_options!
+        names.each do |name|
+          config = ::Subroutine::Outputs::Configuration.new(name, options)
+          self.output_configurations = output_configurations.merge(name.to_sym => config)
+
+          class_eval <<-EV, __FILE__, __LINE__ + 1
+            def #{name}
+              get_output(:#{name})
+            end
+          EV
+        end
+      end
+
+    end
+
+    def setup_outputs
+      @outputs = {}.with_indifferent_access
+    end
+
+    def output(name, value)
+      unless output_configurations.key?(name.to_sym)
+        raise ::Subroutine::Outputs::UnknownOutputError, name
+      end
+
+      outputs[name.to_sym] = value
+    end
+
+    def get_output(name)
+      name = name.to_sym
+      raise ::Subroutine::Outputs::UnknownOutputError, name unless output_configurations.key?(name)
+
+      outputs[name]
+    end
+
+    def validate_outputs!
+      output_configurations.each_pair do |name, config|
+        if config.required? && !outputs.key?(name)
+          raise ::Subroutine::Outputs::OutputNotSetError, name
+        end
+      end
+    end
+
+  end
+end

data/lib/subroutine/version.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 module Subroutine
+
   MAJOR = 0
   MINOR = 10
   PATCH = 0
-  PRE   = "beta"
+  PRE   = "beta2"
+
+  VERSION = [MAJOR, MINOR, PATCH, PRE].compact.join(".")
 
-  VERSION = [MAJOR, MINOR, PATCH, PRE].compact.join('.')
 end

data/test/subroutine/association_test.rb

@@ -1,20 +1,21 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+require "test_helper"
 
 module Subroutine
-  class AuthTest < TestCase
+  class AssociationTest < TestCase
+
     def doug
-      @doug ||= ::User.new(id: 1, email_address: 'doug@example.com')
+      @doug ||= ::User.new(id: 1, email_address: "doug@example.com")
     end
 
     def fred
-      @fred ||= ::User.new(id: 2, email_address: 'fred@example.com')
+      @fred ||= ::User.new(id: 2, email_address: "fred@example.com")
     end
 
     def test_it_sets_accessors_on_init
       op = SimpleAssociationOp.new user: doug
-      assert_equal 'User', op.user_type
+      assert_equal "User", op.user_type
       assert_equal doug.id, op.user_id
     end
 
@@ -24,7 +25,7 @@ module Subroutine
       ::User.expects(:all).returns(all_mock)
       all_mock.expects(:find).with(1).returns(doug)
 
-      op = SimpleAssociationOp.new user_type: 'User', user_id: doug.id
+      op = SimpleAssociationOp.new user_type: "User", user_id: doug.id
       assert_equal doug, op.user
     end
 
@@ -34,7 +35,7 @@ module Subroutine
       ::User.expects(:all).returns(all_mock)
       all_mock.expects(:find).with(1).returns(doug)
 
-      op = SimpleAssociationOp.new user_type: 'users', user_id: doug.id
+      op = SimpleAssociationOp.new user_id: doug.id
       assert_equal doug, op.user
     end
 
@@ -46,7 +47,7 @@ module Subroutine
       all_mock.expects(:unscoped).returns(unscoped_mock)
       unscoped_mock.expects(:find).with(1).returns(doug)
 
-      op = UnscopedSimpleAssociationOp.new user_type: 'User', user_id: doug.id
+      op = UnscopedSimpleAssociationOp.new user_id: doug.id
       assert_equal doug, op.user
     end
 
@@ -56,13 +57,13 @@ module Subroutine
       ::AdminUser.expects(:all).returns(all_mock)
       all_mock.expects(:find).with(1).returns(doug)
 
-      op = PolymorphicAssociationOp.new(admin_type: 'AdminUser', admin_id: doug.id)
+      op = PolymorphicAssociationOp.new(admin_type: "AdminUser", admin_id: doug.id)
       assert_equal doug, op.admin
     end
 
     def test_it_allows_the_class_to_be_set
       op = ::AssociationWithClassOp.new(admin: doug)
-      assert_equal 'AdminUser', op.admin_type
+      assert_equal "AdminUser", op.admin_type
     end
 
     def test_it_inherits_associations_via_inputs_from
@@ -71,9 +72,9 @@ module Subroutine
       ::User.expects(:all).returns(all_mock)
       all_mock.expects(:find).with(1).returns(doug)
 
-      op = ::InheritedSimpleAssociation.new(user_type: 'User', user_id: doug.id)
+      op = ::InheritedSimpleAssociation.new(user_type: "User", user_id: doug.id)
       assert_equal doug, op.user
-      assert_equal 'User', op.user_type
+      assert_equal "User", op.user_type
       assert_equal doug.id, op.user_id
     end
 
@@ -85,9 +86,9 @@ module Subroutine
       all_mock.expects(:unscoped).returns(unscoped_mock)
       unscoped_mock.expects(:find).with(1).returns(doug)
 
-      op = ::InheritedUnscopedAssociation.new(user_type: 'User', user_id: doug.id)
+      op = ::InheritedUnscopedAssociation.new(user_type: "User", user_id: doug.id)
       assert_equal doug, op.user
-      assert_equal 'User', op.user_type
+      assert_equal "User", op.user_type
       assert_equal doug.id, op.user_id
     end
 
@@ -97,9 +98,9 @@ module Subroutine
       ::AdminUser.expects(:all).returns(all_mock)
       all_mock.expects(:find).with(1).returns(doug)
 
-      op = ::InheritedPolymorphicAssociationOp.new(admin_type: 'AdminUser', admin_id: doug.id)
+      op = ::InheritedPolymorphicAssociationOp.new(admin_type: "AdminUser", admin_id: doug.id)
       assert_equal doug, op.admin
-      assert_equal 'AdminUser', op.admin_type
+      assert_equal "AdminUser", op.admin_type
       assert_equal doug.id, op.admin_id
     end
 
@@ -140,7 +141,7 @@ module Subroutine
       assert_equal false, op.field_provided?(:admin)
       assert_equal false, op.field_provided?(:admin_id)
       assert_equal false, op.field_provided?(:admin_type)
-
     end
+
   end
 end