active_interaction 3.8.3 → 4.0.0

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,42 +23,40 @@ 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 klass
-      if Time.respond_to?(:zone) && !Time.zone.nil?
-        Time.zone
+    def time_with_zone?
+      Time.respond_to?(:zone) && !Time.zone.nil?
+    end
+
+    def klasses
+      if time_with_zone?
+        super + [Time.zone.class]
       else
         super
       end
     end
 
-    def klasses
-      [_klass, klass.at(0).class]
+    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,89 @@
+# 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) ||
+          Base.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/input_processor.rb

@@ -1,15 +1,12 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 module ActiveInteraction
   # Groups inputs ending in "(*N*i)" into {GroupedInput}.
   #
-  # @since 1.2.0
-  #
   # @private
   module InputProcessor
     class << self
-      GROUPED_INPUT_PATTERN = /\A(.+)\((\d+)i\)\z/
+      GROUPED_INPUT_PATTERN = /\A(.+)\((\d+)i\)\z/.freeze
       private_constant :GROUPED_INPUT_PATTERN
 
       # Checking `syscall` is the result of what appears to be a bug in Ruby.

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.3')
+  VERSION = Gem::Version.new('4.0.0')
 end

data/spec/active_interaction/base_spec.rb

@@ -1,5 +1,3 @@
-# coding: utf-8
-
 require 'spec_helper'
 require 'action_controller'
 
@@ -57,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
@@ -379,12 +377,10 @@ describe ActiveInteraction::Base do
       end
 
       it 'has the correct backtrace' do
-        begin
-          described_class.run!(inputs)
-        rescue ActiveInteraction::InvalidInteractionError => e
-          expect(e.backtrace)
-            .to include(InterruptInteraction.composition_location)
-        end
+        described_class.run!(inputs)
+      rescue ActiveInteraction::InvalidInteractionError => e
+        expect(e.backtrace)
+          .to include(InterruptInteraction.composition_location)
       end
     end
   end
@@ -643,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 }
@@ -687,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
@@ -698,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
@@ -27,7 +25,7 @@ describe ActiveInteraction::Hashable do
       end
 
       context 'with a block' do
-        let(:block) { proc {} }
+        let(:block) { proc {} } # rubocop:disable Lint/EmptyBlock
         let(:hash) { subject.hash(*arguments, &block) }
 
         it 'calls method_missing' 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
@@ -347,7 +343,7 @@ describe ActiveInteraction::Runnable do
     end
 
     context 'with block not called and error in execute around callback' do
-      class CheckExecuteAroundCallbackForFailure
+      class CheckExecuteAroundCallbackForFailure # rubocop:disable Lint/ConstantDefinitionInBlock
         include ActiveInteraction::ActiveModelable
         include ActiveInteraction::Runnable