mutations 0.5.9 → 0.5.10

data/spec/errors_spec.rb

@@ -1,13 +1,13 @@
 require_relative 'spec_helper'
 
 describe "Mutations - errors" do
-  
+
   class GivesErrors < Mutations::Command
     required do
       string :str1
       string :str2, :in => %w(opt1 opt2 opt3)
     end
-    
+
     optional do
       integer :int1
       hash :hash1 do
@@ -16,15 +16,15 @@ describe "Mutations - errors" do
       end
       array :arr1 do integer end
     end
-    
+
     def execute
       inputs
     end
   end
-  
+
   it "returns an ErrorHash as the top level error object, and ErrorAtom's inside" do
     o = GivesErrors.run(hash1: 1, arr1: "bob")
-    
+
     assert !o.success?
     assert o.errors.is_a?(Mutations::ErrorHash)
     assert o.errors[:str1].is_a?(Mutations::ErrorAtom)
@@ -33,20 +33,20 @@ describe "Mutations - errors" do
     assert o.errors[:hash1].is_a?(Mutations::ErrorAtom)
     assert o.errors[:arr1].is_a?(Mutations::ErrorAtom)
   end
-  
+
   it "returns an ErrorHash for nested hashes" do
     o = GivesErrors.run(hash1: {bool1: "poop"})
-    
+
     assert !o.success?
     assert o.errors.is_a?(Mutations::ErrorHash)
     assert o.errors[:hash1].is_a?(Mutations::ErrorHash)
     assert o.errors[:hash1][:bool1].is_a?(Mutations::ErrorAtom)
     assert o.errors[:hash1][:bool2].is_a?(Mutations::ErrorAtom)
   end
-  
+
   it "returns an ErrorArray for errors in arrays" do
     o = GivesErrors.run(str1: "a", str2: "opt1", arr1: ["bob", 1, "sally"])
-    
+
     assert !o.success?
     assert o.errors.is_a?(Mutations::ErrorHash)
     assert o.errors[:arr1].is_a?(Mutations::ErrorArray)
@@ -54,17 +54,17 @@ describe "Mutations - errors" do
     assert_nil o.errors[:arr1][1]
     assert o.errors[:arr1][2].is_a?(Mutations::ErrorAtom)
   end
-  
+
   it "titleizes keys" do
     atom = Mutations::ErrorAtom.new(:newsletter_subscription, :boolean)
     assert_equal "Newsletter Subscription isn't a boolean", atom.message
   end
-  
+
   describe "Bunch o errors" do
-    before do 
+    before do
       @outcome = GivesErrors.run(str1: "", str2: "opt9", int1: "zero", hash1: {bool1: "bob"}, arr1: ["bob", 1, "sally"])
     end
-    
+
     it "gives symbolic errors" do
       expected = {"str1"=>:empty,
        "str2"=>:in,
@@ -74,20 +74,20 @@ describe "Mutations - errors" do
 
       assert_equal expected, @outcome.errors.symbolic
     end
-    
+
     it "gives messages" do
       expected = {"str1"=>"Str1 can't be blank", "str2"=>"Str2 isn't an option", "int1"=>"Int1 isn't an integer", "hash1"=>{"bool1"=>"Bool1 isn't a boolean", "bool2"=>"Bool2 is required"}, "arr1"=>["Arr1[0] isn't an integer", nil, "Arr1[2] isn't an integer"]}
 
       assert_equal expected, @outcome.errors.message
     end
-    
+
     it "can flatten those messages" do
       expected = ["Str1 can't be blank", "Str2 isn't an option", "Int1 isn't an integer", "Bool1 isn't a boolean", "Bool2 is required", "Arr1[0] isn't an integer", "Arr1[2] isn't an integer"]
-      
+
       assert_equal expected, @outcome.errors.message_list
     end
   end
-  
-  
-  
+
+
+
 end

data/spec/hash_filter_spec.rb

@@ -10,7 +10,7 @@ describe "Mutations::HashFilter" do
     assert_equal ({"foo" => "bar"}), filtered
     assert_equal nil, errors
   end
-  
+
   it 'disallows non-hashes' do
     hf = Mutations::HashFilter.new do
       string :foo
@@ -18,7 +18,7 @@ describe "Mutations::HashFilter" do
     filtered, errors = hf.filter("bar")
     assert_equal :hash, errors
   end
-  
+
   it "allows wildcards in hashes" do
     hf = Mutations::HashFilter.new do
       string :*
@@ -27,7 +27,16 @@ describe "Mutations::HashFilter" do
     assert_equal ({"foo" => "bar", "baz" => "ban"}), filtered
     assert_equal nil, errors
   end
-  
+
+  it "allow floats in hashes" do
+    hf = Mutations::HashFilter.new do
+      float :foo
+    end
+    filtered, errors = hf.filter(foo: 3.14)
+    assert_equal ({"foo" => 3.14}), filtered
+    assert_equal nil, errors
+  end
+
   it "doesn't allow wildcards in hashes" do
     hf = Mutations::HashFilter.new do
       string :*
@@ -35,7 +44,7 @@ describe "Mutations::HashFilter" do
     filtered, errors = hf.filter(foo: [])
     assert_equal ({"foo" => :string}), errors.symbolic
   end
-  
+
   it "allows a mix of specific keys and then wildcards" do
     hf = Mutations::HashFilter.new do
       string :foo
@@ -45,7 +54,7 @@ describe "Mutations::HashFilter" do
     assert_equal ({"foo" => "bar", "baz" => 4}), filtered
     assert_equal nil, errors
   end
-  
+
   it "doesn't allow a mix of specific keys and then wildcards -- should raise errors appropriately" do
     hf = Mutations::HashFilter.new do
       string :foo
@@ -54,7 +63,7 @@ describe "Mutations::HashFilter" do
     filtered, errors = hf.filter(foo: "bar", baz: "poopin")
     assert_equal ({"baz" => :integer}), errors.symbolic
   end
-  
+
   describe "optional params and nils" do
     it "bar is optional -- it works if not passed" do
       hf = Mutations::HashFilter.new do
@@ -65,12 +74,12 @@ describe "Mutations::HashFilter" do
           string :bar
         end
       end
-      
+
       filtered, errors = hf.filter(foo: "bar")
       assert_equal ({"foo" => "bar"}), filtered
       assert_equal nil, errors
     end
-    
+
     it "bar is optional -- it works if nil is passed" do
       hf = Mutations::HashFilter.new do
         required do
@@ -80,12 +89,12 @@ describe "Mutations::HashFilter" do
           string :bar
         end
       end
-      
+
       filtered, errors = hf.filter(foo: "bar", bar: nil)
       assert_equal ({"foo" => "bar"}), filtered
       assert_equal nil, errors
     end
-    
+
     it "bar is optional -- it works if nil is passed and nils are allowed" do
       hf = Mutations::HashFilter.new do
         required do
@@ -95,13 +104,13 @@ describe "Mutations::HashFilter" do
           string :bar, nils: true
         end
       end
-      
+
       filtered, errors = hf.filter(foo: "bar", bar: nil)
       assert_equal ({"foo" => "bar", "bar" => nil}), filtered
       assert_equal nil, errors
     end
   end
-  
+
   describe "optional params and empty values" do
     it "bar is optional -- discards empty" do
       hf = Mutations::HashFilter.new do
@@ -112,12 +121,12 @@ describe "Mutations::HashFilter" do
           string :bar, discard_empty: true
         end
       end
-      
+
       filtered, errors = hf.filter(foo: "bar", bar: "")
       assert_equal ({"foo" => "bar"}), filtered
       assert_equal nil, errors
     end
-    
+
     it "bar is optional -- errors if discard_empty is false and value is blank" do
       hf = Mutations::HashFilter.new do
         required do
@@ -127,11 +136,11 @@ describe "Mutations::HashFilter" do
           string :bar, discard_empty: false
         end
       end
-      
+
       filtered, errors = hf.filter(foo: "bar", bar: "")
       assert_equal ({"bar" => :empty}), errors.symbolic
     end
-    
+
     it "bar is optional -- discards empty -- now with wildcards" do
       hf = Mutations::HashFilter.new do
         required do
@@ -141,12 +150,12 @@ describe "Mutations::HashFilter" do
           string :*, discard_empty: true
         end
       end
-      
+
       filtered, errors = hf.filter(foo: "bar", bar: "")
       assert_equal ({"foo" => "bar"}), filtered
       assert_equal nil, errors
     end
   end
-  
-  
+
+
 end

data/spec/inheritance_spec.rb

@@ -2,38 +2,38 @@ require_relative 'spec_helper'
 require 'simple_command'
 
 describe 'Mutations - inheritance' do
-  
+
   class SimpleInherited < SimpleCommand
-    
+
     required do
       integer :age
     end
-    
+
     def execute
       @filtered_input
     end
   end
-  
+
   it 'should filter with inherited command' do
     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
   end
-  
+
   it 'should filter with original command' do
     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
   end
-  
+
   it 'shouldnt collide' do
     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
-    
+
     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
   end
-  
+
 end

data/spec/integer_filter_spec.rb

@@ -1,28 +1,28 @@
 require_relative 'spec_helper'
 
 describe "Mutations::IntegerFilter" do
-  
+
   it "allows integers" do
     f = Mutations::IntegerFilter.new
     filtered, errors = f.filter(3)
     assert_equal 3, filtered
     assert_equal nil, errors
   end
-  
+
   it "allows strings that start with a digit" do
     f = Mutations::IntegerFilter.new
     filtered, errors = f.filter("3")
     assert_equal 3, filtered
     assert_equal nil, errors
   end
-  
+
   it "allows negative strings" do
     f = Mutations::IntegerFilter.new
     filtered, errors = f.filter("-3")
     assert_equal -3, filtered
     assert_equal nil, errors
   end
-  
+
   it "doesnt't allow other strings, nor does it allow random objects or symbols" do
     f = Mutations::IntegerFilter.new
     ["zero","a1", {}, [], Object.new, :d].each do |thing|
@@ -30,47 +30,47 @@ describe "Mutations::IntegerFilter" do
       assert_equal :integer, errors
     end
   end
-  
+
   it "considers nil to be invalid" do
     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)
     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)
     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)
     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)
     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)
     filtered, errors = f.filter(3)
     assert_equal 3, filtered
     assert_equal nil, errors
   end
-  
+
 end

data/spec/model_filter_spec.rb

@@ -1,21 +1,21 @@
 require_relative 'spec_helper'
 
 describe "Mutations::ModelFilter" do
-  
+
   class SimpleModel; end
   class AlwaysNew
     def new_record?
       true
     end
   end
-  
+
   class AlwaysSaved
     def new_record?
       false
     end
   end
-    
-  
+
+
   it "allows models" do
     f = Mutations::ModelFilter.new(:simple_model)
     m = SimpleModel.new
@@ -23,70 +23,70 @@ describe "Mutations::ModelFilter" do
     assert_equal m, filtered
     assert_equal nil, errors
   end
-  
+
   # it "disallows different types of models" do
   # end
-  
+
   it "raises an exception during initialization if constantization fails" do
     assert_raises NameError do
       Mutations::ModelFilter.new(:complex_model)
     end
   end
-  
+
   it "raises an exception during initialization if constantization of class fails" do
     assert_raises NameError do
       Mutations::ModelFilter.new(:simple_model, class: "ComplexModel")
     end
   end
-  
+
   it "raises an exception during initialization if constantization of builder fails" do
     assert_raises NameError do
       Mutations::ModelFilter.new(:simple_model, builder: "ComplexModel")
     end
   end
-  
+
   it "considers nil to be invalid" do
     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)
     filtered, errors = f.filter(nil)
     assert_equal nil, filtered
     assert_equal nil, errors
   end
-  
+
   # it "allows you to override class with a constant and succeed" do
   # end
-  # 
+  #
   # it "allows you to override class with a string and succeed" do
   # end
-  # 
+  #
   # it "allows you to override class and fail" do
   # end
-  # 
+  #
   # it "allows anything if new_record is true" do
   # end
-  # 
+  #
   # it "disallows new_records if new_record is false" do
   # end
-  # 
+  #
   # it "allows saved records if new_record is false" do
   # end
-  # 
+  #
   # it "allows other records if new_record is false" do
   # end
-  # 
+  #
   # it "allows you to build a record from a hash, and succeed" do
   # end
-  # 
+  #
   # it "allows you to build a record from a hash, and fail" do
   # end
-  # 
+  #
   # it "makes sure that if you build a record from a hash, it still has to be of the right class" do
   # end
-  
+
 end

data/spec/mutations_spec.rb

@@ -1,9 +1,9 @@
 require_relative 'spec_helper'
 
 describe 'Mutations' do
-  
+
   it 'should have a version' do
     assert Mutations::VERSION.is_a?(String)
   end
-  
+
 end

data/spec/simple_command.rb

@@ -1,14 +1,14 @@
 class SimpleCommand < Mutations::Command
-  
+
   required do
     string :name, max_length: 10
     string :email
   end
-  
+
   optional do
     integer :amount
   end
-  
+
   def execute
     inputs
   end

data/spec/string_filter_spec.rb

@@ -8,21 +8,21 @@ describe "Mutations::StringFilter" do
     assert_equal "hello", filtered
     assert_equal nil, errors
   end
-  
+
   it "allows symbols" do
     sf = Mutations::StringFilter.new
     filtered, errors = sf.filter(:hello)
     assert_equal "hello", filtered
     assert_equal nil, errors
   end
-  
+
   it "allows fixnums" do
     sf = Mutations::StringFilter.new
     filtered, errors = sf.filter(1)
     assert_equal "1", filtered
     assert_equal nil, errors
   end
-  
+
   it "disallows non-string" do
     sf = Mutations::StringFilter.new
     [["foo"], {a: "1"}, Object.new].each do |thing|
@@ -30,105 +30,105 @@ describe "Mutations::StringFilter" do
       assert_equal :string, errors
     end
   end
-  
+
   it "strips" do
     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)
     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)
     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)
     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)
     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)
     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)
     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)
     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)
     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)
     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)
     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/)
     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/)
     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))
     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))
     filtered, errors = sf.filter("red")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mutations
 version: !ruby/object:Gem::Version
-  version: 0.5.9
+  version: 0.5.10
   prerelease: 
 platform: ruby
 authors: