active_interaction 1.6.1 → 2.0.0

data/lib/active_interaction/errors.rb

@@ -89,89 +89,20 @@ module ActiveInteraction
   end
   private_constant :Interrupt
 
-  # An extension that provides symbolic error messages to make introspection
-  #   and testing easier.
+  # An extension that provides the ability to merge other errors into itself.
   class Errors < ActiveModel::Errors
-    # Maps attributes to arrays of symbolic messages.
-    #
-    # @return [Hash{Symbol => Array<Symbol>}]
-    attr_reader :symbolic
-    ActiveInteraction.deprecate self, :symbolic, 'use `details` instead'
-
-    def details
-      h = Hash.new([]).with_indifferent_access
-      @symbolic.each { |k, vs| vs.each { |v| h[k] += [{ error: v }] } }
-      h
-    end
-
-    alias_method :add_without_details, :add
-    def add_with_details(attribute, message = :invalid, options = {})
-      message = message.call if message.respond_to?(:call)
-      @symbolic[attribute] += [message] if message.is_a?(Symbol)
-      add_without_details(attribute, message, options)
-    end
-    alias_method :add, :add_with_details
-
-    # Adds a symbolic error message to an attribute.
-    #
-    # @example
-    #   errors.add_sym(:attribute)
-    #   errors.details
-    #   # => {:attribute=>[{:error=>:invalid}]}
-    #   errors.messages
-    #   # => {:attribute=>["is invalid"]}
-    #
-    # @param attribute [Symbol] The attribute to add an error to.
-    # @param symbol [Symbol, nil] The symbolic error to add.
-    # @param message [String, Symbol, Proc, nil] The message to add.
-    # @param options [Hash]
-    #
-    # @return (see #symbolic)
-    #
-    # @see ActiveModel::Errors#add
-    def add_sym(attribute, symbol = :invalid, message = nil, options = {})
-      add_without_details(attribute, message || symbol, options)
-
-      @symbolic[attribute] += [symbol]
-    end
-    ActiveInteraction.deprecate self, :add_sym, 'use `add` instead'
-
-    # @see ActiveModel::Errors#initialize
-    #
-    # @private
-    def initialize(*)
-      @symbolic = Hash.new([]).with_indifferent_access
-
-      super
-    end
-
-    # @see ActiveModel::Errors#initialize_dup
-    #
-    # @private
-    def initialize_dup(other)
-      @symbolic = Hash.new([]).with_indifferent_access
-      other.details.each { |k, vs| vs.each { |v| @symbolic[k] += [v[:error]] } }
-
-      super
-    end
-
-    # @see ActiveModel::Errors#clear
-    #
-    # @private
-    def clear
-      @symbolic.clear
-
-      super
-    end
-
     # Merge other errors into this one.
     #
     # @param other [Errors]
     #
     # @return [Errors]
     def merge!(other)
-      merge_messages!(other)
-      merge_details!(other) if other.respond_to?(:details)
+      if other.respond_to?(:details)
+        merge_details!(other)
+      else
+        merge_messages!(other)
+      end
+
       self
     end
 
@@ -186,12 +117,11 @@ module ActiveInteraction
     end
 
     def merge_details!(other)
-      other.details.each do |attribute, hashes|
-        hashes.each do |hash|
-          error = hash[:error]
-          next if @symbolic[attribute].include?(error)
-
-          @symbolic[attribute] += [error]
+      other.details.each do |attribute, details|
+        details.each do |detail|
+          detail = detail.dup
+          error = detail.delete(:error)
+          add(attribute, error, detail) unless added?(attribute, error, detail)
         end
       end
     end

data/lib/active_interaction/filters/array_filter.rb

@@ -64,16 +64,10 @@ module ActiveInteraction
     # @return [Array<Class>]
     def classes
       result = [Array]
+      return result unless Object.const_defined?(:ActiveRecord)
+      return result unless ActiveRecord.const_defined?(:Relation)
 
-      %w[
-        ActiveRecord::Relation
-        ActiveRecord::Associations::CollectionProxy
-      ].each do |name|
-        next unless (klass = name.safe_constantize)
-        result.push(klass)
-      end
-
-      result
+      result.push(ActiveRecord::Relation)
     end
 
     # @param filter [Filter]

data/lib/active_interaction/filters/file_filter.rb

@@ -4,9 +4,8 @@ module ActiveInteraction
   class Base
     # @!method self.file(*attributes, options = {})
     #   Creates accessors for the attributes and ensures that values passed to
-    #     the attributes are Files or Tempfiles. It will also extract a file
-    #     from any object with a `tempfile` method. This is useful when passing
-    #     in Rails params that include a file upload.
+    #   the attributes respond to the `eof?` method. This is useful when passing
+    #   in Rails params that include a file upload or another generic IO object.
     #
     #   @!macro filter_method_params
     #
@@ -15,35 +14,17 @@ module ActiveInteraction
   end
 
   # @private
-  class FileFilter < Filter
+  class FileFilter < InterfaceFilter
     register :file
 
-    def cast(value)
-      value = extract_file(value)
-
-      case value
-      when File, Tempfile
-        value
-      else
-        super
-      end
-    end
-
     def database_column_type
       self.class.slug
     end
 
     private
 
-    # @param value [File, #tempfile]
-    #
-    # @return [File]
-    def extract_file(value)
-      if value.respond_to?(:tempfile)
-        value.tempfile
-      else
-        value
-      end
+    def methods
+      [:eof?]
     end
   end
 end

data/lib/active_interaction/filters/hash_filter.rb

@@ -8,17 +8,13 @@ module ActiveInteraction
     #
     #   @!macro filter_method_params
     #   @param block [Proc] filter methods to apply for select keys
-    #   @option options [Boolean] :strip (true) strip unknown keys (Note: All
-    #     keys are symbolized. Ruby does not GC symbols so this can cause
-    #     memory bloat. Setting this option to `false` and passing in non-safe
-    #     input (e.g. Rails `params`) opens your software to a denial of
-    #     service attack.)
+    #   @option options [Boolean] :strip (true) remove unknown keys
     #
     #   @example
     #     hash :order
     #   @example
     #     hash :order do
-    #       model :item
+    #       object :item
     #       integer :quantity, default: 1
     #     end
   end
@@ -32,11 +28,12 @@ module ActiveInteraction
     def cast(value)
       case value
       when Hash
-        value = stringify_the_symbol_keys(value)
+        value = value.with_indifferent_access
+        initial = strip? ? ActiveSupport::HashWithIndifferentAccess.new : value
 
-        filters.each_with_object(strip? ? {} : value) do |(name, filter), h|
+        filters.each_with_object(initial) do |(name, filter), h|
           clean_value(h, name.to_s, filter, value)
-        end.symbolize_keys
+        end
       else
         super
       end
@@ -79,9 +76,5 @@ module ActiveInteraction
     def strip?
       options.fetch(:strip, true)
     end
-
-    def stringify_the_symbol_keys(hash)
-      self.class.transform_keys(hash) { |k| k.is_a?(Symbol) ? k.to_s : k }
-    end
   end
 end

data/lib/active_interaction/filters/interface_filter.rb

@@ -7,8 +7,8 @@ module ActiveInteraction
     #   the attributes implement an interface.
     #
     #   @!macro filter_method_params
-    #   @option options [Array<Symbol>] :methods ([]) the methods that objects
-    #     conforming to this interface should respond to
+    #   @option options [Array<String,Symbol>] :methods ([]) the methods that
+    #     objects conforming to this interface should respond to
     #
     #   @example
     #     interface :anything

data/lib/active_interaction/filters/{model_filter.rb → object_filter.rb}

@@ -2,7 +2,7 @@
 
 module ActiveInteraction
   class Base
-    # @!method self.model(*attributes, options = {})
+    # @!method self.object(*attributes, options = {})
     #   Creates accessors for the attributes and ensures that values passed to
     #     the attributes are the correct class.
     #
@@ -11,14 +11,13 @@ module ActiveInteraction
     #     Class name used to ensure the value.
     #
     #   @example
-    #     model :account
+    #     object :account
     #   @example
-    #     model :account, class: User
+    #     object :account, class: User
   end
 
   # @private
-  class ModelFilter < Filter
-    register :model
+  class ObjectFilter < Filter
     register :object
 
     def cast(value, reconstantize = true)

data/lib/active_interaction/locale/en.yml

@@ -17,7 +17,6 @@ en:
       hash: hash
       integer: integer
       interface: interface
-      model: model
       object: object
       string: string
       symbol: symbol

data/lib/active_interaction/version.rb

@@ -5,5 +5,5 @@ module ActiveInteraction
   # The version number.
   #
   # @return [Gem::Version]
-  VERSION = Gem::Version.new('1.6.1')
+  VERSION = Gem::Version.new('2.0.0')
 end

data/spec/active_interaction/base_spec.rb

@@ -19,7 +19,7 @@ AddInteraction = Class.new(TestInteraction) do
 end
 
 InterruptInteraction = Class.new(TestInteraction) do
-  model :x, :y,
+  object :x, :y,
     class: Object,
     default: nil
 
@@ -248,8 +248,9 @@ describe ActiveInteraction::Base do
           before do
             @execute = described_class.instance_method(:execute)
             described_class.send(:define_method, :execute) do
-              errors.add(:thing, 'error')
-              errors.add_sym(:thing, :error, 'error')
+              errors.add(:thing, 'is invalid')
+              errors.add(:thing, :invalid)
+              true
             end
           end
 
@@ -263,16 +264,22 @@ describe ActiveInteraction::Base do
             expect(outcome).to be_invalid
           end
 
-          it 'sets the result to nil' do
-            expect(result).to be_nil
+          it 'sets the result' do
+            expect(result).to be true
           end
 
           it 'has errors' do
-            expect(outcome.errors.messages[:thing]).to eql %w[error error]
+            expect(outcome.errors.messages[:thing]).to eql [
+              'is invalid',
+              'is invalid'
+            ]
           end
 
-          it 'has symbolic errors' do
-            expect(outcome.errors.symbolic[:thing]).to eql [:error]
+          it 'has detailed errors' do
+            expect(outcome.errors.details[:thing]).to eql [
+              { error: 'is invalid' },
+              { error: :invalid }
+            ]
           end
         end
 
@@ -283,12 +290,6 @@ describe ActiveInteraction::Base do
         it 'sets the result' do
           expect(result[:thing]).to eql thing
         end
-
-        it 'calls #transaction' do
-          expect_any_instance_of(described_class).to receive(:transaction)
-            .once.with(no_args)
-          outcome
-        end
       end
     end
 

data/spec/active_interaction/concerns/runnable_spec.rb

@@ -101,9 +101,9 @@ describe ActiveInteraction::Runnable do
     context 'with an error' do
       include_context 'with an error'
 
-      it 'does not set the result' do
+      it 'sets the result' do
         instance.result = result
-        expect(instance.result).to be_nil
+        expect(instance.result).to eql result
       end
     end
 
@@ -180,38 +180,6 @@ describe ActiveInteraction::Runnable do
       end
     end
 
-    context 'with an execute where composition fails' do
-      before do
-        interaction = Class.new(TestInteraction) do
-          validate { errors.add(:base) }
-        end
-
-        klass.send(:define_method, :execute) { compose(interaction) }
-      end
-
-      it 'rolls back the transaction' do
-        instance = klass.new
-
-        allow(instance).to receive(:raise)
-        instance.send(:run)
-        expect(instance).to have_received(:raise)
-          .with(ActiveRecord::Rollback)
-      end
-
-      context 'without a transaction' do
-        before { klass.transaction(false) }
-
-        it 'does not roll back' do
-          instance = klass.new
-
-          allow(instance).to receive(:raise)
-          instance.send(:run)
-          expect(instance).to_not have_received(:raise)
-            .with(ActiveRecord::Rollback)
-        end
-      end
-    end
-
     context 'with invalid post-execution state' do
       before do
         klass.class_exec do

data/spec/active_interaction/errors_spec.rb

@@ -17,88 +17,6 @@ describe ActiveInteraction::Errors do
 
   subject(:errors) { described_class.new(klass.new) }
 
-  describe '#add_sym' do
-    it 'defaults to :invalid' do
-      errors.add_sym(:attribute)
-      expect(errors.symbolic[:attribute]).to eql [:invalid]
-    end
-
-    it 'adds a symbol' do
-      errors.add_sym(:attribute, :symbol)
-      expect(errors.symbolic[:attribute]).to eql [:symbol]
-    end
-
-    it 'accepts a message' do
-      errors.add_sym(:attribute, :symbol, 'message')
-      expect(errors.symbolic[:attribute]).to eql [:symbol]
-    end
-
-    it 'accepts a message and options' do
-      errors.add_sym(:attribute, :symbol, 'message', key: :value)
-      expect(errors.symbolic[:attribute]).to eql [:symbol]
-    end
-
-    context 'calling #add' do
-      before do
-        allow(errors).to receive(:add_without_details)
-      end
-
-      it 'with the default' do
-        errors.add_sym(:attribute)
-        expect(errors).to have_received(:add_without_details).once
-          .with(:attribute, :invalid, {})
-      end
-
-      it 'with a symbol' do
-        errors.add_sym(:attribute, :symbol)
-        expect(errors).to have_received(:add_without_details).once
-          .with(:attribute, :symbol, {})
-      end
-
-      it 'with a symbol and message' do
-        errors.add_sym(:attribute, :symbol, 'message')
-        expect(errors).to have_received(:add_without_details).once
-          .with(:attribute, 'message', {})
-      end
-
-      it 'with a symbol, message and options' do
-        errors.add_sym(:attribute, :symbol, 'message', key: :value)
-        expect(errors).to have_received(:add_without_details).once
-          .with(:attribute, 'message', key: :value)
-      end
-    end
-  end
-
-  describe '#initialize' do
-    it 'sets symbolic to an empty hash' do
-      expect(errors.symbolic).to eql({})
-    end
-  end
-
-  describe '#initialize_dup' do
-    let(:errors_dup) { errors.dup }
-
-    before do
-      errors.add_sym(:attribute)
-    end
-
-    it 'dups symbolic' do
-      expect(errors_dup.symbolic).to eql errors.symbolic
-      expect(errors_dup.symbolic).to_not equal errors.symbolic
-    end
-  end
-
-  describe '#clear' do
-    before do
-      errors.add_sym(:attribute)
-    end
-
-    it 'clears symbolic' do
-      errors.clear
-      expect(errors.symbolic).to be_empty
-    end
-  end
-
   describe '#merge!' do
     let(:other) { described_class.new(klass.new) }
 
@@ -119,18 +37,18 @@ describe ActiveInteraction::Errors do
       end
     end
 
-    context 'with a symbolic error' do
+    context 'with a detailed error' do
       before do
-        other.add_sym(:attribute)
+        other.add(:attribute)
       end
 
       it 'adds the error' do
         errors.merge!(other)
-        expect(errors.symbolic[:attribute]).to eql [:invalid]
+        expect(errors.details[:attribute]).to eql [{ error: :invalid }]
       end
     end
 
-    context 'with an interpolated symbolic error' do
+    context 'with an interpolated detailed error' do
       before do
         I18n.backend.store_translations('en',
           activemodel: {
@@ -147,7 +65,7 @@ describe ActiveInteraction::Errors do
             }
           })
 
-        other.add_sym(:attribute, :invalid_type, type: nil)
+        other.add(:attribute, :invalid_type, type: nil)
       end
 
       it 'does not raise an error' do