active_interaction 0.5.0 → 0.6.1

data/lib/active_interaction/filters/time_filter.rb

@@ -6,41 +6,63 @@ module ActiveInteraction
     #   in which case they will be processed with `strptime`. If `Time.zone` is
     #   available it will be used so that the values are time zone aware.
     #
-    # @macro attribute_method_params
-    # @option options [String] :format Parse strings using this format string.
+    # @macro filter_method_params
+    # @option options [String] :format parse strings using this format string
     #
     # @example
     #   time :start_date
     #
     # @example
-    #   date_time :start_date, format: '%Y-%m-%dT%H:%M:%S'
+    #   date_time :start_date, format: '%Y-%m-%dT%H:%M:%S%z'
+    #
+    # @since 0.1.0
     #
     # @method self.time(*attributes, options = {})
   end
 
   # @private
-  class TimeFilter < AbstractDateTimeFilter
-    def self.prepare(key, value, options = {}, &block)
+  class TimeFilter < Filter
+    def cast(value)
       case value
-        when Numeric
-          time.at(value)
-        else
-          super(key, value, options.merge(class: time_class), &block)
+      when klass
+        value
+      when Numeric
+        time.at(value)
+      when String
+        begin
+          if has_format?
+            klass.strptime(value, format)
+          else
+            klass.parse(value)
+          end
+        rescue ArgumentError
+          super
+        end
+      else
+        super
       end
     end
 
-    def self.time
+    private
+
+    def format
+      options.fetch(:format)
+    end
+
+    def has_format?
+      options.has_key?(:format)
+    end
+
+    def klass
+      time.at(0).class
+    end
+
+    def time
       if Time.respond_to?(:zone) && !Time.zone.nil?
         Time.zone
       else
         Time
       end
     end
-    private_class_method :time
-
-    def self.time_class
-      time.at(0).class
-    end
-    private_class_method :time_class
   end
 end

data/lib/active_interaction/method_missing.rb

@@ -0,0 +1,18 @@
+module ActiveInteraction
+  # @private
+  module MethodMissing
+    def method_missing(slug, *args, &block)
+      begin
+        klass = Filter.factory(slug)
+      rescue MissingFilterError
+        super
+      end
+
+      options = args.last.is_a?(Hash) ? args.pop : {}
+
+      yield(klass, args, options) if block_given?
+
+      self
+    end
+  end
+end

data/lib/active_interaction/overload_hash.rb

@@ -1,4 +1,5 @@
 module ActiveInteraction
+  # @private
   module OverloadHash
     def hash(*args, &block)
       if args.empty? && !block_given?

data/lib/active_interaction/validation.rb

@@ -0,0 +1,19 @@
+module ActiveInteraction
+  # @private
+  module Validation
+    def self.validate(filters, inputs)
+      filters.reduce([]) do |errors, filter|
+        begin
+          filter.cast(inputs[filter.name])
+
+          errors
+        rescue InvalidValueError
+          type = I18n.translate("#{Base.i18n_scope}.types.#{filter.class.slug}")
+          errors << [filter.name, :invalid, nil, type: type]
+        rescue MissingValueError
+          errors << [filter.name, :missing]
+        end
+      end
+    end
+  end
+end

data/lib/active_interaction/version.rb

@@ -1,3 +1,3 @@
 module ActiveInteraction
-  VERSION = Gem::Version.new('0.5.0')
+  VERSION = Gem::Version.new('0.6.1')
 end

data/spec/active_interaction/active_model_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe ActiveInteraction::ActiveModel do
+  subject(:model) do
+    Class.new do
+      include ActiveInteraction::ActiveModel
+    end
+  end
+
+  describe '#new_record?' do
+    it 'returns true' do
+      expect(model.new).to be_new_record
+    end
+  end
+
+  describe '#persisted?' do
+    it 'returns false' do
+      expect(model.new).to_not be_persisted
+    end
+  end
+
+  describe '.i18n_scope' do
+    it 'returns the scope' do
+      expect(model.i18n_scope).to eq :active_interaction
+    end
+  end
+
+  describe '#i18n_scope' do
+    it 'returns the scope' do
+      expect(model.new.i18n_scope).to eq :active_interaction
+    end
+  end
+end

data/spec/active_interaction/base_spec.rb

@@ -1,7 +1,8 @@
 require 'spec_helper'
 
 describe ActiveInteraction::Base do
-  let(:options) { {} }
+  include_context 'interactions'
+
   subject(:interaction) { described_class.new(options) }
 
   class InteractionWithFilter < described_class
@@ -13,27 +14,29 @@ describe ActiveInteraction::Base do
   end
 
   describe '.new(options = {})' do
-    it 'does not allow :result as an option' do
-      options.merge!(result: nil)
-      expect { interaction }.to raise_error ArgumentError
+    it 'does not allow :_interaction_* as an option' do
+      key = :"_interaction_#{SecureRandom.hex}"
+      options.merge!(key => nil)
+      expect {
+        interaction
+      }.to raise_error ActiveInteraction::InvalidValueError
     end
 
-    it 'does not allow "result" as an option' do
-      options.merge!('result' => nil)
-      expect { interaction }.to raise_error ArgumentError
+    it 'does not allow "_interaction_*" as an option' do
+      key = "_interaction_#{SecureRandom.hex}"
+      options.merge!(key => nil)
+      expect {
+        interaction
+      }.to raise_error ActiveInteraction::InvalidValueError
     end
 
     context 'with an attribute' do
       let(:described_class) do
-        Class.new(ActiveInteraction::Base) do
+        Class.new(TestInteraction) do
           attr_reader :thing
 
           validates :thing, presence: true
 
-          def self.name
-            SecureRandom.hex
-          end
-
           def execute
             thing
           end
@@ -104,6 +107,14 @@ describe ActiveInteraction::Base do
       }.to raise_error NoMethodError
     end
 
+    it do
+      expect do
+        Class.new(described_class) do
+          float :_interaction_thing
+        end
+      end.to raise_error ActiveInteraction::InvalidFilterError
+    end
+
     context 'with a filter' do
       let(:described_class) { InteractionWithFilter }
 
@@ -142,41 +153,35 @@ describe ActiveInteraction::Base do
     let(:thing) { rand }
 
     describe '.run(options = {})' do
-      subject(:outcome) { described_class.run(options) }
-
       it "returns an instance of #{described_class}" do
         expect(outcome).to be_a described_class
       end
 
       context 'setting the result' do
         let(:described_class) do
-          Class.new(ActiveInteraction::Base) do
+          Class.new(TestInteraction) do
             boolean :attribute
 
             validate do
               @_interaction_result = SecureRandom.hex
               errors.add(:attribute, SecureRandom.hex)
             end
-
-            def self.name
-              SecureRandom.hex
-            end
           end
         end
 
         it 'sets the result to nil' do
           expect(outcome).to be_invalid
-          expect(outcome.result).to be_nil
+          expect(result).to be_nil
         end
       end
 
       context 'failing validations' do
         it 'returns an invalid outcome' do
-          expect(outcome).to be_invalid
+          expect(outcome).to_not be_valid
         end
 
         it 'sets the result to nil' do
-          expect(outcome.result).to be_nil
+          expect(result).to be_nil
         end
       end
 
@@ -187,12 +192,15 @@ describe ActiveInteraction::Base do
           before do
             @execute = described_class.instance_method(:execute)
             described_class.send(:define_method, :execute) do
-              errors.add(:thing, SecureRandom.hex)
+              errors.add(:thing, 'error')
+              errors.add_sym(:thing, :error, 'error')
             end
           end
 
           after do
-            described_class.send(:define_method, :execute, @execute)
+            silence_warnings do
+              described_class.send(:define_method, :execute, @execute)
+            end
           end
 
           it 'returns an invalid outcome' do
@@ -200,7 +208,15 @@ describe ActiveInteraction::Base do
           end
 
           it 'sets the result to nil' do
-            expect(outcome.result).to be_nil
+            expect(result).to be_nil
+          end
+
+          it 'has errors' do
+            expect(outcome.errors.messages[:thing]).to eq %w(error error)
+          end
+
+          it 'has symbolic errors' do
+            expect(outcome.errors.symbolic[:thing]).to eq [:error]
           end
         end
 
@@ -209,7 +225,7 @@ describe ActiveInteraction::Base do
         end
 
         it 'sets the result' do
-          expect(outcome.result).to eq thing
+          expect(result).to eq thing
         end
 
         it 'calls transaction' do
@@ -246,7 +262,7 @@ describe ActiveInteraction::Base do
         it 'raises an error' do
           expect {
             result
-          }.to raise_error ActiveInteraction::InteractionInvalid
+          }.to raise_error ActiveInteraction::InteractionInvalidError
         end
       end
 
@@ -260,33 +276,23 @@ describe ActiveInteraction::Base do
     end
   end
 
-  describe '#execute' do
-    it 'raises an error' do
-      expect { interaction.execute }.to raise_error NotImplementedError
-    end
-  end
-
-  describe '#new_record?' do
-    it 'returns true' do
-      expect(interaction).to be_new_record
-    end
-  end
+  describe '#inputs' do
+    let(:described_class) { InteractionWithFilter }
+    let(:other_val) { SecureRandom.hex }
+    let(:options) { {thing: 1, other: other_val} }
 
-  describe '#persisted?' do
-    it 'returns false' do
-      expect(interaction).to_not be_persisted
+    it 'casts filtered inputs' do
+      expect(interaction.inputs[:thing]).to eql 1.0
     end
-  end
 
-  describe '.i18n_scope' do
-    it 'returns the scope' do
-      expect(described_class.i18n_scope).to eq :active_interaction
+    it 'strips non-filtered inputs' do
+      expect(interaction.inputs).to_not have_key(:other)
     end
   end
 
-  describe '#i18n_scope' do
-    it 'returns the scope' do
-      expect(interaction.i18n_scope).to eq :active_interaction
+  describe '#execute' do
+    it 'raises an error' do
+      expect { interaction.execute }.to raise_error NotImplementedError
     end
   end
 end

data/spec/active_interaction/errors_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe ActiveInteraction::Errors do
+  let(:klass) do
+    Class.new do
+      include ActiveModel::Model
+
+      attr_reader :attribute
+
+      def self.name
+        SecureRandom.hex
+      end
+    end
+  end
+
+  subject(:errors) { described_class.new(klass.new) }
+
+  describe '#add_sym' do
+    it 'defaults to :invalid' do
+      errors.add_sym(:attribute)
+      expect(errors.symbolic).to eq({ attribute: [:invalid] })
+    end
+
+    it 'adds a symbol' do
+      errors.add_sym(:attribute, :symbol)
+      expect(errors.symbolic).to eq({ attribute: [:symbol] })
+    end
+
+    it 'accepts a message' do
+      errors.add_sym(:attribute, :symbol, 'message')
+      expect(errors.symbolic).to eq({ attribute: [:symbol] })
+    end
+
+    it 'accepts a message and options' do
+      errors.add_sym(:attribute, :symbol, 'message', { key: :value })
+      expect(errors.symbolic).to eq({ attribute: [:symbol] })
+    end
+
+    context 'calling #add' do
+      before do
+        allow(errors).to receive(:add)
+      end
+
+      it 'with the default' do
+        errors.add_sym(:attribute)
+        expect(errors).to have_received(:add).once.
+          with(:attribute, :invalid, {})
+      end
+
+      it 'with a symbol' do
+        errors.add_sym(:attribute, :symbol)
+        expect(errors).to have_received(:add).once.
+          with(:attribute, :symbol, {})
+      end
+
+      it 'with a symbol and message' do
+        errors.add_sym(:attribute, :symbol, 'message')
+        expect(errors).to have_received(:add).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).once.
+          with(:attribute, 'message', { key: :value })
+      end
+    end
+  end
+
+  describe '#initialize' do
+    it 'sets symbolic to an empty hash' do
+      expect(errors.symbolic).to eq({})
+    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 eq 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
+end