active_interaction 3.8.0 → 4.0.1

data/lib/active_interaction/filters/symbol_filter.rb

@@ -1,8 +1,7 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 module ActiveInteraction
-  class Base
+  class Base # rubocop:disable Lint/EmptyClass
     # @!method self.symbol(*attributes, options = {})
     #   Creates accessors for the attributes and ensures that values passed to
     #     the attributes are Symbols. Strings will be converted to Symbols.
@@ -17,15 +16,22 @@ module ActiveInteraction
   class SymbolFilter < Filter
     register :symbol
 
-    def cast(value, _interaction)
-      case value
-      when Symbol
-        value
-      when String
+    private
+
+    def matches?(value)
+      value.is_a?(Symbol)
+    rescue NoMethodError # BasicObject
+      false
+    end
+
+    def convert(value)
+      if value.respond_to?(:to_sym)
         value.to_sym
       else
         super
       end
+    rescue NoMethodError # BasicObject
+      super
     end
   end
 end

data/lib/active_interaction/filters/time_filter.rb

@@ -1,8 +1,7 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 module ActiveInteraction
-  class Base
+  class Base # rubocop:disable Lint/EmptyClass
     # @!method self.time(*attributes, options = {})
     #   Creates accessors for the attributes and ensures that values passed to
     #     the attributes are Times. Numeric values are processed using `at`.
@@ -24,34 +23,24 @@ module ActiveInteraction
   class TimeFilter < AbstractDateTimeFilter
     register :time
 
-    alias _klass klass
-    private :_klass
-
     def initialize(name, options = {}, &block)
-      if options.key?(:format) && klass != Time
-        raise InvalidFilterError, 'format option unsupported with time zones'
-      end
+      raise InvalidFilterError, 'format option unsupported with time zones' if options.key?(:format) && time_with_zone?
 
       super
     end
 
-    def cast(value, _interaction)
-      case value
-      when Numeric
-        klass.at(value)
-      else
-        super
-      end
-    end
-
     def database_column_type
       :datetime
     end
 
     private
 
+    def time_with_zone?
+      Time.respond_to?(:zone) && !Time.zone.nil?
+    end
+
     def klass
-      if Time.respond_to?(:zone) && !Time.zone.nil?
+      if time_with_zone?
         Time.zone
       else
         super
@@ -59,7 +48,23 @@ module ActiveInteraction
     end
 
     def klasses
-      [_klass, klass.at(0).class]
+      if time_with_zone?
+        [Time.zone.at(0).class, Time]
+      else
+        super
+      end
+    end
+
+    def convert(value)
+      value = value.to_int if value.respond_to?(:to_int)
+
+      if value.is_a?(Numeric)
+        klass.at(value)
+      else
+        super
+      end
+    rescue NoMethodError # BasicObject
+      super
     end
   end
 end

data/lib/active_interaction/grouped_input.rb

@@ -1,4 +1,3 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 require 'ostruct'
@@ -6,8 +5,6 @@ require 'ostruct'
 module ActiveInteraction
   # Holds a group of inputs together for passing from {Base} to {Filter}s.
   #
-  # @since 1.2.0
-  #
   # @private
   class GroupedInput < OpenStruct
   end

data/lib/active_interaction/inputs.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module ActiveInteraction
+  # Holds inputs passed to the interaction.
+  class Inputs < DelegateClass(Hash)
+    class << self
+      # matches inputs like "key(1i)"
+      GROUPED_INPUT_PATTERN = /
+        \A
+        (?<key>.+)         # extracts "key"
+        \((?<index>\d+)i\) # extracts "1"
+        \z
+      /x.freeze
+      private_constant :GROUPED_INPUT_PATTERN
+
+      # Checking `syscall` is the result of what appears to be a bug in Ruby.
+      # https://bugs.ruby-lang.org/issues/15597
+      def reserved?(name)
+        name.to_s.start_with?('_interaction_') ||
+          name == :syscall ||
+          (
+            Base.method_defined?(name) &&
+            !Object.method_defined?(name)
+          ) ||
+          (
+            Base.private_method_defined?(name) &&
+            !Object.private_method_defined?(name)
+          )
+      end
+
+      def process(inputs)
+        inputs.stringify_keys.sort.each_with_object({}) do |(k, v), h|
+          next if reserved?(k)
+
+          if (group = GROUPED_INPUT_PATTERN.match(k))
+            assign_to_grouped_input!(h, group[:key], group[:index], v)
+          else
+            h[k.to_sym] = v
+          end
+        end
+      end
+
+      private
+
+      def assign_to_grouped_input!(inputs, key, index, value)
+        key = key.to_sym
+
+        inputs[key] = GroupedInput.new unless inputs[key].is_a?(GroupedInput)
+        inputs[key][index] = value
+      end
+    end
+
+    def initialize
+      @groups = {}
+      @groups.default_proc = ->(hash, key) { hash[key] = [] }
+
+      super(@inputs = {})
+    end
+
+    # Associates the `value` with the `key`. Allows the `key`/`value` pair to
+    #   be associated with one or more groups.
+    #
+    # @example
+    #   inputs.store(:key, :value)
+    #   # => :value
+    #   inputs.store(:key, :value, %i[a b])
+    #   # => :value
+    #
+    # @param key [Object] The key to store the value under.
+    # @param value [Object] The value to store.
+    # @param groups [Array<Object>] The groups to store the pair under.
+    #
+    # @return [Object] value
+    def store(key, value, groups = [])
+      groups.each do |group|
+        @groups[group] << key
+      end
+
+      super(key, value)
+    end
+
+    # Returns inputs from the group name given.
+    #
+    # @example
+    #   inputs.group(:a)
+    #   # => {key: :value}
+    #
+    # @param name [Object] Name of the group to return.
+    #
+    # @return [Hash] Inputs from the group name given.
+    def group(name)
+      @inputs.select { |k, _| @groups[name].include?(k) }
+    end
+  end
+end

data/lib/active_interaction/modules/validation.rb

@@ -1,4 +1,3 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 module ActiveInteraction
@@ -12,14 +11,13 @@ module ActiveInteraction
       # @param inputs [Hash{Symbol => Object}]
       def validate(context, filters, inputs)
         filters.each_with_object([]) do |(name, filter), errors|
-          begin
-            filter.clean(inputs[name], context)
-          rescue NoDefaultError
-            nil
-          rescue InvalidNestedValueError,
-                 InvalidValueError, MissingValueError => e
-            errors << error_args(filter, e)
-          end
+          filter.clean(inputs[name], context)
+        rescue NoDefaultError
+          nil
+        rescue InvalidNestedValueError,
+               InvalidValueError,
+               MissingValueError => e
+          errors << error_args(filter, e)
         end
       end
 
@@ -28,10 +26,9 @@ module ActiveInteraction
       def error_args(filter, error)
         case error
         when InvalidNestedValueError
-          [filter.name, :invalid_nested,
-           name: error.filter_name.inspect, value: error.input_value.inspect]
+          [filter.name, :invalid_nested, { name: error.filter_name.inspect, value: error.input_value.inspect }]
         when InvalidValueError
-          [filter.name, :invalid_type, type: type(filter)]
+          [filter.name, :invalid_type, { type: type(filter) }]
         when MissingValueError
           [filter.name, :missing]
         end

data/lib/active_interaction/version.rb

@@ -1,10 +1,8 @@
-# coding: utf-8
 # frozen_string_literal: true
 
-#
 module ActiveInteraction
   # The version number.
   #
   # @return [Gem::Version]
-  VERSION = Gem::Version.new('3.8.0')
+  VERSION = Gem::Version.new('4.0.1')
 end

data/spec/active_interaction/base_spec.rb

@@ -1,5 +1,3 @@
-# coding: utf-8
-
 require 'spec_helper'
 require 'action_controller'
 
@@ -24,6 +22,12 @@ InterruptInteraction = Class.new(TestInteraction) do
     class: Object,
     default: nil
 
+  # NOTE: the relative position between this method
+  #   and the compose line should be preserved.
+  def self.composition_location
+    "#{__FILE__}:#{__LINE__ + 4}:in `execute'"
+  end
+
   def execute
     compose(AddInteraction, x: x, y: z)
   end
@@ -51,7 +55,7 @@ describe ActiveInteraction::Base do
     end
 
     context 'with non-hash inputs' do
-      let(:inputs) { [[:k, :v]] }
+      let(:inputs) { [%i[k v]] }
 
       it 'raises an error' do
         expect { interaction }.to raise_error ArgumentError
@@ -371,6 +375,13 @@ describe ActiveInteraction::Base do
         expect(outcome.errors.details)
           .to eql(x: [{ error: :missing }], base: [{ error: 'Y is required' }])
       end
+
+      it 'has the correct backtrace' do
+        described_class.run!(inputs)
+      rescue ActiveInteraction::InvalidInteractionError => e
+        expect(e.backtrace)
+          .to include(InterruptInteraction.composition_location)
+      end
     end
   end
 
@@ -628,32 +639,6 @@ describe ActiveInteraction::Base do
     end
   end
 
-  context 'predicates' do
-    let(:described_class) { InteractionWithFilter }
-
-    it 'responds to the predicate' do
-      expect(interaction.respond_to?(:thing?)).to be_truthy
-    end
-
-    context 'without a value' do
-      it 'returns false' do
-        expect(interaction.thing?).to be_falsey
-      end
-    end
-
-    context 'with a value' do
-      let(:thing) { rand }
-
-      before do
-        inputs[:thing] = thing
-      end
-
-      it 'returns true' do
-        expect(interaction.thing?).to be_truthy
-      end
-    end
-  end
-
   describe '.import_filters' do
     shared_context 'import_filters context' do |only, except|
       let(:klass) { AddInteraction }
@@ -672,9 +657,11 @@ describe ActiveInteraction::Base do
       include_context 'import_filters context', only, except
 
       it 'imports the filters' do
-        expect(described_class.filters).to eql klass.filters
-          .select { |k, _| only.nil? ? true : [*only].include?(k) }
-          .reject { |k, _| except.nil? ? false : [*except].include?(k) }
+        expect(described_class.filters).to eql(
+          klass.filters
+            .select { |k, _| only.nil? ? true : [*only].include?(k) }
+            .reject { |k, _| except.nil? ? false : [*except].include?(k) }
+        )
       end
 
       it 'does not modify the source' do
@@ -683,11 +670,11 @@ describe ActiveInteraction::Base do
         expect(klass.filters).to eql filters
       end
 
-      it 'responds to readers, writers, and predicates' do
+      it 'responds to readers and writers' do
         instance = described_class.new
 
-        described_class.filters.keys.each do |name|
-          [name, "#{name}=", "#{name}?"].each do |method|
+        described_class.filters.each_key do |name|
+          [name, "#{name}="].each do |method|
             expect(instance).to respond_to method
           end
         end

data/spec/active_interaction/concerns/active_modelable_spec.rb

@@ -1,5 +1,3 @@
-# coding: utf-8
-
 require 'spec_helper'
 
 shared_examples_for 'ActiveModel' do

data/spec/active_interaction/concerns/active_recordable_spec.rb

@@ -1,5 +1,3 @@
-# coding: utf-8
-
 require 'spec_helper'
 
 InteractionWithFloatFilter = Class.new(TestInteraction) do

data/spec/active_interaction/concerns/hashable_spec.rb

@@ -1,5 +1,3 @@
-# coding: utf-8
-
 require 'spec_helper'
 
 describe ActiveInteraction::Hashable do

data/spec/active_interaction/concerns/missable_spec.rb

@@ -1,5 +1,3 @@
-# coding: utf-8
-
 require 'spec_helper'
 
 describe ActiveInteraction::Missable do

data/spec/active_interaction/concerns/runnable_spec.rb

@@ -1,11 +1,9 @@
-# coding: utf-8
-
 require 'spec_helper'
 
 describe ActiveInteraction::Runnable do
   include_context 'concerns', ActiveInteraction::Runnable
 
-  class WrappableFailingInteraction
+  class WrappableFailingInteraction # rubocop:disable Lint/ConstantDefinitionInBlock
     include ActiveInteraction::Runnable
 
     def execute
@@ -72,7 +70,7 @@ describe ActiveInteraction::Runnable do
       include_examples 'set_callback examples', :execute
 
       context 'execute with composed interaction' do
-        class WithFailingCompose
+        class WithFailingCompose # rubocop:disable Lint/ConstantDefinitionInBlock
           include ActiveInteraction::Runnable
 
           def execute
@@ -107,11 +105,9 @@ describe ActiveInteraction::Runnable do
           context 'using if' do
             it 'yields errors to the if' do
               has_run = false
-              # rubocop:disable Metrics/LineLength
               WithFailingCompose.set_callback :execute, :after, if: -> { errors.any? } do
                 has_run = true
               end
-              # rubocop:enable Metrics/LineLength
 
               WithFailingCompose.run
               expect(has_run).to be_truthy
@@ -237,10 +233,10 @@ describe ActiveInteraction::Runnable do
     context 'caches the validity and result of the run' do
       let(:klass) do
         Class.new(ActiveInteraction::Base) do
-          INVALID = [false, true].cycle
+          invalid = [false, true].cycle
 
           validate do |interaction|
-            interaction.errors.add(:base, 'failed') unless INVALID.next
+            interaction.errors.add(:base, 'failed') unless invalid.next
           end
 
           def execute
@@ -260,10 +256,10 @@ describe ActiveInteraction::Runnable do
     context 'caches the validity and result of the run' do
       let(:klass) do
         Class.new(ActiveInteraction::Base) do
-          VALID = [true, false].cycle
+          valid = [true, false].cycle
 
           validate do |interaction|
-            interaction.errors.add(:base, 'failed') unless VALID.next
+            interaction.errors.add(:base, 'failed') unless valid.next
           end
 
           def execute
@@ -327,14 +323,14 @@ describe ActiveInteraction::Runnable do
     end
 
     context 'with failing composition' do
-      class CheckInnerForFailure
+      class CheckInnerForFailure # rubocop:disable Lint/ConstantDefinitionInBlock
         include ActiveInteraction::Runnable
 
         attr_reader :caught_error
 
         def execute
           compose(WrappableFailingInteraction)
-        rescue
+        rescue StandardError
           @caught_error = true
           raise
         end
@@ -345,6 +341,24 @@ describe ActiveInteraction::Runnable do
         expect(outcome.caught_error).to be true
       end
     end
+
+    context 'with block not called and error in execute around callback' do
+      class CheckExecuteAroundCallbackForFailure # rubocop:disable Lint/ConstantDefinitionInBlock
+        include ActiveInteraction::ActiveModelable
+        include ActiveInteraction::Runnable
+
+        set_callback :execute, :around, -> { errors.add(:base, 'invalid') }
+
+        def execute
+          true
+        end
+      end
+
+      it 'is invalid' do
+        outcome = CheckExecuteAroundCallbackForFailure.run
+        expect(outcome).to_not be_valid
+      end
+    end
   end
 
   describe '.run!' do