mutations 0.5.2 → 0.5.3

data/lib/mutations/exception.rb

@@ -7,7 +7,7 @@ module Mutations
     end
     
     def to_s
-      "Mutations::ValidationException: #{self.errors.message_list.join('; ')}"
+      "#{self.errors.message_list.join('; ')}"
     end
   end
 end

data/lib/mutations/hash_filter.rb

@@ -2,17 +2,30 @@ module Mutations
   class HashFilter < InputFilter
     @default_options = {
       nils: false,            # true allows an explicit nil to be valid. Overrides any other options
+      key_class: nil,         # Can be a string or Class. If present, all keys must be of this class. Note that this field can't be set if a block is passed.
+      value_class: nil        # Can be a string or Class. If present, all values must be of this class. Note that this field can't be set if a block is passed.
     }
     
+    attr_accessor :general_inputs  # defaults to false
     attr_accessor :optional_inputs
     attr_accessor :required_inputs
     
+    # There's two types of Hash filters:
+    #  - those that accept specific inputs (eg, the hash needs to have an email key with a string value matching %r{...})
+    #  - those that accept general hashes (eg, the hash needs to have String keys and values, but can have any such k/v's)
     def initialize(opts = {}, &block)
       super(opts)
       
-      @optional_inputs = {}
-      @required_inputs = {}
-      @current_inputs = @required_inputs
+      raise ArgumentError, "Can't use key_class/value_class with a block." if block_given? && (options[:key_class] || options[:value_class])
+      
+      if options[:key_class] || options[:value_class]
+        @general_inputs = true
+      else
+        @general_inputs = false
+        @optional_inputs = {}
+        @required_inputs = {}
+        @current_inputs = @required_inputs
+      end
       
       if block_given?
         instance_eval &block
@@ -27,16 +40,21 @@ module Mutations
       @required_inputs.each_pair do |k, v|
         dupped.required_inputs[k] = v
       end
+      dupped.general_inputs = @general_inputs
       dupped
     end
     
     def required(&block)
+      raise ArgumentError, "Can't use specific filters if you're filtering by key." if general_inputs
+      
       # TODO: raise if nesting is wrong
       @current_inputs = @required_inputs
       instance_eval &block
     end
     
     def optional(&block)
+      raise ArgumentError, "Can't use specific filters if you're filtering by key." if general_inputs
+      
       # TODO: raise if nesting is wrong
       @current_inputs = @optional_inputs
       instance_eval &block
@@ -64,6 +82,9 @@ module Mutations
     end
     
     def hash(name, options = {}, &block)
+      unless block_given?
+        options.reverse_merge!(key_class: String, value_class: String)
+      end
       @current_inputs[name.to_sym] = HashFilter.new(options, &block)
     end
     
@@ -97,26 +118,46 @@ module Mutations
       errors = ErrorHash.new
       filtered_data = HashWithIndifferentAccess.new
       
-      [[@required_inputs, true], [@optional_inputs, false]].each do |(inputs, is_required)|
-        inputs.each_pair do |key, filterer|
-          data_element = data[key]
-          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)
-
-            if sub_error.nil?
-              filtered_data[key] = sub_data
+      if @general_inputs
+        key_class_const = options[:key_class] || raise
+        key_class_const = key_class_const.constantize if key_class_const.is_a?(String)
+        
+        value_class_const = options[:value_class] || raise
+        value_class_const = value_class_const.constantize if value_class_const.is_a?(String)
+        data.each_pair do |k, v|
+          if k.is_a?(key_class_const) && v.is_a?(value_class_const)
+            filtered_data[k] = v
+          else
+            k_string = k.to_s
+            if !k.is_a?(key_class_const)
+              errors[k_string] = ErrorAtom.new(k_string, :key_class)
             else
-              sub_error = ErrorAtom.new(key, sub_error) if sub_error.is_a?(Symbol)
-              errors[key] = sub_error
+              errors[k_string] = ErrorAtom.new(k_string, :value_class)
+            end
+          end
+        end
+      else
+        [[@required_inputs, true], [@optional_inputs, false]].each do |(inputs, is_required)|
+          inputs.each_pair do |key, filterer|
+            data_element = data[key]
+            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)
+      
+              if sub_error.nil?
+                filtered_data[key] = sub_data
+              else
+                sub_error = ErrorAtom.new(key, sub_error) if sub_error.is_a?(Symbol)
+                errors[key] = sub_error
+              end
+            elsif is_required
+              errors[key] = ErrorAtom.new(key, :required)
             end
-          elsif is_required
-            errors[key] = ErrorAtom.new(key, :required)
           end
         end
       end

data/lib/mutations/version.rb

@@ -1,3 +1,3 @@
 module Mutations
-  VERSION = "0.5.2"
+  VERSION = "0.5.3"
 end

data/spec/hash_filter_spec.rb

@@ -0,0 +1,41 @@
+require_relative 'spec_helper'
+
+describe "Mutations::HashFilter" do
+
+  it "allows valid hashes" do
+    hf = Mutations::HashFilter.new do
+      string :foo
+    end
+    filtered, errors = hf.filter(foo: "bar")
+    assert_equal ({"foo" => "bar"}), filtered
+    assert_equal nil, errors
+  end
+  
+  it 'disallows non-hashes' do
+    hf = Mutations::HashFilter.new do
+      string :foo
+    end
+    filtered, errors = hf.filter("bar")
+    assert_equal :hash, errors
+  end
+  
+  it 'allows general hashes' do
+    hf = Mutations::HashFilter.new(key_class: String, value_class: Symbol)
+    filtered, errors = hf.filter("f1" => :v1, "f2" => :v2)
+    assert_equal ({"f1" => :v1, "f2" => :v2}), filtered
+    assert_equal nil, errors
+  end
+  
+  it 'doesnt allows invalid general hashes (wrong value type)' do
+    hf = Mutations::HashFilter.new(key_class: String, value_class: Symbol)
+    filtered, errors = hf.filter("f1" => "v1", "f2" => :v2)
+    assert_equal ({"f1" => :value_class}), errors.symbolic
+  end
+  
+  it 'doesnt allows invalid general hashes (wrong key type)' do
+    hf = Mutations::HashFilter.new(key_class: Fixnum, value_class: Symbol)
+    filtered, errors = hf.filter("f1" => :v1)
+    assert_equal ({"f1" => :key_class}), errors.symbolic
+  end
+  
+end

data/spec/spec_helper.rb

@@ -1,5 +1,5 @@
 require 'minitest/unit'
-require 'minitest/pride'
+#require 'minitest/pride'
 require 'minitest/autorun'
 require 'pp'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mutations
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.5.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-29 00:00:00.000000000 Z
+date: 2013-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -92,6 +92,7 @@ files:
 - spec/command_spec.rb
 - spec/default_spec.rb
 - spec/errors_spec.rb
+- spec/hash_filter_spec.rb
 - spec/inheritance_spec.rb
 - spec/integer_filter_spec.rb
 - spec/model_filter_spec.rb