mutations 0.5.9 → 0.5.10

data/lib/mutations/integer_filter.rb

@@ -6,15 +6,15 @@ module Mutations
       min: nil,          # lowest value, inclusive
       max: nil           # highest value, inclusive
     }
-    
+
     def filter(data)
-      
+
       # Handle nil case
       if data.nil?
         return [nil, nil] if options[:nils]
         return [nil, :nils]
       end
-      
+
       # Ensure it's the correct data type (Fixnum)
       if !data.is_a?(Fixnum)
         if data.is_a?(String) && data =~ /^-?\d/
@@ -23,10 +23,10 @@ module Mutations
           return [data, :integer]
         end
       end
-      
+
       return [data, :min] if options[:min] && data < options[:min]
       return [data, :max] if options[:max] && data > options[:max]
-      
+
       # We win, it's valid!
       [data, nil]
     end

data/lib/mutations/model_filter.rb

@@ -6,47 +6,47 @@ module Mutations
       builder: nil,       # Could be a class or a string which will be constantized. If present, and a hash is passed, then we use that to construct a model
       new_records: false, # If false, unsaved AR records are not valid. Things that don't respond to new_record? are valid.  true: anything is valid
     }
-    
+
     def initialize(name, opts = {})
       super(opts)
       @name = name
-      
+
       class_const = options[:class] || @name.to_s.camelize
       class_const = class_const.constantize if class_const.is_a?(String)
       self.options[:class] = class_const
-      
+
       if options[:builder]
         options[:builder] = options[:builder].constantize if options[:builder].is_a?(String)
       end
     end
-    
+
     def filter(data)
-      
+
       # Handle nil case
       if data.nil?
         return [nil, nil] if options[:nils]
         return [nil, :nils]
       end
-      
+
       # Passing in attributes.  Let's see if we have a builder
       if data.is_a?(Hash) && options[:builder]
         ret = options[:builder].run(data)
-        
+
         if ret.success?
           data = ret.result
         else
           return [data, ret.errors]
         end
       end
-      
+
       # We have a winner, someone passed in the correct data type!
       if data.is_a?(options[:class])
         return [data, :new_records] if !options[:new_records] && (data.respond_to?(:new_record?) && data.new_record?)
         return [data, nil]
       end
-      
+
       return [data, :model]
     end
-    
+
   end
 end

data/lib/mutations/outcome.rb

@@ -3,7 +3,7 @@ module Mutations
     def initialize(is_success, result, errors)
       @success, @result, @errors = is_success, result, errors
     end
-    
+
     def success?
       @success
     end

data/lib/mutations/string_filter.rb

@@ -11,24 +11,24 @@ module Mutations
       in: nil,              # Can be an array like %w(red blue green)
       discard_empty: false  # If the param is optional, discard_empty: true drops empty fields.
     }
-    
+
     def filter(data)
-      
+
       # Handle nil case
       if data.nil?
         return [nil, nil] if options[:nils]
         return [nil, :nils]
       end
-      
+
       # At this point, data is not nil. If it's not a string, convert it to a string for some standard classes
       data = data.to_s if !options[:strict] && [TrueClass, FalseClass, Fixnum, Symbol].include?(data.class)
-      
+
       # Now ensure it's a string:
       return [data, :string] unless data.is_a?(String)
-      
+
       # At this point, data is a string.  Now transform it using strip:
       data = data.strip if options[:strip]
-      
+
       # Now check if it's blank:
       if data == ""
         if options[:empty]
@@ -37,17 +37,17 @@ module Mutations
           return [data, :empty]
         end
       end
-      
+
       # Now check to see if it's the correct size:
       return [data, :min_length] if options[:min_length] && data.length < options[:min_length]
       return [data, :max_length] if options[:max_length] && data.length > options[:max_length]
-      
+
       # Ensure it match
       return [data, :in] if options[:in] && !options[:in].include?(data)
-      
+
       # Ensure it matches the regexp
       return [data, :matches] if options[:matches] && (options[:matches] !~ data)
-      
+
       # We win, it's valid!
       [data, nil]
     end

data/lib/mutations/version.rb

@@ -1,3 +1,3 @@
 module Mutations
-  VERSION = "0.5.9"
+  VERSION = "0.5.10"
 end

data/mutations.gemspec

@@ -15,6 +15,6 @@ Gem::Specification.new do |s|
   s.add_dependency 'activesupport'
   s.add_development_dependency 'minitest', '~> 4'
   s.add_development_dependency 'rake'
-  
+
   s.required_ruby_version = '>= 1.9.2'
 end

data/spec/array_filter_spec.rb

@@ -1,14 +1,14 @@
 require_relative 'spec_helper'
 
 describe "Mutations::ArrayFilter" do
-  
+
   it "allows arrays" do
     f = Mutations::ArrayFilter.new(:arr)
     filtered, errors = f.filter([1])
     assert_equal [1], filtered
     assert_equal nil, errors
   end
-  
+
   it "considers non-arrays to be invalid" do
     f = Mutations::ArrayFilter.new(:arr)
     ['hi', true, 1, {a: "1"}, Object.new].each do |thing|
@@ -16,90 +16,98 @@ describe "Mutations::ArrayFilter" do
       assert_equal :array, errors
     end
   end
-  
+
   it "considers nil to be invalid" do
     f = Mutations::ArrayFilter.new(:arr, 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::ArrayFilter.new(:arr, nils: true)
     filtered, errors = f.filter(nil)
     filtered, errors = f.filter(nil)
     assert_equal nil, errors
   end
-  
+
   it "lets you specify a class, and has valid elements" do
     f = Mutations::ArrayFilter.new(:arr, class: Fixnum)
     filtered, errors = f.filter([1,2,3])
     assert_equal nil, errors
     assert_equal [1,2,3], filtered
   end
-  
+
   it "lets you specify a class as a string, and has valid elements" do
     f = Mutations::ArrayFilter.new(:arr, class: 'Fixnum')
     filtered, errors = f.filter([1,2,3])
     assert_equal nil, errors
     assert_equal [1,2,3], filtered
   end
-  
+
   it "lets you specify a class, and has invalid elements" do
     f = Mutations::ArrayFilter.new(:arr, class: Fixnum)
     filtered, errors = f.filter([1, "bob"])
     assert_equal [nil, :class], errors.symbolic
     assert_equal [1,"bob"], filtered
   end
-  
+
   it "lets you use a block to supply an element filter" do
     f = Mutations::ArrayFilter.new(:arr) { string }
-    
+
     filtered, errors = f.filter(["hi", {stuff: "ok"}])
     assert_nil errors[0]
     assert_equal :string, errors[1].symbolic
   end
-  
+
   it "lets you array-ize everything" do
     f = Mutations::ArrayFilter.new(:arr, arrayize: true) { string }
-    
+
     filtered, errors = f.filter("foo")
     assert_equal ["foo"], filtered
     assert_nil errors
   end
-  
+
   it "lets you array-ize an empty string" do
     f = Mutations::ArrayFilter.new(:arr, arrayize: true) { string }
-    
+
     filtered, errors = f.filter("")
     assert_equal [], filtered
     assert_nil errors
   end
-  
+
   it "lets you pass integers in arrays" do
     f = Mutations::ArrayFilter.new(:arr) { integer min: 4 }
-    
+
     filtered, errors = f.filter([5,6,1,"bob"])
     assert_equal [5,6,1,"bob"], filtered
     assert_equal [nil, nil, :min, :integer], errors.symbolic
   end
-  
+
+  it "lets you pass floats in arrays" do
+    f = Mutations::ArrayFilter.new(:float) { float min: 4.0 }
+
+    filtered, errors = f.filter([5.0,6.0,1.0,"bob"])
+    assert_equal [5.0,6.0,1.0,"bob"], filtered
+    assert_equal [nil, nil, :min, :float], errors.symbolic
+  end
+
   it "lets you pass booleans in arrays" do
     f = Mutations::ArrayFilter.new(:arr) { boolean }
-    
+
     filtered, errors = f.filter([true, false, "1"])
     assert_equal [true, false, true], filtered
     assert_equal nil, errors
   end
-  
+
   it "lets you pass model in arrays" do
     f = Mutations::ArrayFilter.new(:arr) { model :string }
-    
+
     filtered, errors = f.filter(["hey"])
     assert_equal ["hey"], filtered
     assert_equal nil, errors
   end
-  
+
   it "lets you pass hashes in arrays" do
     f = Mutations::ArrayFilter.new(:arr) do
       hash do
@@ -107,44 +115,44 @@ describe "Mutations::ArrayFilter" do
           string :foo
           integer :bar
         end
-        
+
         optional do
           boolean :baz
         end
       end
     end
-    
+
     filtered, errors = f.filter([{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"}], filtered
-    
+
     assert_equal nil, errors[0]
     assert_equal nil, errors[1]
     assert_equal ({"bar"=>:required}), errors[2].symbolic
   end
-  
+
   it "lets you pass arrays of arrays" do
     f = Mutations::ArrayFilter.new(:arr) do
       array do
         string
       end
     end
-    
+
     filtered, errors = f.filter([["h", "e"], ["l"], [], ["lo"]])
     assert_equal filtered, [["h", "e"], ["l"], [], ["lo"]]
     assert_equal nil, errors
   end
-  
+
   it "handles errors for arrays of arrays" do
     f = Mutations::ArrayFilter.new(:arr) do
       array do
         string
       end
     end
-    
+
     filtered, errors = f.filter([["h", "e", {}], ["l"], [], [""]])
     assert_equal [[nil, nil, :string], nil, nil, [:empty]], errors.symbolic
     assert_equal [[nil, nil, "Array[2] isn't a string"], nil, nil, ["Array[0] can't be blank"]], errors.message
     assert_equal ["Array[2] isn't a string", "Array[0] can't be blank"], errors.message_list
   end
-  
+
 end

data/spec/boolean_filter_spec.rb

@@ -1,18 +1,18 @@
 require_relative 'spec_helper'
 
 describe "Mutations::BooleanFilter" do
-  
+
   it "allows booleans" do
     f = Mutations::BooleanFilter.new
     filtered, errors = f.filter(true)
     assert_equal true, filtered
     assert_equal nil, errors
-    
+
     filtered, errors = f.filter(false)
     assert_equal false, filtered
     assert_equal nil, errors
   end
-  
+
   it "considers non-booleans to be invalid" do
     f = Mutations::BooleanFilter.new
     [[true], {a: "1"}, Object.new].each do |thing|
@@ -20,21 +20,21 @@ describe "Mutations::BooleanFilter" do
       assert_equal :boolean, errors
     end
   end
-  
+
   it "considers nil to be invalid" do
     f = Mutations::BooleanFilter.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::BooleanFilter.new(nils: true)
     filtered, errors = f.filter(nil)
     assert_equal nil, filtered
     assert_equal nil, errors
   end
-  
+
   it "considers certain strings to be valid booleans" do
     f = Mutations::BooleanFilter.new
     [["true", true], ["TRUE", true], ["TrUe", true], ["1", true], ["false", false], ["FALSE", false], ["FalSe", false], ["0", false], [0, false], [1, true]].each do |(str, v)|
@@ -43,7 +43,7 @@ describe "Mutations::BooleanFilter" do
       assert_equal nil, errors
     end
   end
-  
+
   it "considers other string to be invalid" do
     f = Mutations::BooleanFilter.new
     ["", "truely", "2"].each do |str|

data/spec/command_spec.rb

@@ -2,7 +2,7 @@ require_relative 'spec_helper'
 require 'simple_command'
 
 describe "Command" do
-  
+
   describe "SimpleCommand" do
     it "should allow valid in put in" do
       outcome = SimpleCommand.run(name: "John", email: "john@gmail.com", amount: 5)
@@ -11,166 +11,166 @@ describe "Command" do
       assert_equal ({name: "John", email: "john@gmail.com", amount: 5}).stringify_keys, outcome.result
       assert_equal nil, outcome.errors
     end
-    
+
     it "should filter out spurious params" do
       outcome = SimpleCommand.run(name: "John", email: "john@gmail.com", amount: 5, buggers: true)
-      
+
       assert outcome.success?
       assert_equal ({name: "John", email: "john@gmail.com", amount: 5}).stringify_keys, outcome.result
       assert_equal nil, outcome.errors
     end
-    
+
     it "should discover errors in inputs" do
       outcome = SimpleCommand.run(name: "JohnTooLong", email: "john@gmail.com")
-      
+
       assert !outcome.success?
       assert_equal :max_length, outcome.errors.symbolic[:name]
     end
-    
+
     it "shouldn't throw an exception with run!" do
       result = SimpleCommand.run!(name: "John", email: "john@gmail.com", amount: 5)
       assert_equal ({name: "John", email: "john@gmail.com", amount: 5}).stringify_keys, result
     end
-    
+
     it "should throw an exception with run!" do
       assert_raises Mutations::ValidationException do
         result = SimpleCommand.run!(name: "John", email: "john@gmail.com", amount: "bob")
       end
     end
-    
+
     it "should do standalone validation" do
       outcome = SimpleCommand.validate(name: "JohnLong", email: "john@gmail.com")
       assert outcome.success?
       assert_nil outcome.result
       assert_nil outcome.errors
-      
+
       outcome = SimpleCommand.validate(name: "JohnTooLong", email: "john@gmail.com")
       assert !outcome.success?
       assert_nil outcome.result
       assert_equal :max_length, outcome.errors.symbolic[:name]
     end
-    
+
     it "should merge multiple hashes" do
       outcome = SimpleCommand.run({name: "John", email: "john@gmail.com"}, {email: "bob@jones.com", amount: 5})
-      
+
       assert outcome.success?
       assert_equal ({name: "John", email: "bob@jones.com", amount: 5}).stringify_keys, outcome.result
     end
-    
+
     it "should merge hashes indifferently" do
       outcome = SimpleCommand.run({name: "John", email: "john@gmail.com"}, {"email" => "bob@jones.com", "amount" => 5})
-      
+
       assert outcome.success?
       assert_equal ({name: "John", email: "bob@jones.com", amount: 5}).stringify_keys, outcome.result
     end
-    
+
     it "shouldn't accept non-hashes" do
       assert_raises ArgumentError do
         outcome = SimpleCommand.run(nil)
       end
-      
+
       assert_raises ArgumentError do
         outcome = SimpleCommand.run(1)
       end
     end
-    
+
     it "should accept nothing at all" do
       SimpleCommand.run # make sure nothing is raised
     end
   end
-  
+
   describe "EigenCommand" do
     class EigenCommand < Mutations::Command
-  
+
       required { string :name }
       optional { string :email }
-  
+
       def execute
         {name: name, email: email}
       end
     end
-  
+
     it "should define getter methods on params" do
       mutation = EigenCommand.run(name: "John", email: "john@gmail.com")
       assert_equal ({name: "John", email: "john@gmail.com"}), mutation.result
     end
   end
-  
+
   describe "MutatatedCommand" do
     class MutatatedCommand < Mutations::Command
-  
+
       required { string :name }
       optional { string :email }
-  
+
       def execute
         self.name, self.email = "bob", "bob@jones.com"
         {name: inputs[:name], email: inputs[:email]}
       end
     end
-  
+
     it "should define setter methods on params" do
       mutation = MutatatedCommand.run(name: "John", email: "john@gmail.com")
       assert_equal ({name: "bob", email: "bob@jones.com"}), mutation.result
     end
   end
-  
+
   describe "ErrorfulCommand" do
     class ErrorfulCommand < Mutations::Command
-  
+
       required { string :name }
       optional { string :email }
-  
+
       def execute
         add_error("bob", :is_a_bob)
-        
+
         1
       end
     end
-  
+
     it "should let you add errors" do
       outcome = ErrorfulCommand.run(name: "John", email: "john@gmail.com")
-      
+
       assert !outcome.success?
       assert_nil outcome.result
       assert :is_a_bob, outcome.errors.symbolic[:bob]
     end
   end
-  
+
   describe "MultiErrorCommand" do
     class ErrorfulCommand < Mutations::Command
-  
+
       required { string :name }
       optional { string :email }
-  
+
       def execute
         moar_errors = Mutations::ErrorHash.new
         moar_errors[:bob] = Mutations::ErrorAtom.new(:bob, :is_short)
         moar_errors[:sally] = Mutations::ErrorAtom.new(:sally, :is_fat)
-        
+
         merge_errors(moar_errors)
-        
+
         1
       end
     end
-  
+
     it "should let you merge errors" do
       outcome = ErrorfulCommand.run(name: "John", email: "john@gmail.com")
-      
+
       assert !outcome.success?
       assert_nil outcome.result
       assert :is_short, outcome.errors.symbolic[:bob]
       assert :is_fat, outcome.errors.symbolic[:sally]
     end
   end
-  
+
   describe "PresentCommand" do
     class PresentCommand < Mutations::Command
-  
+
       optional do
         string :email
         string :name
       end
-  
+
       def execute
         if name_present? && email_present?
           1
@@ -183,7 +183,7 @@ describe "Command" do
         end
       end
     end
-  
+
     it "should handle *_present? methods" do
       assert_equal 1, PresentCommand.run!(name: "John", email: "john@gmail.com")
       assert_equal 2, PresentCommand.run!(email: "john@gmail.com")
@@ -191,5 +191,5 @@ describe "Command" do
       assert_equal 4, PresentCommand.run!
     end
   end
-  
+
 end