mutations 0.5.9 → 0.5.10

data/README.md

@@ -7,7 +7,7 @@ Compose your business logic into commands that sanitize and validate input. Writ
 ## Installation
 
     gem install mutations
-    
+
 Or add it to your Gemfile:
 
     gem 'mutations'
@@ -23,12 +23,12 @@ class UserSignup < Mutations::Command
     string :email, matches: EMAIL_REGEX
     string :name
   end
-  
+
   # These inputs are optional
   optional do
     boolean :newsletter_subscribe
   end
-  
+
   # The execute method is called only if the inputs validate. It does your business action.
   def execute
     user = User.create!(inputs)
@@ -54,7 +54,7 @@ end
 Some things to note about the example:
 
 * We don't need attr_accessible or strong_attributes to protect against mass assignment attacks
-* We're guaranteed that within execute, the inputs will be the correct data types, even if they needed some coercion (all strings are stripped by default, and strings like "1" / "0" are converted to true/false for newsletter_subscribe) 
+* We're guaranteed that within execute, the inputs will be the correct data types, even if they needed some coercion (all strings are stripped by default, and strings like "1" / "0" are converted to true/false for newsletter_subscribe)
 * We don't need ActiveRecord validations
 * We don't need callbacks on our models -- everything is in the execute method (helper methods are also encouraged)
 * We don't use accepts_nested_attributes_for, even though multiple ActiveRecord models are created
@@ -119,7 +119,7 @@ class CreateComment < Mutations::Command
     model :article
     string :comment, max_length: 500
   end
-  
+
   def execute; ...; end
 end
 
@@ -186,7 +186,7 @@ Your execute method has access to the inputs passed into it:
 ```ruby
 self.inputs # white-listed hash of all inputs passed to run.  Hash has indifferent access.
 ```
-    
+
 If you define an input called _email_, then you'll have these three methods:
 
 ```ruby

data/lib/mutations/array_filter.rb

@@ -5,57 +5,61 @@ module Mutations
       class: nil,             # A constant or string indicates that each element of the array needs to be one of these classes
       arrayize: false         # true will convert "hi" to ["hi"]. "" converts to []
     }
-    
+
     def initialize(name, opts = {}, &block)
       super(opts)
-      
+
       @name = name
       @element_filter = nil
-      
+
       if block_given?
         instance_eval &block
       end
-      
+
       raise ArgumentError.new("Can't supply both a class and a filter") if @element_filter && self.options[:class]
     end
-    
+
     def string(options = {})
       @element_filter = StringFilter.new(options)
     end
-    
+
     def integer(options = {})
       @element_filter = IntegerFilter.new(options)
     end
-    
+
+    def float(options = {})
+      @element_filter = FloatFilter.new(options)
+    end
+
     def boolean(options = {})
       @element_filter = BooleanFilter.new(options)
     end
-    
+
     def hash(options = {}, &block)
       @element_filter = HashFilter.new(options, &block)
     end
-    
+
     # Advanced types
     def model(name, options = {})
       @element_filter = ModelFilter.new(name.to_sym, options)
     end
-    
+
     def array(options = {}, &block)
       @element_filter = ArrayFilter.new(nil, options, &block)
     end
-    
+
     def filter(data)
       # Handle nil case
       if data.nil?
         return [nil, nil] if options[:nils]
         return [nil, :nils]
       end
-      
+
       if !data.is_a?(Array) && options[:arrayize]
         return [[], nil] if data == ""
         data = Array(data)
       end
-      
+
       if data.is_a?(Array)
         errors = ErrorArray.new
         filtered_data = []
@@ -63,14 +67,14 @@ module Mutations
         data.each_with_index do |el, i|
           el_filtered, el_error = filter_element(el)
           el_error = ErrorAtom.new(@name, el_error, index: i) if el_error.is_a?(Symbol)
-          
+
           errors << el_error
           found_error = true if el_error
           if !found_error
             filtered_data << el_filtered
           end
         end
-        
+
         if found_error
           [data, errors]
         else
@@ -80,22 +84,22 @@ module Mutations
         return [data, :array]
       end
     end
-    
+
     # Returns [filtered, errors]
     def filter_element(data)
-      
+
       if @element_filter
         data, el_errors = @element_filter.filter(data)
         return [data, el_errors] if el_errors
       elsif options[:class]
         class_const = options[:class]
         class_const = class_const.constantize if class_const.is_a?(String)
-        
+
         if !data.is_a?(class_const)
           return [data, :class]
         end
       end
-      
+
       [data, nil]
     end
   end

data/lib/mutations/boolean_filter.rb

@@ -3,23 +3,23 @@ module Mutations
     @default_options = {
       nils: false   # true allows an explicit nil to be valid. Overrides any other options
     }
-    
+
     BOOL_MAP = {"true" => true, "1" => true, "false" => false, "0" => false}
-    
+
     def filter(data)
-      
+
       # Handle nil case
       if data.nil?
         return [nil, nil] if options[:nils]
         return [nil, :nils]
       end
-      
+
       # If data is true or false, we win.
       return [data, nil] if data == true || data == false
-      
+
       # If data is a Fixnum, like 1, let's convert it to a string first
       data = data.to_s if data.is_a?(Fixnum)
-      
+
       # If data's a string, try to convert it to a boolean. If we can't, it's invalid.
       if data.is_a?(String)
         res = BOOL_MAP[data.downcase]

data/lib/mutations/command.rb

@@ -11,51 +11,51 @@
 
 module Mutations
   class Command
-    
+
+    ##
     ##
-    ## 
     ##
     class << self
       def required(&block)
         self.input_filters.required(&block)
-        
+
         self.input_filters.required_keys.each do |key|
-          define_method(key) do 
+          define_method(key) do
             @filtered_input[key]
           end
-          
-          define_method("#{key}_present?") do 
+
+          define_method("#{key}_present?") do
             @filtered_input.has_key?(key)
           end
-          
+
           define_method("#{key}=") do |v|
             @filtered_input[key] = v
           end
         end
       end
-      
+
       def optional(&block)
         self.input_filters.optional(&block)
-        
+
         self.input_filters.optional_keys.each do |key|
-          define_method(key) do 
+          define_method(key) do
             @filtered_input[key]
           end
-          
-          define_method("#{key}_present?") do 
+
+          define_method("#{key}_present?") do
             @filtered_input.has_key?(key)
           end
-          
+
           define_method("#{key}=") do |v|
             @filtered_input[key] = v
           end
         end
       end
-      
+
       def run(*args)
         new(*args).execute!
       end
-      
+
       def run!(*args)
         m = run(*args)
         if m.success?
@@ -64,12 +64,12 @@ module Mutations
           raise ValidationException.new(m.errors)
         end
       end
-      
+
       # Validates input, but doesn't call execute. Returns an Outcome with errors anyway.
       def validate(*args)
         new(*args).validation_outcome
       end
-      
+
       def input_filters
         @input_filters ||= begin
           if Command == self.superclass
@@ -79,9 +79,9 @@ module Mutations
           end
         end
       end
-      
+
     end
-  
+
     # Instance methods
     def initialize(*args)
       if args.length == 0
@@ -91,24 +91,24 @@ module Mutations
         raise ArgumentError.new("All arguments must be hashes") unless @original_hash.is_a?(Hash)
         @original_hash = @original_hash.with_indifferent_access
       end
-      
+
       args.each do |a|
         raise ArgumentError.new("All arguments must be hashes") unless a.is_a?(Hash)
         @original_hash.merge!(a)
       end
-      
+
       @filtered_input, @errors = self.input_filters.filter(@original_hash)
     end
-    
+
     def input_filters
       self.class.input_filters
     end
-    
+
     def execute!
       return Outcome.new(false, nil, @errors) if @errors
-      
+
       # IDEA/TODO: run validate block
-      
+
       r = execute
       if @errors # Execute can add errors
         return Outcome.new(false, nil, @errors)
@@ -116,7 +116,7 @@ module Mutations
         return Outcome.new(true, r, nil)
       end
     end
-    
+
     # Runs input thru the filter and sets @filtered_input and @errors
     def validation_outcome
       if @errors
@@ -125,14 +125,14 @@ module Mutations
         Outcome.new(true, nil,  nil)
       end
     end
-    
+
     # add_error("name", :too_short)
     # add_error("colors.foreground", :not_a_color) # => to create errors = {colors: {foreground: :not_a_color}}
     # or, supply a custom message:
     # add_error("name", :too_short, "The name 'blahblahblah' is too short!")
     def add_error(key, kind, message = nil)
       raise ArgumentError.new("Invalid kind") unless kind.is_a?(Symbol)
-      
+
       @errors ||= ErrorHash.new
       cur_errors = @errors
       parts = key.to_s.split(".")
@@ -147,16 +147,16 @@ module Mutations
       end
       @errors
     end
-    
+
     def merge_errors(hash)
       @errors ||= ErrorHash.new
       @errors.merge!(hash)
     end
-    
+
     def inputs
       @filtered_input
     end
-    
+
     def execute
       # Meant to be overridden
     end

data/lib/mutations/errors.rb

@@ -1,14 +1,14 @@
 module Mutations
-  
+
   # Offers a non-localized, english only, non configurable way to get error messages.  This probably isnt good enough for users as-is.
   class DefaultErrorMessageCreator
-    
+
     MESSAGES = Hash.new("is invalid").tap do |h|
       h.merge!(
         # General
         nils: "can't be nil",
         required: "is required",
-      
+
         # Datatypes
         string: "isn't a string",
         integer: "isn't an integer",
@@ -16,26 +16,26 @@ module Mutations
         hash: "isn't a hash",
         array: "isn't an array",
         model: "isn't the right class",
-        
+
         # String
         empty: "can't be blank",
         max_length: "is too long",
         min_length: "is too short",
         matches: "isn't in the right format",
         in: "isn't an option",
-        
+
         # Array
         class: "isn't the right class",
-        
+
         # Integer
         min: "is too small",
         max: "is too big",
-        
+
         # Model
         new_records: "isn't a saved model"
       )
     end
-    
+
     # key: the name of the field, eg, :email. Could be nil if it's an array element
     # error_symbol: the validation symbol, eg, :matches or :required
     # options:
@@ -49,7 +49,7 @@ module Mutations
     end
   end
 
-  
+
   class ErrorAtom
 
     # NOTE: in the future, could also pass in:
@@ -138,7 +138,7 @@ module Mutations
       list
     end
   end
-  
+
   class ErrorArray < Array
     def symbolic
       map {|e| e && e.symbolic }

data/lib/mutations/exception.rb

@@ -1,11 +1,11 @@
 module Mutations
   class ValidationException < ::StandardError
     attr_accessor :errors
-    
+
     def initialize(errors)
       self.errors = errors
     end
-    
+
     def to_s
       "#{self.errors.message_list.join('; ')}"
     end

data/lib/mutations/hash_filter.rb

@@ -3,22 +3,22 @@ module Mutations
     @default_options = {
       nils: false,            # true allows an explicit nil to be valid. Overrides any other options
     }
-    
+
     attr_accessor :optional_inputs
     attr_accessor :required_inputs
-    
+
     def initialize(opts = {}, &block)
       super(opts)
-      
+
       @optional_inputs = {}
       @required_inputs = {}
       @current_inputs = @required_inputs
-      
+
       if block_given?
         instance_eval &block
       end
     end
-    
+
     def dup
       dupped = HashFilter.new
       @optional_inputs.each_pair do |k, v|
@@ -29,96 +29,100 @@ module Mutations
       end
       dupped
     end
-    
+
     def required(&block)
       # TODO: raise if nesting is wrong
       @current_inputs = @required_inputs
       instance_eval &block
     end
-    
+
     def optional(&block)
       # TODO: raise if nesting is wrong
       @current_inputs = @optional_inputs
       instance_eval &block
     end
-    
+
     def required_keys
       @required_inputs.keys
     end
-    
+
     def optional_keys
       @optional_inputs.keys
     end
-    
+
     # Basic types:
     def string(name, options = {})
       @current_inputs[name.to_sym] = StringFilter.new(options)
     end
-    
+
     def integer(name, options = {})
       @current_inputs[name.to_sym] = IntegerFilter.new(options)
     end
-    
+
+    def float(name, options = {})
+      @current_inputs[name.to_sym] = FloatFilter.new(options)
+    end
+
     def boolean(name, options = {})
       @current_inputs[name.to_sym] = BooleanFilter.new(options)
     end
-    
+
     def hash(name, options = {}, &block)
       @current_inputs[name.to_sym] = HashFilter.new(options, &block)
     end
-    
+
     # Advanced types
     def model(name, options = {})
       name_sym = name.to_sym
       @current_inputs[name_sym] = ModelFilter.new(name_sym, options)
     end
-    
+
     def array(name, options = {}, &block)
       name_sym = name.to_sym
       @current_inputs[name.to_sym] = ArrayFilter.new(name_sym, options, &block)
     end
-    
+
     def filter(data)
-      
+
       # Handle nil case
       if data.nil?
         return [nil, nil] if options[:nils]
         return [nil, :nils]
       end
-      
+
       # Ensure it's a hash
       return [data, :hash] unless data.is_a?(Hash)
-      
+
       # We always want a hash with indiffernet access
       unless data.is_a?(HashWithIndifferentAccess)
         data = data.with_indifferent_access
       end
-      
+
       errors = ErrorHash.new
       filtered_data = HashWithIndifferentAccess.new
       wildcard_filterer = nil
-      
+
       [[@required_inputs, true], [@optional_inputs, false]].each do |(inputs, is_required)|
         inputs.each_pair do |key, filterer|
-          
+
           # If we are doing wildcards, then record so and move on
           if key == :*
             wildcard_filterer = filterer
             next
           end
-          
+
           data_element = data[key]
-          
+
           # First, discard optional nils/empty params
           data.delete(key) if !is_required && data.has_key?(key) && filterer.discard_nils? && data_element.nil?
           data.delete(key) if !is_required && data.has_key?(key) && filterer.discard_empty? && data_element == ""
-          
+
           default_used = false
           if !data.has_key?(key) && filterer.has_default?
             data_element = filterer.default
             default_used = true
           end
-          
+
           if data.has_key?(key) || default_used
             sub_data, sub_error = filterer.filter(data_element)
 
@@ -133,17 +137,17 @@ module Mutations
           end
         end
       end
-      
+
       if wildcard_filterer
         filtered_keys = data.keys - filtered_data.keys
-        
+
         filtered_keys.each do |key|
           data_element = data[key]
-          
+
           # First, discard optional nils/empty params
           next if data.has_key?(key) && wildcard_filterer.discard_nils? && data_element.nil?
           next if data.has_key?(key) && wildcard_filterer.discard_empty? && data_element == ""
-          
+
           sub_data, sub_error = wildcard_filterer.filter(data_element)
           if sub_error.nil?
             filtered_data[key] = sub_data
@@ -153,7 +157,7 @@ module Mutations
           end
         end
       end
-      
+
       if errors.any?
         [data, errors]
       else

data/lib/mutations/input_filter.rb

@@ -1,36 +1,36 @@
 module Mutations
   class InputFilter
     @default_options = {}
-    
+
     def self.default_options
       @default_options
     end
-    
+
     attr_accessor :options
-    
+
     def initialize(opts = {})
       self.options = (self.class.default_options || {}).merge(opts)
     end
-    
+
     # returns -> [sanitized data, error]
     # If an error is returned, then data will be nil
     def filter(data)
       [data, nil]
     end
-    
+
     def has_default?
       options.has_key?(:default)
     end
-    
+
     def default
       options[:default]
     end
-    
+
     # Only relevant for optional params
     def discard_nils?
       !options[:nils]
     end
-    
+
     def discard_empty?
       options[:discard_empty]
     end