mutations 0.5.12 → 0.6.0

data/spec/hash_filter_spec.rb

@@ -1,4 +1,4 @@
-require_relative 'spec_helper'
+require 'spec_helper'
 require 'stringio'
 
 describe "Mutations::HashFilter" do
@@ -7,7 +7,7 @@ describe "Mutations::HashFilter" do
     hf = Mutations::HashFilter.new do
       string :foo
     end
-    filtered, errors = hf.filter(foo: "bar")
+    filtered, errors = hf.filter(:foo => "bar")
     assert_equal ({"foo" => "bar"}), filtered
     assert_equal nil, errors
   end
@@ -24,7 +24,7 @@ describe "Mutations::HashFilter" do
     hf = Mutations::HashFilter.new do
       string :*
     end
-    filtered, errors = hf.filter(foo: "bar", baz: "ban")
+    filtered, errors = hf.filter(:foo => "bar", :baz => "ban")
     assert_equal ({"foo" => "bar", "baz" => "ban"}), filtered
     assert_equal nil, errors
   end
@@ -33,26 +33,35 @@ describe "Mutations::HashFilter" do
     hf = Mutations::HashFilter.new do
       float :foo
     end
-    filtered, errors = hf.filter(foo: 3.14)
+    filtered, errors = hf.filter(:foo => 3.14)
     assert_equal ({"foo" => 3.14}), filtered
     assert_equal nil, errors
   end
-  
+
   it "allows ducks in hashes" do
     hf = Mutations::HashFilter.new do
-      duck :foo, methods: [:length]
+      duck :foo, :methods => [:length]
     end
-    filtered, errors = hf.filter(foo: "123")
+    filtered, errors = hf.filter(:foo => "123")
     assert_equal ({"foo" => "123"}), filtered
     assert_equal nil, errors
   end
-  
+
+  it "allows dates in hashes" do
+    hf = Mutations::HashFilter.new do
+      date :foo, :format => "%d-%m-%Y"
+    end
+    filtered, errors = hf.filter(:foo => "1-1-2000")
+    assert_equal Date.new(2000, 1, 1), filtered[:foo]
+    assert_equal nil, errors
+  end
+
   it "allows files in hashes" do
     sio = StringIO.new("bob")
     hf = Mutations::HashFilter.new do
       file :foo
     end
-    filtered, errors = hf.filter(foo: sio)
+    filtered, errors = hf.filter(:foo => sio)
     assert_equal ({"foo" => sio}), filtered
     assert_equal nil, errors
   end
@@ -61,7 +70,7 @@ describe "Mutations::HashFilter" do
     hf = Mutations::HashFilter.new do
       string :*
     end
-    filtered, errors = hf.filter(foo: [])
+    filtered, errors = hf.filter(:foo => [])
     assert_equal ({"foo" => :string}), errors.symbolic
   end
 
@@ -70,7 +79,7 @@ describe "Mutations::HashFilter" do
       string :foo
       integer :*
     end
-    filtered, errors = hf.filter(foo: "bar", baz: "4")
+    filtered, errors = hf.filter(:foo => "bar", :baz => "4")
     assert_equal ({"foo" => "bar", "baz" => 4}), filtered
     assert_equal nil, errors
   end
@@ -80,7 +89,7 @@ describe "Mutations::HashFilter" do
       string :foo
       integer :*
     end
-    filtered, errors = hf.filter(foo: "bar", baz: "poopin")
+    filtered, errors = hf.filter(:foo => "bar", :baz => "poopin")
     assert_equal ({"baz" => :integer}), errors.symbolic
   end
 
@@ -95,7 +104,7 @@ describe "Mutations::HashFilter" do
         end
       end
 
-      filtered, errors = hf.filter(foo: "bar")
+      filtered, errors = hf.filter(:foo => "bar")
       assert_equal ({"foo" => "bar"}), filtered
       assert_equal nil, errors
     end
@@ -110,7 +119,7 @@ describe "Mutations::HashFilter" do
         end
       end
 
-      filtered, errors = hf.filter(foo: "bar", bar: nil)
+      filtered, errors = hf.filter(:foo => "bar", :bar => nil)
       assert_equal ({"foo" => "bar"}), filtered
       assert_equal nil, errors
     end
@@ -121,11 +130,11 @@ describe "Mutations::HashFilter" do
           string :foo
         end
         optional do
-          string :bar, nils: true
+          string :bar, :nils => true
         end
       end
 
-      filtered, errors = hf.filter(foo: "bar", bar: nil)
+      filtered, errors = hf.filter(:foo => "bar", :bar => nil)
       assert_equal ({"foo" => "bar", "bar" => nil}), filtered
       assert_equal nil, errors
     end
@@ -138,11 +147,11 @@ describe "Mutations::HashFilter" do
           string :foo
         end
         optional do
-          string :bar, discard_empty: true
+          string :bar, :discard_empty => true
         end
       end
 
-      filtered, errors = hf.filter(foo: "bar", bar: "")
+      filtered, errors = hf.filter(:foo => "bar", :bar => "")
       assert_equal ({"foo" => "bar"}), filtered
       assert_equal nil, errors
     end
@@ -153,11 +162,11 @@ describe "Mutations::HashFilter" do
           string :foo
         end
         optional do
-          string :bar, discard_empty: false
+          string :bar, :discard_empty => false
         end
       end
 
-      filtered, errors = hf.filter(foo: "bar", bar: "")
+      filtered, errors = hf.filter(:foo => "bar", :bar => "")
       assert_equal ({"bar" => :empty}), errors.symbolic
     end
 
@@ -167,15 +176,14 @@ describe "Mutations::HashFilter" do
           string :foo
         end
         optional do
-          string :*, discard_empty: true
+          string :*, :discard_empty => true
         end
       end
 
-      filtered, errors = hf.filter(foo: "bar", bar: "")
+      filtered, errors = hf.filter(:foo => "bar", :bar => "")
       assert_equal ({"foo" => "bar"}), filtered
       assert_equal nil, errors
     end
   end
 
-
 end

data/spec/inheritance_spec.rb

@@ -1,4 +1,4 @@
-require_relative 'spec_helper'
+require 'spec_helper'
 require 'simple_command'
 
 describe 'Mutations - inheritance' do
@@ -15,25 +15,25 @@ describe 'Mutations - inheritance' do
   end
 
   it 'should filter with inherited command' do
-    mutation = SimpleInherited.run(name: "bob", email: "jon@jones.com", age: 10, amount: 22)
+    mutation = SimpleInherited.run(:name => "bob", :email => "jon@jones.com", :age => 10, :amount => 22)
     assert mutation.success?
-    assert_equal HashWithIndifferentAccess.new(name: "bob", email: "jon@jones.com", age: 10, amount: 22), mutation.result
+    assert_equal HashWithIndifferentAccess.new(:name => "bob", :email => "jon@jones.com", :age => 10, :amount => 22), mutation.result
   end
 
   it 'should filter with original command' do
-    mutation = SimpleCommand.run(name: "bob", email: "jon@jones.com", age: 10, amount: 22)
+    mutation = SimpleCommand.run(:name => "bob", :email => "jon@jones.com", :age => 10, :amount => 22)
     assert mutation.success?
-    assert_equal HashWithIndifferentAccess.new(name: "bob", email: "jon@jones.com", amount: 22), mutation.result
+    assert_equal HashWithIndifferentAccess.new(:name => "bob", :email => "jon@jones.com", :amount => 22), mutation.result
   end
 
   it 'shouldnt collide' do
-    mutation = SimpleInherited.run(name: "bob", email: "jon@jones.com", age: 10, amount: 22)
+    mutation = SimpleInherited.run(:name => "bob", :email => "jon@jones.com", :age => 10, :amount => 22)
     assert mutation.success?
-    assert_equal HashWithIndifferentAccess.new(name: "bob", email: "jon@jones.com", age: 10, amount: 22), mutation.result
+    assert_equal HashWithIndifferentAccess.new(:name => "bob", :email => "jon@jones.com", :age => 10, :amount => 22), mutation.result
 
-    mutation = SimpleCommand.run(name: "bob", email: "jon@jones.com", age: 10, amount: 22)
+    mutation = SimpleCommand.run(:name => "bob", :email => "jon@jones.com", :age => 10, :amount => 22)
     assert mutation.success?
-    assert_equal HashWithIndifferentAccess.new(name: "bob", email: "jon@jones.com", amount: 22), mutation.result
+    assert_equal HashWithIndifferentAccess.new(:name => "bob", :email => "jon@jones.com", :amount => 22), mutation.result
   end
 
 end

data/spec/integer_filter_spec.rb

@@ -1,4 +1,4 @@
-require_relative 'spec_helper'
+require 'spec_helper'
 
 describe "Mutations::IntegerFilter" do
 
@@ -32,56 +32,56 @@ describe "Mutations::IntegerFilter" do
   end
 
   it "considers nil to be invalid" do
-    f = Mutations::IntegerFilter.new(nils: false)
+    f = Mutations::IntegerFilter.new(:nils => false)
     filtered, errors = f.filter(nil)
     assert_equal nil, filtered
     assert_equal :nils, errors
   end
 
   it "considers nil to be valid" do
-    f = Mutations::IntegerFilter.new(nils: true)
+    f = Mutations::IntegerFilter.new(:nils => true)
     filtered, errors = f.filter(nil)
     assert_equal nil, filtered
     assert_equal nil, errors
   end
 
   it "considers low numbers invalid" do
-    f = Mutations::IntegerFilter.new(min: 10)
+    f = Mutations::IntegerFilter.new(:min => 10)
     filtered, errors = f.filter(3)
     assert_equal 3, filtered
     assert_equal :min, errors
   end
 
   it "considers low numbers valid" do
-    f = Mutations::IntegerFilter.new(min: 10)
+    f = Mutations::IntegerFilter.new(:min => 10)
     filtered, errors = f.filter(31)
     assert_equal 31, filtered
     assert_equal nil, errors
   end
 
   it "considers high numbers invalid" do
-    f = Mutations::IntegerFilter.new(max: 10)
+    f = Mutations::IntegerFilter.new(:max => 10)
     filtered, errors = f.filter(31)
     assert_equal 31, filtered
     assert_equal :max, errors
   end
 
   it "considers high numbers vaild" do
-    f = Mutations::IntegerFilter.new(max: 10)
+    f = Mutations::IntegerFilter.new(:max => 10)
     filtered, errors = f.filter(3)
     assert_equal 3, filtered
     assert_equal nil, errors
   end
 
   it "considers not matching numbers to be invalid" do
-    f = Mutations::IntegerFilter.new(in: [3, 4, 5])
+    f = Mutations::IntegerFilter.new(:in => [3, 4, 5])
     filtered, errors = f.filter(6)
     assert_equal 6, filtered
     assert_equal :in, errors
   end
 
   it "considers matching numbers to be valid" do
-    f = Mutations::IntegerFilter.new(in: [3, 4, 5])
+    f = Mutations::IntegerFilter.new(:in => [3, 4, 5])
     filtered, errors = f.filter(3)
     assert_equal 3, filtered
     assert_nil errors

data/spec/model_filter_spec.rb

@@ -1,4 +1,4 @@
-require_relative 'spec_helper'
+require 'spec_helper'
 
 describe "Mutations::ModelFilter" do
 
@@ -15,7 +15,6 @@ describe "Mutations::ModelFilter" do
     end
   end
 
-
   it "allows models" do
     f = Mutations::ModelFilter.new(:simple_model)
     m = SimpleModel.new
@@ -35,32 +34,53 @@ describe "Mutations::ModelFilter" do
   end
 
   it "raises an exception during filtering if constantization of class fails" do
-    f = Mutations::ModelFilter.new(:simple_model, class: "ComplexModel")
+    f = Mutations::ModelFilter.new(:simple_model, :class => "ComplexModel")
     assert_raises NameError do
       f.filter(nil)
     end
   end
 
   it "raises an exception during filtering if constantization of builder fails" do
-    f = Mutations::ModelFilter.new(:simple_model, builder: "ComplexModel")
+    f = Mutations::ModelFilter.new(:simple_model, :builder => "ComplexModel")
     assert_raises NameError do
       f.filter(nil)
     end
   end
 
   it "considers nil to be invalid" do
-    f = Mutations::ModelFilter.new(:simple_model, nils: false)
+    f = Mutations::ModelFilter.new(:simple_model, :nils => false)
     filtered, errors = f.filter(nil)
     assert_equal nil, filtered
     assert_equal :nils, errors
   end
 
   it "considers nil to be valid" do
-    f = Mutations::ModelFilter.new(:simple_model, nils: true)
+    f = Mutations::ModelFilter.new(:simple_model, :nils => true)
     filtered, errors = f.filter(nil)
     assert_equal nil, filtered
     assert_equal nil, errors
   end
+  
+  it "will re-constantize if cache_constants is false" do
+    was = Mutations.cache_constants?
+    Mutations.cache_constants = false
+    f = Mutations::ModelFilter.new(:simple_model)
+    m = SimpleModel.new
+    filtered, errors = f.filter(m)
+    assert_equal m, filtered
+    assert_equal nil, errors
+    
+    Object.send(:remove_const, 'SimpleModel')
+    
+    class SimpleModel; end
+    
+    m = SimpleModel.new
+    filtered, errors = f.filter(m)
+    assert_equal m, filtered
+    assert_equal nil, errors
+    
+    Mutations.cache_constants = was
+  end
 
   # it "allows you to override class with a constant and succeed" do
   # end

data/spec/mutations_spec.rb

@@ -1,4 +1,4 @@
-require_relative 'spec_helper'
+require 'spec_helper'
 
 describe 'Mutations' do
 

data/spec/simple_command.rb

@@ -1,7 +1,7 @@
 class SimpleCommand < Mutations::Command
 
   required do
-    string :name, max_length: 10
+    string :name, :max_length => 10
     string :email
   end
 
@@ -12,4 +12,4 @@ class SimpleCommand < Mutations::Command
   def execute
     inputs
   end
-end
+end

data/spec/spec_helper.rb

@@ -5,4 +5,4 @@ require 'pp'
 $LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__))
 $LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
 
-require 'mutations'
+require 'mutations'

data/spec/string_filter_spec.rb

@@ -1,4 +1,4 @@
-require_relative 'spec_helper'
+require 'spec_helper'
 
 describe "Mutations::StringFilter" do
 
@@ -25,112 +25,112 @@ describe "Mutations::StringFilter" do
 
   it "disallows non-string" do
     sf = Mutations::StringFilter.new
-    [["foo"], {a: "1"}, Object.new].each do |thing|
+    [["foo"], {:a => "1"}, Object.new].each do |thing|
       filtered, errors = sf.filter(thing)
       assert_equal :string, errors
     end
   end
 
   it "strips" do
-    sf = Mutations::StringFilter.new(strip: true)
+    sf = Mutations::StringFilter.new(:strip => true)
     filtered, errors = sf.filter(" hello ")
     assert_equal "hello", filtered
     assert_equal nil, errors
   end
 
   it "doesn't strip" do
-    sf = Mutations::StringFilter.new(strip: false)
+    sf = Mutations::StringFilter.new(:strip => false)
     filtered, errors = sf.filter(" hello ")
     assert_equal " hello ", filtered
     assert_equal nil, errors
   end
 
   it "considers nil to be invalid" do
-    sf = Mutations::StringFilter.new(nils: false)
+    sf = Mutations::StringFilter.new(:nils => false)
     filtered, errors = sf.filter(nil)
     assert_equal nil, filtered
     assert_equal :nils, errors
   end
 
   it "considers nil to be valid" do
-    sf = Mutations::StringFilter.new(nils: true)
+    sf = Mutations::StringFilter.new(:nils => true)
     filtered, errors = sf.filter(nil)
     assert_equal nil, filtered
     assert_equal nil, errors
   end
 
   it "considers empty strings to be invalid" do
-    sf = Mutations::StringFilter.new(empty: false)
+    sf = Mutations::StringFilter.new(:empty => false)
     filtered, errors = sf.filter("")
     assert_equal "", filtered
     assert_equal :empty, errors
   end
 
   it "considers empty strings to be valid" do
-    sf = Mutations::StringFilter.new(empty: true)
+    sf = Mutations::StringFilter.new(:empty => true)
     filtered, errors = sf.filter("")
     assert_equal "", filtered
     assert_equal nil, errors
   end
 
   it "considers stripped strings that are empty to be invalid" do
-    sf = Mutations::StringFilter.new(empty: false)
+    sf = Mutations::StringFilter.new(:empty => false)
     filtered, errors = sf.filter("   ")
     assert_equal "", filtered
     assert_equal :empty, errors
   end
 
   it "considers long strings to be invalid" do
-    sf = Mutations::StringFilter.new(max_length: 5)
+    sf = Mutations::StringFilter.new(:max_length => 5)
     filtered, errors = sf.filter("123456")
     assert_equal "123456", filtered
     assert_equal :max_length, errors
   end
 
   it "considers long strings to be valid" do
-    sf = Mutations::StringFilter.new(max_length: 5)
+    sf = Mutations::StringFilter.new(:max_length => 5)
     filtered, errors = sf.filter("12345")
     assert_equal "12345", filtered
     assert_equal nil, errors
   end
 
   it "considers short strings to be invalid" do
-    sf = Mutations::StringFilter.new(min_length: 5)
+    sf = Mutations::StringFilter.new(:min_length => 5)
     filtered, errors = sf.filter("1234")
     assert_equal "1234", filtered
     assert_equal :min_length, errors
   end
 
   it "considers short strings to be valid" do
-    sf = Mutations::StringFilter.new(min_length: 5)
+    sf = Mutations::StringFilter.new(:min_length => 5)
     filtered, errors = sf.filter("12345")
     assert_equal "12345", filtered
     assert_equal nil, errors
   end
 
   it "considers bad matches to be invalid" do
-    sf = Mutations::StringFilter.new(matches: /aaa/)
+    sf = Mutations::StringFilter.new(:matches => /aaa/)
     filtered, errors = sf.filter("aab")
     assert_equal "aab", filtered
     assert_equal :matches, errors
   end
 
   it "considers good matches to be valid" do
-    sf = Mutations::StringFilter.new(matches: /aaa/)
+    sf = Mutations::StringFilter.new(:matches => /aaa/)
     filtered, errors = sf.filter("baaab")
     assert_equal "baaab", filtered
     assert_equal nil, errors
   end
 
   it "considers non-inclusion to be invalid" do
-    sf = Mutations::StringFilter.new(in: %w(red blue green))
+    sf = Mutations::StringFilter.new(:in => %w(red blue green))
     filtered, errors = sf.filter("orange")
     assert_equal "orange", filtered
     assert_equal :in, errors
   end
 
   it "considers inclusion to be valid" do
-    sf = Mutations::StringFilter.new(in: %w(red blue green))
+    sf = Mutations::StringFilter.new(:in => %w(red blue green))
     filtered, errors = sf.filter("red")
     assert_equal "red", filtered
     assert_equal nil, errors