objective 0.1.0

data/spec/filters/any_filter_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe 'Objective::Filters::AnyFilter' do
+  it 'Allows anything' do
+    f = Objective::Filters::AnyFilter.new
+
+    [true, 'hi', 1, [1, 2, 3], { one: 1 }, 1..3, nil].each do |v|
+      result = f.feed(v)
+      if v.nil?
+        assert_nil result.inputs
+      else
+        assert_equal v, result.inputs
+      end
+      assert_nil result.errors
+    end
+  end
+
+  it 'Allows nils by default' do
+    f = Objective::Filters::AnyFilter.new
+
+    result = f.feed(nil)
+    assert_nil result.inputs
+    assert_nil result.errors
+  end
+
+  it 'Does not allow nils if set to deny' do
+    f = Objective::Filters::AnyFilter.new(:a1, nils: Objective::DENY)
+
+    result = f.feed(nil)
+    assert_nil result.inputs
+    assert_equal :nils, result.errors
+  end
+end

data/spec/filters/array_filter_spec.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require 'stringio'
+
+describe 'Objective::Filters::ArrayFilter' do
+  it 'allows arrays' do
+    f = Objective::Filters::ArrayFilter.new(:arr) { any }
+
+    result = f.feed([1])
+    assert_equal [1], result.inputs
+    assert_nil result.errors
+  end
+
+  it 'considers non-arrays to be invalid' do
+    f = Objective::Filters::ArrayFilter.new(:arr) { any }
+
+    ['hi', true, 1, { a: '1' }, Object.new].each do |thing|
+      result = f.feed(thing)
+      assert_equal :array, result.errors
+    end
+  end
+
+  it 'considers nil to be invalid' do
+    f = Objective::Filters::ArrayFilter.new(:arr) { any }
+
+    result = f.feed(nil)
+    assert_nil result.inputs
+    assert_equal :nils, result.errors
+  end
+
+  it 'considers nil to be valid' do
+    f = Objective::Filters::ArrayFilter.new(:arr, nils: Objective::ALLOW) { any }
+
+    result = f.feed(nil)
+    assert_nil result.errors
+  end
+
+  it 'lets you use a block to supply an element filter' do
+    f = Objective::Filters::ArrayFilter.new(:arr) { string }
+
+    result = f.feed(['hi', { stuff: 'ok' }])
+    assert_nil result.errors[0]
+    assert_equal :string, result.errors[1].codes
+  end
+
+  it 'lets you wrap everything' do
+    f = Objective::Filters::ArrayFilter.new(:arr, wrap: true) { any }
+
+    [
+      [true, [true]],
+      ['hi', ['hi']],
+      ['', ['']],
+      [1, [1]],
+      [[1, 2, 3], [1, 2, 3]],
+      [{ one: 1 }, [{ one: 1 }]],
+      [1..3, [1..3]]
+    ].each do |(given, expected)|
+      result = f.feed(given)
+      assert_equal expected, result.inputs
+      assert_nil result.errors
+    end
+
+    result = f.feed('foo')
+    assert_equal ['foo'], result.inputs
+    assert_nil result.errors
+  end
+
+  it 'lets you pass integers in arrays' do
+    f = Objective::Filters::ArrayFilter.new(:arr) { integer min: 4 }
+
+    result = f.feed([5, 6, 1, 'bob'])
+    assert_equal [5, 6, 1, 'bob'], result.inputs
+    assert_equal [nil, nil, :min, :integer], result.errors.codes
+  end
+
+  it 'lets you pass floats in arrays' do
+    f = Objective::Filters::ArrayFilter.new(:float) { float min: 4.0 }
+
+    result = f.feed([5.0, 6.0, 1.0, 'bob'])
+    assert_equal [5.0, 6.0, 1.0, 'bob'], result.inputs
+    assert_equal [nil, nil, :min, :float], result.errors.codes
+  end
+
+  it 'lets you pass ducks in arrays' do
+    f = Objective::Filters::ArrayFilter.new(:arr) { duck(methods: :length) }
+
+    result = f.feed(['hi', [1], true])
+    assert_equal ['hi', [1], true], result.inputs
+    assert_equal [nil, nil, :duck], result.errors.codes
+  end
+
+  it 'lets you pass dates in arrays' do
+    f = Objective::Filters::ArrayFilter.new(:arr) { date(format: '%Y-%m-%d') }
+
+    result = f.feed(['2000-1-1', Date.new(2000, 1, 1), '2000-20-1'])
+    assert_equal [Date.new(2000, 1, 1), Date.new(2000, 1, 1), '2000-20-1'], result.inputs
+    assert_equal [nil, nil, :date], result.errors.codes
+  end
+
+  it 'lets you pass files in arrays' do
+    sio = StringIO.new('bob')
+    f = Objective::Filters::ArrayFilter.new(:arr) { file }
+
+    result = f.feed([sio, 'bob'])
+    assert_equal [sio, 'bob'], result.inputs
+    assert_equal [nil, :file], result.errors.codes
+  end
+
+  it 'lets you pass booleans in arrays' do
+    f = Objective::Filters::ArrayFilter.new(:arr) { boolean }
+
+    result = f.feed([true, false, '1'])
+    assert_equal [true, false, true], result.inputs
+    assert_nil result.errors
+  end
+
+  it 'lets you pass model in arrays' do
+    f = Objective::Filters::ArrayFilter.new(:arr) { model :string }
+
+    result = f.feed(['hey'])
+    assert_equal ['hey'], result.inputs
+    assert_nil result.errors
+  end
+
+  it 'lets you pass hashes in arrays' do
+    f = Objective::Filters::ArrayFilter.new(:arr) do
+      hash do
+        string :foo
+        integer :bar
+        boolean :baz, none: Objective::ALLOW
+      end
+    end
+
+    result = f.feed([{ foo: 'f', bar: 3, baz: true }, { foo: 'f', bar: 3 }, { foo: 'f' }])
+    assert_equal [{ 'foo' => 'f', 'bar' => 3, 'baz' => true }, { 'foo' => 'f', 'bar' => 3 }, { 'foo' => 'f' }], result.inputs
+    assert_nil result.errors[0]
+    assert_nil result.errors[1]
+    assert_equal ({ 'bar' => :required }), result.errors[2].codes
+  end
+
+  it 'lets you pass arrays of arrays' do
+    f = Objective::Filters::ArrayFilter.new(:arr) do
+      array do
+        string
+      end
+    end
+
+    result = f.feed([%w(h e), ['l'], [], ['lo']])
+    assert_equal [%w(h e), ['l'], [], ['lo']], result.inputs
+    assert_nil result.errors
+  end
+
+  it 'handles errors for arrays of arrays' do
+    f = Objective::Filters::ArrayFilter.new(:arr) do
+      array do
+        string
+      end
+    end
+
+    result = f.feed([['h', 'e', {}], ['l'], [], ['']])
+    assert_equal [[nil, nil, :string], nil, nil, [:empty]], result.errors.codes
+    assert_equal [[nil, nil, '3rd Item must be a string'], nil, nil, ['1st Item cannot be empty']], result.errors.message
+    assert_equal ['3rd Item must be a string', '1st Item cannot be empty'], result.errors.message_list
+  end
+
+  it 'can discard invalid elements' do
+    f = Objective::Filters::ArrayFilter.new(:arr) do
+      integer invalid: Objective::DISCARD
+    end
+
+    result = f.feed([1, '2', 'three', '4', 5, [6]])
+    assert_nil result.errors
+    assert_equal [1, 2, 4, 5], result.inputs
+  end
+
+  it 'can discard nil elements' do
+    f = Objective::Filters::ArrayFilter.new(:arr) do
+      integer nils: Objective::DISCARD
+    end
+
+    result = f.feed([nil, 1, '2', nil, nil, '4', 5, nil])
+    assert_nil result.errors
+    assert_equal [1, 2, 4, 5], result.inputs
+  end
+
+  it 'can discard empty elements' do
+    f = Objective::Filters::ArrayFilter.new(:arr) do
+      string empty: Objective::DISCARD
+    end
+
+    result = f.feed(['', 1, '2', '', '', '4', 5, ''])
+    assert_nil result.errors
+    assert_equal %w(1 2 4 5), result.inputs
+  end
+end

data/spec/filters/boolean_filter_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe 'Objective::Filters::BooleanFilter' do
+  it 'allows booleans' do
+    f = Objective::Filters::BooleanFilter.new
+    result = f.feed(true)
+    assert_equal true, result.inputs
+    assert_nil result.errors
+
+    result = f.feed(false)
+    assert_equal false, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'considers non-booleans to be invalid' do
+    f = Objective::Filters::BooleanFilter.new
+    [[true], { a: '1' }, Object.new].each do |thing|
+      result = f.feed(thing)
+      assert_equal :boolean, result.errors
+    end
+  end
+
+  it 'considers nil to be invalid' do
+    f = Objective::Filters::BooleanFilter.new(:bool)
+    result = f.feed(nil)
+    assert_nil result.inputs
+    assert_equal :nils, result.errors
+  end
+
+  it 'considers nil to be valid' do
+    f = Objective::Filters::BooleanFilter.new(:bool, nils: Objective::ALLOW)
+    result = f.feed(nil)
+    assert_nil result.inputs
+    assert_nil result.errors
+  end
+
+  it 'considers certain values to be true' do
+    f = Objective::Filters::BooleanFilter.new
+
+    ['true', 'TRUE', 'TrUe', '1', 1].each do |value|
+      result = f.feed(value)
+      assert_equal true, result.inputs
+      assert_nil result.errors
+    end
+  end
+
+  it 'considers certain values to be true' do
+    f = Objective::Filters::BooleanFilter.new
+
+    ['false', 'FALSE', 'FalSe', '0', 0].each do |value|
+      result = f.feed(value)
+      assert_equal false, result.inputs
+      assert_nil result.errors
+    end
+  end
+
+  it 'considers other string to be invalid' do
+    f = Objective::Filters::BooleanFilter.new
+    %w(truely 2).each do |str|
+      result = f.feed(str)
+      assert_equal str, result.inputs
+      assert_equal :boolean, result.errors
+    end
+  end
+end

data/spec/filters/date_filter_spec.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe 'Objective::Filters::DateFilter' do
+  it 'takes a date object' do
+    date = Date.new
+    f = Objective::Filters::DateFilter.new
+    result = f.feed(date)
+    assert_equal date, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'takes a DateTime object' do
+    date = DateTime.new
+    f = Objective::Filters::DateFilter.new
+    result = f.feed(date)
+    assert_equal date, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'takes a Time object and converts it to a date' do
+    time = Time.now
+    f = Objective::Filters::DateFilter.new
+    result = f.feed(time)
+    if time.respond_to?(:to_date)
+      assert_equal time.to_date, result.inputs
+      assert_nil result.errors
+    else
+      assert_equal :date, result.errors
+    end
+  end
+
+  it 'checks if the given date is after a certain date' do
+    date = Date.new(2005, 1, 1)
+    after_date = Date.new(2000, 1, 1)
+    f = Objective::Filters::DateFilter.new(:d1, after: after_date)
+    result = f.feed(date)
+
+    assert_equal date, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'gives errors when the given date is before the after date' do
+    date = Date.new(1995, 1, 1)
+    after_date = Date.new(2000, 1, 1)
+    f = Objective::Filters::DateFilter.new(:d1, after: after_date)
+    result = f.feed(date)
+
+    assert_equal date, result.inputs
+    assert_equal :after, result.errors
+  end
+
+  it 'checks if the given date is before a certain date' do
+    date = Date.new(1995, 1, 1)
+    after_date = Date.new(2000, 1, 1)
+    f = Objective::Filters::DateFilter.new(:d1, before: after_date)
+    result = f.feed(date)
+
+    assert_equal date, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'gives errors when the given date is after the before date' do
+    date = Date.new(2005, 1, 1)
+    before_date = Date.new(2000, 1, 1)
+    f = Objective::Filters::DateFilter.new(:d1, before: before_date)
+    result = f.feed(date)
+
+    assert_equal date, result.inputs
+    assert_equal :before, result.errors
+  end
+
+  it 'checks if the given date is in the given range' do
+    date = Date.new(2005, 1, 1)
+    after_date = Date.new(2000, 1, 1)
+    before_date = Date.new(2010, 1, 1)
+    f = Objective::Filters::DateFilter.new(:d1, after: after_date, before: before_date)
+    result = f.feed(date)
+
+    assert_equal date, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'should be able to parse a D-M-Y string to a date' do
+    date_string = '2-1-2000'
+    date = Date.new(2000, 1, 2)
+    f = Objective::Filters::DateFilter.new
+    result = f.feed(date_string)
+
+    assert_equal date, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'should be able to parse a Y-M-D string to a date' do
+    date_string = '2000-1-2'
+    date = Date.new(2000, 1, 2)
+    f = Objective::Filters::DateFilter.new
+    result = f.feed(date_string)
+
+    assert_equal date, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'should be able to handle date formatting' do
+    date_string = '2000-1-2'
+    date = Date.new(2000, 1, 2)
+    f = Objective::Filters::DateFilter.new(:d1, format: '%Y-%m-%d')
+    result = f.feed(date_string)
+
+    assert_equal date, result.inputs
+    assert_nil result.errors
+
+    date_string = '1, 2, 2000'
+    f = Objective::Filters::DateFilter.new(:d1, format: '%m, %d, %Y')
+    result = f.feed(date_string)
+
+    assert_equal date, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'considers nil to be invalid' do
+    f = Objective::Filters::DateFilter.new
+    result = f.feed(nil)
+
+    assert_nil result.inputs
+    assert_equal :nils, result.errors
+  end
+
+  it 'allows the use of nil when specified' do
+    f = Objective::Filters::DateFilter.new(:d1, nils: Objective::ALLOW)
+    result = f.feed(nil)
+
+    assert_nil result.inputs
+    assert_nil result.errors
+  end
+
+  it 'does not allow non-existing dates' do
+    date_string = '1, 20, 2013'
+    f = Objective::Filters::DateFilter.new
+    result = f.feed(date_string)
+
+    assert_equal '1, 20, 2013', result.inputs
+    assert_equal :date, result.errors
+  end
+end

data/spec/filters/decimal_filter_spec.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe 'Objective::Filters::DecimalFilter' do
+  it 'allows bigdecimals' do
+    f = Objective::Filters::DecimalFilter.new
+    result = f.feed(BigDecimal.new('0.99999999999999999'))
+
+    assert result.inputs.is_a?(BigDecimal)
+    assert_equal '0.99999999999999999', result.inputs.to_s('F')
+    assert_nil result.errors
+  end
+
+  it 'allows integers' do
+    f = Objective::Filters::DecimalFilter.new
+    result = f.feed(3)
+
+    assert result.inputs.is_a?(BigDecimal)
+    assert_equal 3, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'allows floats' do
+    f = Objective::Filters::DecimalFilter.new
+    result = f.feed(3.1415926)
+
+    assert result.inputs.is_a?(BigDecimal)
+    assert_equal 3.1415926, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'allows strings that start with a digit' do
+    f = Objective::Filters::DecimalFilter.new
+    result = f.feed('3')
+
+    assert result.inputs.is_a?(BigDecimal)
+    assert_equal 3.0, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'allows string representation of float' do
+    f = Objective::Filters::DecimalFilter.new
+    result = f.feed('3.14')
+
+    assert result.inputs.is_a?(BigDecimal)
+    assert_equal 3.14, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'allows string representation of float without a number before dot' do
+    f = Objective::Filters::DecimalFilter.new
+    result = f.feed('.14')
+
+    assert result.inputs.is_a?(BigDecimal)
+    assert_equal 0.14, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'allows negative strings' do
+    f = Objective::Filters::DecimalFilter.new
+    result = f.feed('-.14')
+
+    assert result.inputs.is_a?(BigDecimal)
+    assert_equal(-0.14, result.inputs)
+    assert_nil result.errors
+  end
+
+  it 'allows strings with a positive sign' do
+    f = Objective::Filters::DecimalFilter.new
+    result = f.feed('+.14')
+
+    assert result.inputs.is_a?(BigDecimal)
+    assert_equal 0.14, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'allows spaces in strings as a delimiter' do
+    f = Objective::Filters::DecimalFilter.new
+    result = f.feed('123 456.789')
+
+    assert result.inputs.is_a?(BigDecimal)
+    assert_equal 123_456.789, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'allows commas in strings as a delimiter' do
+    f = Objective::Filters::DecimalFilter.new
+    result = f.feed('123,456.789')
+
+    assert result.inputs.is_a?(BigDecimal)
+    assert_equal 123_456.789, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'does not allow random objects, symbols, or strings with non-numeric characters' do
+    f = Objective::Filters::DecimalFilter.new
+
+    ['zero', 'a1', {}, [], Object.new, :d].each do |thing|
+      result = f.feed(thing)
+
+      assert_equal :decimal, result.errors
+    end
+  end
+
+  it 'considers nil to be invalid' do
+    f = Objective::Filters::DecimalFilter.new(:x)
+    result = f.feed(nil)
+
+    assert_nil result.inputs
+    assert_equal :nils, result.errors
+  end
+
+  it 'considers nil to be valid' do
+    f = Objective::Filters::DecimalFilter.new(:x, nils: Objective::ALLOW)
+    result = f.feed(nil)
+
+    assert_nil result.inputs
+    assert_nil result.errors
+  end
+
+  it 'considers empty strings to be invalid' do
+    f = Objective::Filters::DecimalFilter.new
+    result = f.feed('')
+
+    assert_equal :decimal, result.errors
+  end
+
+  it 'can allow alternative number formats' do
+    f = Objective::Filters::DecimalFilter.new(:x, delimiter: '.', decimal_mark: ',')
+    result = f.feed('123.456,789')
+
+    assert result.inputs.is_a?(BigDecimal)
+    assert_equal 123_456.789, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'considers numbers with less decimal points than the scale value to be valid' do
+    f = Objective::Filters::DecimalFilter.new(:x, scale: 2)
+    result = f.feed('1.2')
+
+    assert result.inputs.is_a?(BigDecimal)
+    assert_equal 1.2, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'considers numbers with the same decimal points as the scale value to be valid' do
+    f = Objective::Filters::DecimalFilter.new(:x, scale: 2)
+    result = f.feed('1.23')
+
+    assert result.inputs.is_a?(BigDecimal)
+    assert_equal 1.23, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'considers numbers with more decimal points than scale value to be invalid' do
+    f = Objective::Filters::DecimalFilter.new(:x, scale: 2)
+    result = f.feed('1.234')
+
+    assert result.inputs.is_a?(BigDecimal)
+    assert_equal 1.234, result.inputs
+    assert_equal :scale, result.errors
+  end
+
+  it 'considers low numbers invalid' do
+    f = Objective::Filters::DecimalFilter.new(:x, min: 10)
+    result = f.feed(3)
+
+    assert result.inputs.is_a?(BigDecimal)
+    assert_equal 3, result.inputs
+    assert_equal :min, result.errors
+  end
+
+  it 'considers low numbers valid' do
+    f = Objective::Filters::DecimalFilter.new(:x, min: 10)
+    result = f.feed(31)
+
+    assert result.inputs.is_a?(BigDecimal)
+    assert_equal 31, result.inputs
+    assert_nil result.errors
+  end
+
+  it 'considers high numbers invalid' do
+    f = Objective::Filters::DecimalFilter.new(:x, max: 10)
+    result = f.feed(31)
+
+    assert result.inputs.is_a?(BigDecimal)
+    assert_equal 31, result.inputs
+    assert_equal :max, result.errors
+  end
+
+  it 'considers high numbers vaild' do
+    f = Objective::Filters::DecimalFilter.new(:x, max: 10)
+    result = f.feed(3)
+
+    assert result.inputs.is_a?(BigDecimal)
+    assert_equal 3, result.inputs
+    assert_nil result.errors
+  end
+end

data/spec/filters/duck_filter_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe 'Objective::Filters::DuckFilter' do
+  it 'allows objects that respond to a single specified method' do
+    f = Objective::Filters::DuckFilter.new(:quack, methods: [:length])
+    result = f.feed('test')
+    assert_equal 'test', result.inputs
+    assert_nil result.errors
+
+    result = f.feed([1, 2])
+    assert_equal [1, 2], result.inputs
+    assert_nil result.errors
+  end
+
+  it 'does not allow objects that respond to a single specified method' do
+    f = Objective::Filters::DuckFilter.new(:quack, methods: [:length])
+    result = f.feed(true)
+    assert_equal true, result.inputs
+    assert_equal :duck, result.errors
+
+    result = f.feed(12)
+    assert_equal 12, result.inputs
+    assert_equal :duck, result.errors
+  end
+
+  it 'considers nil to be invalid' do
+    f = Objective::Filters::DuckFilter.new(:quack)
+    result = f.feed(nil)
+    assert_nil result.inputs
+    assert_equal :nils, result.errors
+  end
+
+  it 'considers nil to be valid' do
+    f = Objective::Filters::DuckFilter.new(:quack, nils: Objective::ALLOW)
+    result = f.feed(nil)
+    assert_nil result.inputs
+    assert_nil result.errors
+  end
+
+  it 'Allows anything if no methods are specified' do
+    f = Objective::Filters::DuckFilter.new
+    [true, 'hi', 1, [1, 2, 3], { one: 1 }, 1..3].each do |v|
+      result = f.feed(v)
+      assert_equal v, result.inputs
+      assert_nil result.errors
+    end
+  end
+end