active_interaction 3.7.1 → 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/locale/ja.yml

@@ -0,0 +1,24 @@
+ja:
+  active_interaction:
+    errors:
+      messages:
+        invalid: は無効です
+        invalid_nested: は無効なネストされた値です (%{name} => %{value})
+        invalid_type: は無効な %{type} です
+        missing: が必要です
+    types:
+      array: 配列
+      boolean: ブール
+      date: 日付
+      date_time: 日時
+      decimal: 10進数
+      file: ファイル
+      float: 浮動小数点数
+      hash: ハッシュ
+      integer: 整数
+      interface: インターフェース
+      object: オブジェクト
+      record: レコード
+      string: 文字
+      symbol: シンボル
+      time: 時間

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.
@@ -17,8 +14,14 @@ module ActiveInteraction
       def reserved?(name)
         name.to_s.start_with?('_interaction_') ||
           name == :syscall ||
-          Base.method_defined?(name) ||
-          Base.private_method_defined?(name)
+          (
+            Base.method_defined?(name) &&
+            !Object.method_defined?(name)
+          ) ||
+          (
+            Base.private_method_defined?(name) &&
+            !Object.private_method_defined?(name)
+          )
       end
 
       def process(inputs)

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.7.1')
+  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'
 
@@ -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
 
@@ -505,6 +516,79 @@ describe ActiveInteraction::Base do
         expect(result).to be false
       end
     end
+
+    context 'nested array values' do
+      let(:described_class) do
+        Class.new(TestInteraction) do
+          array :x do
+            hash do
+              boolean :y, default: true
+            end
+          end
+
+          def execute; end
+        end
+      end
+
+      context 'has a positive index' do
+        it 'returns true if found' do
+          described_class.class_exec do
+            def execute
+              given?(:x, 0, :y)
+            end
+          end
+
+          inputs[:x] = [{ y: true }]
+          expect(result).to be true
+        end
+
+        it 'returns false if not found' do
+          described_class.class_exec do
+            def execute
+              given?(:x, 0, :y)
+            end
+          end
+
+          inputs[:x] = []
+          expect(result).to be false
+        end
+      end
+
+      context 'has a negative index' do
+        it 'returns true if found' do
+          described_class.class_exec do
+            def execute
+              given?(:x, -1, :y)
+            end
+          end
+
+          inputs[:x] = [{ y: true }]
+          expect(result).to be true
+        end
+
+        it 'returns false if not found' do
+          described_class.class_exec do
+            def execute
+              given?(:x, -1, :y)
+            end
+          end
+
+          inputs[:x] = []
+          expect(result).to be false
+        end
+      end
+
+      it 'returns false if you go too far' do
+        described_class.class_exec do
+          def execute
+            given?(:x, 10, :y)
+          end
+        end
+
+        inputs[:x] = [{}]
+        expect(result).to be false
+      end
+    end
   end
 
   context 'inheritance' do
@@ -555,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 }
@@ -599,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
@@ -610,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