mutations 0.5.3 → 0.5.4

data/lib/mutations/hash_filter.rb

@@ -2,30 +2,17 @@ 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)
       
-      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
+      @optional_inputs = {}
+      @required_inputs = {}
+      @current_inputs = @required_inputs
       
       if block_given?
         instance_eval &block
@@ -40,21 +27,16 @@ 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
@@ -82,9 +64,6 @@ 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
     
@@ -117,47 +96,50 @@ module Mutations
       
       errors = ErrorHash.new
       filtered_data = HashWithIndifferentAccess.new
+      wildcard_filterer = nil
       
-      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)
+      [[@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]
+          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
-              errors[k_string] = ErrorAtom.new(k_string, :value_class)
+              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
         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)
+      end
       
-              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
+      if wildcard_filterer
+        filtered_keys = data.keys - filtered_data.keys
+        
+        filtered_keys.each do |key|
+          data_element = data[key]
+          sub_data, sub_error = wildcard_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
         end
       end

data/lib/mutations/version.rb

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

data/spec/hash_filter_spec.rb

@@ -19,23 +19,31 @@ describe "Mutations::HashFilter" do
     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
+  it "allows wildcards in hashes" do
+    hf = Mutations::HashFilter.new do
+      string :*
+    end
+    filtered, errors = hf.filter(foo: "bar", baz: "ban")
+    assert_equal ({"foo" => "bar", "baz" => "ban"}), 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
+  it "doesn't allow wildcards in hashes" do
+    hf = Mutations::HashFilter.new do
+      string :*
+    end
+    filtered, errors = hf.filter(foo: nil)
+    assert_equal ({"foo" => :nils}), 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
+  it "allows a mix of specific keys and then wildcards" do
+    hf = Mutations::HashFilter.new do
+      string :foo
+      integer :*
+    end
+    filtered, errors = hf.filter(foo: "bar", baz: "4")
+    assert_equal ({"foo" => "bar", "baz" => 4}), filtered
+    assert_equal nil, errors
   end
   
 end

data/spec/spec_helper.rb

@@ -1,5 +1,4 @@
 require 'minitest/unit'
-#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.3
+  version: 0.5.4
   prerelease: 
 platform: ruby
 authors: