active_interaction 1.1.7 → 1.2.0

data/lib/active_interaction/filters/abstract_filter.rb

@@ -8,14 +8,11 @@ module ActiveInteraction
   #
   # @private
   class AbstractFilter < Filter
-    # @return [Class]
-    attr_reader :klass
-    private :klass
-
-    def initialize(*)
-      super
+    private
 
-      @klass = self.class.slug.to_s.camelize.constantize
+    # @return [Class]
+    def klass
+      @klass ||= self.class.slug.to_s.camelize.constantize
     end
   end
 end

data/lib/active_interaction/filters/abstract_numeric_filter.rb

@@ -21,6 +21,10 @@ module ActiveInteraction
       end
     end
 
+    def database_column_type
+      self.class.slug
+    end
+
     private
 
     def convert(value)

data/lib/active_interaction/filters/boolean_filter.rb

@@ -26,5 +26,9 @@ module ActiveInteraction
         super
       end
     end
+
+    def database_column_type
+      self.class.slug
+    end
   end
 end

data/lib/active_interaction/filters/date_time_filter.rb

@@ -19,5 +19,8 @@ module ActiveInteraction
 
   # @private
   class DateTimeFilter < AbstractDateTimeFilter
+    def database_column_type
+      :datetime
+    end
   end
 end

data/lib/active_interaction/filters/decimal_filter.rb

@@ -0,0 +1,54 @@
+# coding: utf-8
+
+module ActiveInteraction
+  class Base
+    # @!method self.decimal(*attributes, options = {})
+    #   Creates accessors for the attributes and ensures that values passed to
+    #     the attributes are BigDecimals. Numerics and String values are
+    #     converted into BigDecimals.
+    #
+    #   @!macro filter_method_params
+    #
+    #   @example
+    #     decimal :amount, digits: 4
+    #
+    #   @since 1.2.0
+  end
+
+  # @private
+  class DecimalFilter < AbstractNumericFilter
+    def cast(value)
+      case value
+      when Numeric
+        BigDecimal.new(value, digits)
+      when String
+        decimal_from_string(value)
+      else
+        super
+      end
+    end
+
+    private
+
+    # @return [Integer]
+    def digits
+      options.fetch(:digits, 0)
+    end
+
+    # @param value [String] string that has to be converted
+    #
+    # @return [BigDecimal]
+    #
+    # @raise [InvalidValueError] if given value can not be converted
+    def decimal_from_string(value)
+      Float(value)
+      BigDecimal.new(value, digits)
+    rescue ArgumentError
+       raise InvalidValueError, "Given value: #{value.inspect}"
+    end
+
+    def klass
+      BigDecimal
+    end
+  end
+end

data/lib/active_interaction/filters/file_filter.rb

@@ -27,6 +27,10 @@ module ActiveInteraction
       end
     end
 
+    def database_column_type
+      self.class.slug
+    end
+
     private
 
     # @param value [File, #tempfile]

data/lib/active_interaction/filters/time_filter.rb

@@ -33,6 +33,10 @@ module ActiveInteraction
       end
     end
 
+    def database_column_type
+      :datetime
+    end
+
     private
 
     def klass

data/lib/active_interaction/grouped_input.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+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
+    unless method_defined?(:[])
+      def [](name)
+        send(name)
+      end
+    end
+
+    unless method_defined?(:[]=)
+      def []=(name, value)
+        send("#{name}=", value)
+      end
+    end
+  end
+end

data/lib/active_interaction/locale/en.yml

@@ -11,6 +11,7 @@ en:
       boolean: boolean
       date: date
       date_time: date time
+      decimal: decimal
       file: file
       float: float
       hash: hash

data/lib/active_interaction/modules/input_processor.rb

@@ -0,0 +1,40 @@
+# coding: utf-8
+
+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/
+      private_constant :GROUPED_INPUT_PATTERN
+
+      def reserved?(name)
+        name.to_s.start_with?('_interaction_')
+      end
+
+      def process(inputs)
+        inputs.stringify_keys.sort.each_with_object({}) do |(k, v), h|
+          fail ReservedNameError, k.inspect if reserved?(k)
+
+          if (match = GROUPED_INPUT_PATTERN.match(k))
+            assign_to_group!(h, *match.captures, v)
+          else
+            h[k.to_sym] = v
+          end
+        end
+      end
+
+      private
+
+      def assign_to_group!(inputs, key, index, value)
+        key = key.to_sym
+
+        inputs[key] = GroupedInput.new unless inputs[key].is_a?(GroupedInput)
+        inputs[key][index] = value
+      end
+    end
+  end
+end

data/lib/active_interaction/version.rb

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

data/spec/active_interaction/base_spec.rb

@@ -6,6 +6,10 @@ InteractionWithFilter = Class.new(TestInteraction) do
   float :thing
 end
 
+InteractionWithDateFilter = Class.new(TestInteraction) do
+  date :thing
+end
+
 AddInteraction = Class.new(TestInteraction) do
   float :x, :y
 
@@ -62,59 +66,92 @@ describe ActiveInteraction::Base do
           validates :thing, presence: true
         end
       end
-      let(:thing) { SecureRandom.hex }
-
-      before { inputs.merge!(thing: thing) }
 
-      it 'sets the attribute' do
-        expect(interaction.thing).to eql thing
-      end
+      context 'validation' do
+        context 'failing' do
+          it 'returns an invalid outcome' do
+            expect(interaction).to be_invalid
+          end
+        end
 
-      context 'failing validations' do
-        before { inputs.merge!(thing: nil) }
+        context 'passing' do
+          before { inputs.merge!(thing: SecureRandom.hex) }
 
-        it 'returns an invalid outcome' do
-          expect(interaction).to be_invalid
+          it 'returns a valid outcome' do
+            expect(interaction).to be_valid
+          end
         end
       end
 
-      context 'passing validations' do
-        it 'returns a valid outcome' do
-          expect(interaction).to be_valid
+      context 'with a single input' do
+        let(:thing) { SecureRandom.hex }
+        before { inputs.merge!(thing: thing) }
+
+        it 'sets the attribute' do
+          expect(interaction.thing).to eql thing
         end
       end
     end
 
-    describe 'with a filter' do
+    context 'with a filter' do
       let(:described_class) { InteractionWithFilter }
 
-      context 'failing validations' do
-        before { inputs.merge!(thing: thing) }
+      context 'validation' do
+        context 'failing' do
+          before { inputs.merge!(thing: thing) }
+
+          context 'with an invalid value' do
+            let(:thing) { 'a' }
+
+            it 'sets the attribute to the filtered value' do
+              expect(interaction.thing).to equal thing
+            end
+          end
 
-        context 'with an invalid value' do
-          let(:thing) { 'a' }
+          context 'without a value' do
+            let(:thing) { nil }
 
-          it 'sets the attribute to the filtered value' do
-            expect(interaction.thing).to equal thing
+            it 'sets the attribute to the filtered value' do
+              expect(interaction.thing).to equal thing
+            end
           end
         end
 
-        context 'without a value' do
-          let(:thing) { nil }
+        context 'passing' do
+          before { inputs.merge!(thing: 1) }
 
-          it 'sets the attribute to the filtered value' do
-            expect(interaction.thing).to equal thing
+          it 'returns a valid outcome' do
+            expect(interaction).to be_valid
           end
         end
       end
 
-      context 'passing validations' do
+      context 'with a single input' do
         before { inputs.merge!(thing: 1) }
 
         it 'sets the attribute to the filtered value' do
           expect(interaction.thing).to eql 1.0
         end
       end
+
+      context 'with multiple inputs' do
+        let(:described_class) { InteractionWithDateFilter }
+        let(:year) { 2012 }
+        let(:month) { 1 }
+        let(:day) { 2 }
+
+        before do
+          inputs.merge!(
+            'thing(1i)' => year.to_s,
+            'thing(2i)' => month.to_s,
+            'thing(3i)' => day.to_s
+          )
+        end
+
+        it 'returns a Date' do
+          expect(interaction.thing).to eql Date.new(year, month, day)
+        end
+      end
     end
   end
 
@@ -245,11 +282,10 @@ describe ActiveInteraction::Base do
           expect(result[:thing]).to eql thing
         end
 
-        it 'calls ActiveRecord::Base.transaction' do
-          allow(ActiveRecord::Base).to receive(:transaction)
+        it 'calls #transaction' do
+          expect_any_instance_of(described_class).to receive(:transaction)
+            .once.with(no_args)
           outcome
-          expect(ActiveRecord::Base).to have_received(:transaction)
-            .with(no_args)
         end
       end
     end
@@ -275,6 +311,31 @@ describe ActiveInteraction::Base do
     end
   end
 
+  describe '#column_for_attribute(name)' do
+    let(:described_class) { InteractionWithFilter }
+    let(:column) { outcome.column_for_attribute(name) }
+
+    context 'name is not an input name' do
+      let(:name) { SecureRandom.hex }
+
+      it 'returns nil if the attribute cannot be found' do
+        expect(column).to be_nil
+      end
+    end
+
+    context 'name is an input name' do
+      let(:name) { InteractionWithFilter.filters.keys.first }
+
+      it 'returns a FilterColumn' do
+        expect(column).to be_a ActiveInteraction::FilterColumn
+      end
+
+      it 'returns a FilterColumn of type boolean' do
+        expect(column.type).to eql :float
+      end
+    end
+  end
+
   describe '#inputs' do
     let(:described_class) { InteractionWithFilter }
     let(:other_val) { SecureRandom.hex }

data/spec/active_interaction/concerns/runnable_spec.rb

@@ -2,32 +2,6 @@
 
 require 'spec_helper'
 
-describe ActiveRecord::Base do
-  describe '.transaction' do
-    it 'raises an error' do
-      expect { described_class.transaction }.to raise_error LocalJumpError
-    end
-
-    it 'silently rescues ActiveRecord::Rollback' do
-      expect do
-        described_class.transaction do
-          fail ActiveRecord::Rollback
-        end
-      end.to_not raise_error
-    end
-
-    context 'with a block' do
-      it 'yields to the block' do
-        expect { |b| described_class.transaction(&b) }.to yield_with_no_args
-      end
-
-      it 'accepts an argument' do
-        expect { described_class.transaction(nil) {} }.to_not raise_error
-      end
-    end
-  end
-end
-
 describe ActiveInteraction::Runnable do
   include_context 'concerns', ActiveInteraction::Runnable
 

data/spec/active_interaction/concerns/transactable_spec.rb

@@ -0,0 +1,114 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe ActiveRecord::Base do
+  describe '.transaction' do
+    it 'raises an error' do
+      expect { described_class.transaction }.to raise_error LocalJumpError
+    end
+
+    it 'silently rescues ActiveRecord::Rollback' do
+      expect do
+        described_class.transaction do
+          fail ActiveRecord::Rollback
+        end
+      end.to_not raise_error
+    end
+
+    context 'with a block' do
+      it 'yields to the block' do
+        expect { |b| described_class.transaction(&b) }.to yield_with_no_args
+      end
+
+      it 'accepts an argument' do
+        expect { described_class.transaction(nil) {} }.to_not raise_error
+      end
+    end
+  end
+end
+
+describe ActiveInteraction::Transactable do
+  include_context 'concerns', ActiveInteraction::Transactable
+
+  describe '.transaction' do
+    it 'returns nil' do
+      expect(klass.transaction(true)).to be_nil
+    end
+
+    it 'accepts a flag parameter' do
+      expect { klass.transaction(true) }.to_not raise_error
+    end
+
+    it 'also accepts an options parameter' do
+      expect { klass.transaction(true, {}) }.to_not raise_error
+    end
+  end
+
+  describe '.transaction?' do
+    it 'defaults to true' do
+      expect(klass.transaction?).to be_true
+    end
+
+    it 'returns the stored value' do
+      klass.transaction(false)
+      expect(klass.transaction?).to be_false
+    end
+  end
+
+  describe '.transaction_options' do
+    it 'defaults to an empty hash' do
+      expect(klass.transaction_options).to eql({})
+    end
+
+    it 'returns the stored value' do
+      h = { rand => rand }
+      klass.transaction(klass.transaction?, h)
+      expect(klass.transaction_options).to eql h
+    end
+  end
+
+  describe '#transaction' do
+    let(:block) { -> { value } }
+    let(:result) { instance.transaction(&block) }
+    let(:value) { double }
+
+    before do
+      allow(ActiveRecord::Base).to receive(:transaction).and_call_original
+    end
+
+    it 'returns nil' do
+      expect(instance.transaction).to be_nil
+    end
+
+    context 'with transactions disabled' do
+      before do
+        klass.transaction(false)
+      end
+
+      it 'returns the value of the block' do
+        expect(result).to eql value
+      end
+
+      it 'does not call ActiveRecord::Base.transaction' do
+        expect(ActiveRecord::Base).to_not have_received(:transaction)
+      end
+    end
+
+    context 'with transactions enabled' do
+      before do
+        klass.transaction(true)
+      end
+
+      it 'returns the value of the block' do
+        expect(result).to eql value
+      end
+
+      it 'calls ActiveRecord::Base.transaction' do
+        result
+        expect(ActiveRecord::Base).to have_received(:transaction)
+          .once.with(klass.transaction_options, &block)
+      end
+    end
+  end
+end