active_interaction 3.8.2 → 4.0.3

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,120 @@
+# 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
+
+      # @private
+      def keys_for_group?(keys, group_key)
+        search_key = /\A#{group_key}\(\d+i\)\z/
+        keys.any? { |key| search_key.match?(key) }
+      end
+
+      # Checking `syscall` is the result of what appears to be a bug in Ruby.
+      # https://bugs.ruby-lang.org/issues/15597
+      # @private
+      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
+
+      # @param inputs [Hash, ActionController::Parameters, ActiveInteraction::Inputs] Attribute values to set.
+      #
+      # @private
+      def process(inputs)
+        normalize_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 normalize_inputs!(inputs)
+        return inputs if inputs.is_a?(Hash) || inputs.is_a?(Inputs)
+
+        parameters = 'ActionController::Parameters'
+        klass = parameters.safe_constantize
+        return inputs.to_unsafe_h if klass && inputs.is_a?(klass)
+
+        raise ArgumentError, "inputs must be a hash or #{parameters}"
+      end
+
+      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
+    # @private
+    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.
+    # @private
+    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.2')
+  VERSION = Gem::Version.new('4.0.3')
 end

data/spec/active_interaction/base_spec.rb

@@ -1,5 +1,3 @@
-# coding: utf-8
-
 require 'spec_helper'
 require 'action_controller'
 
@@ -48,65 +46,6 @@ describe ActiveInteraction::Base do
       expect(interaction.instance_variable_defined?(:"@#{key}")).to be false
     end
 
-    context 'with invalid inputs' do
-      let(:inputs) { nil }
-
-      it 'raises an error' do
-        expect { interaction }.to raise_error ArgumentError
-      end
-    end
-
-    context 'with non-hash inputs' do
-      let(:inputs) { [[:k, :v]] }
-
-      it 'raises an error' do
-        expect { interaction }.to raise_error ArgumentError
-      end
-    end
-
-    context 'with ActionController::Parameters inputs' do
-      let(:inputs) { ActionController::Parameters.new }
-
-      it 'does not raise an error' do
-        expect { interaction }.to_not raise_error
-      end
-    end
-
-    context 'with a reader' do
-      let(:described_class) do
-        Class.new(TestInteraction) do
-          attr_reader :thing
-
-          validates :thing, presence: true
-        end
-      end
-
-      context 'validation' do
-        context 'failing' do
-          it 'returns an invalid outcome' do
-            expect(interaction).to be_invalid
-          end
-        end
-
-        context 'passing' do
-          before { inputs[:thing] = SecureRandom.hex }
-
-          it 'returns a valid outcome' do
-            expect(interaction).to be_valid
-          end
-        end
-      end
-
-      context 'with a single input' do
-        let(:thing) { SecureRandom.hex }
-        before { inputs[:thing] = thing }
-
-        it 'sets the attribute' do
-          expect(interaction.thing).to eql thing
-        end
-      end
-    end
-
     context 'with a filter' do
       let(:described_class) { InteractionWithFilter }
 
@@ -379,12 +318,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
@@ -593,6 +530,32 @@ describe ActiveInteraction::Base do
         expect(result).to be false
       end
     end
+
+    context 'multi-part date values' do
+      let(:described_class) do
+        Class.new(TestInteraction) do
+          date :thing,
+            default: nil
+
+          def execute
+            given?(:thing)
+          end
+        end
+      end
+
+      it 'returns true when the input is given' do
+        inputs.merge!(
+          'thing(1i)' => '2020',
+          'thing(2i)' => '12',
+          'thing(3i)' => '31'
+        )
+        expect(result).to be true
+      end
+
+      it 'returns false if not found' do
+        expect(result).to be false
+      end
+    end
   end
 
   context 'inheritance' do
@@ -643,32 +606,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 +624,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 +637,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